快速入門GO語言之Lesson01-函數

一、GO語言函數定義

Go 語言最少有個 main() 函數。可以通過函數來劃分不同功能，邏輯上每個函數執行的是指定的任務。函數聲明告訴了編譯器函數的名稱，返回類型，和參數。Go 語言標準庫提供了多種可動用的內置的函數。

func function_name( [parameter list] ) [return_types] {
   函數體
}
func：函數由 func 開始聲明
function_name：函數名稱，函數名和參數列表一起構成了函數簽名。
parameter list：參數列表，參數就像一個佔位符，當函數被調用時，你可以將值傳遞給參數，這個值被稱爲實際參數。參數列表指定的是參數類型、順序、及參數個數。參數是可選的，也就是說函數也可以不包含參數。
return_types：返回類型，函數返回一列值。return_types 是該列值的數據類型。有些功能不需要返回值，這種情況下 return_types 不是必須的。
函數體：函數定義的代碼集合。
From https://www.runoob.com/

二、帶參與無參函數

2.1 函數定義

定義函數時，在函數後面()定義的參數叫做形參，參數傳遞只能由實參傳遞給形參，單向傳遞。

無參數無返回值函數
func MyFunc() {
	a := 10
	fmt.Printf("a = %d\n", a)
}

有參數無返回值函數
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

有參數無返回值函數
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

func MyFunc02(b, c int) {
	fmt.Printf("b = %d,c = %d\n", b, c)
}

不定參數列表
...int 不定參數類型
傳遞的實參可以是0或者多個
固定參數一定要傳參數，固定參數可以不傳
接收main()函數的
func MyFunc03(args ...int) {
	//獲取用戶參數傳遞的個數
	fmt.Printf("len(args) = %d\n", len(args))
	for i := 0; i < len(args); i++ {
		fmt.Printf("args[%d] = %d\n", i, args[i])
	}
	fmt.Printf("*****************\n")
	//返回兩個值，第一個是下標，第二個是下標所對應的數
	for i, data := range args {
		fmt.Printf("args[%d] = %d\n", i, data)
	}
}

2.2 完整實踐代碼

package main

import "fmt"

// 1、函數定義聲明
// Go 語言最少有個 main() 函數。
// 可以通過函數來劃分不同功能，邏輯上每個函數執行的是指定的任務。
// 函數聲明告訴了編譯器函數的名稱，返回類型，和參數。
// Go 語言標準庫提供了多種可動用的內置的函數。

//2、普通參數列表
//定義函數時，在函數後面()定義的參數叫做形參
//參數傳遞，只能由實參傳遞給形參，單向傳遞

//無參數無返回值函數
func MyFunc() {
	a := 10
	fmt.Printf("a = %d\n", a)
}

//有參數無返回值函數
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

func MyFunc02(b, c int) {
	fmt.Printf("b = %d,c = %d\n", b, c)
}

//3、不定參數列表
//...int 不定參數類型
//傳遞的實參可以是0或者多個
//固定參數一定要傳參數，固定參數可以不傳
//接收main()函數的
func MyFunc03(args ...int) {
	//獲取用戶參數傳遞的個數
	fmt.Printf("len(args) = %d\n", len(args))
	for i := 0; i < len(args); i++ {
		fmt.Printf("args[%d] = %d\n", i, args[i])
	}
	fmt.Printf("*****************\n")
	//返回兩個值，第一個是下標，第二個是下標所對應的數
	for i, data := range args {
		fmt.Printf("args[%d] = %d\n", i, data)
	}
}

//接收Transform(args ...int)傳過來的參數並打印
func MyFunc04(temp ...int) {
	for _, data := range temp {
		fmt.Printf("data = %d\n", data)
	}
}

//接收Transform(args ...int)傳過來的參數並打印
func MyFunc05(temp ...int) {
	for _, data := range temp {
		fmt.Printf("data = %d\n", data)
	}
}

//傳送參數到MyFunc04(temp ...int)和MyFunc05(temp ...int)
func Transform(args ...int) {
	//全部元素傳遞給MyFunc04()
	MyFunc04(args...)

	//[1到3]部分元素傳遞給MyFunc05()
	MyFunc05(args[1:3]...)
}

func main() {
	//調用MyFunc（）函數
	MyFunc()
	//調用MyFunc01（）函數
	MyFunc01(20)
	MyFunc02(30, 40)

	//調用MyFunc03（）函數
	MyFunc03(1, 2, 3, 4, 5, 6, 7)

	//調用Transform() 函數
	Transform(1, 2, 3, 4, 5)
}
運行結果
a = 10
b = 20
b = 30,c = 40
len(args) = 7
args[0] = 1
args[1] = 2
args[2] = 3
args[3] = 4
args[4] = 5
args[5] = 6
args[6] = 7
*****************
args[0] = 1
args[1] = 2
args[2] = 3
args[3] = 4
args[4] = 5
args[5] = 6
args[6] = 7
data = 1
data = 2
data = 3
data = 4
data = 5
data = 2
data = 3

三、自定義函數

3.1 函數定義

函數聲明包括函數名、形式參數列表、返回值列表（可省略）以及函數體。
無參有返回值：只有一個返回值。
有返回值的函數，需要通過return中斷函數，通過return返回。
有參返回值，可以有多個返回值。

func 函數名(形式參數列表)(返回值列表){
    函數體
}

無參數無返回值函數
func MyFunc() {
	a := 10
	fmt.Printf("a = %d\n", a)

有參數無返回值函數
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

有參數無返回值函數
func MyFunc02(b, c int) {
	fmt.Printf("b = %d,c = %d\n", b, c)
}

返回一個int 10
func MyFunc06() int {
	return 10
}

給返回值起一個變量名
func MyFunc07() (result int) {
	return 10
}

返回多個參數
func MyFunc08() (a int, b int, c int) {
	a, b, c = 1, 2, 3
	return
}

3.2 完整實踐代碼

package main

import "fmt"

/* 1、函數定義聲明
函數聲明包括函數名、形式參數列表、返回值列表（可省略）以及函數體。
func 函數名(形式參數列表)(返回值列表){
    函數體
}*/

/*2、普通參數函數
定義函數時，在函數後面()定義的參數叫做形參
參數傳遞，只能由實參傳遞給形參，單向傳遞
*/

//無參數無返回值函數
func MyFunc() {
	a := 10
	fmt.Printf("a = %d\n", a)
}

//有參數無返回值函數
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

//有參數無返回值函數
func MyFunc02(b, c int) {
	fmt.Printf("b = %d,c = %d\n", b, c)
}

//接收main()傳來的不定參數
func MyFunc03(args ...int) {
	//獲取用戶參數傳遞的個數
	fmt.Printf("len(args) = %d\n", len(args))
	for i := 0; i < len(args); i++ {
		fmt.Printf("args[%d] = %d\n", i, args[i])
	}
	fmt.Printf("*****************\n")
	//返回兩個值，第一個是下標，第二個是下標所對應的數
	for i, data := range args {
		fmt.Printf("args[%d] = %d\n", i, data)
	}
}

//接收Transform(args ...int)傳來的參數
func MyFunc04(temp ...int) {
	for _, data := range temp {
		fmt.Printf("data = %d\n", data)
	}
}

//接收Transform(args ...int)傳來的參數
func MyFunc05(temp ...int) {
	for _, data := range temp {
		fmt.Printf("data = %d\n", data)
	}
}

//傳遞參數給MyFunc04(temp ...int)和MyFunc05(temp ...int)
func Transform(args ...int) {
	//全部元素傳遞給MyFunc04()
	MyFunc04(args...)
	//[1到3]部分元素傳遞給MyFunc05()
	MyFunc05(args[1:3]...)
}

/*3、返回值函數
無參有返回值：只有一個返回值
有返回值的函數，需要通過return中斷函數，通過return返回
有參返回值，可以有多個返回值
*/

//返回一個int 10
func MyFunc06() int {
	return 10
}

//給返回值起一個變量名
func MyFunc07() (result int) {
	return 10
}

//返回多個參數
func MyFunc08() (a int, b int, c int) {
	a, b, c = 1, 2, 3
	return
}

func main() {
	//調用MyFunc（）函數
	MyFunc()
	//調用MyFunc01（）函數
	MyFunc01(20)
	MyFunc02(30, 40)
	fmt.Printf("*****************\n")
	//調用MyFunc03（）函數
	MyFunc03(1, 2, 3, 4, 5, 6, 7)
	fmt.Printf("*****************\n")
	//調用Transform() 函數
	Transform(1, 2, 3, 4, 5)
	fmt.Printf("*****************\n")
	//調用MyFunc06（）函數
	var a int
	a = MyFunc06()
	fmt.Printf("a = %d\n", a)
	fmt.Printf("*****************\n")
	//調用MyFunc07（）函數
	fmt.Printf("result = %d\n", MyFunc07())
	fmt.Printf("*****************\n")
	//調用MyFunc08（）函數
	d, e, f := MyFunc08()
	fmt.Printf("a = %d,b = %d,c = %d\n", d, e, f)
}

運行結果
a = 10
b = 20
b = 30,c = 40
*****************
len(args) = 7
args[0] = 1
args[1] = 2
args[2] = 3
args[3] = 4
args[4] = 5
args[5] = 6
args[6] = 7
*****************
args[0] = 1
args[1] = 2
args[2] = 3
args[3] = 4
args[4] = 5
args[5] = 6
args[6] = 7
*****************
data = 1
data = 2
data = 3
data = 4
data = 5
data = 2
data = 3
*****************
a = 10
*****************
result = 10

四、遞歸函數

4.1 遞歸函數的定義：通過調用自己實現遞歸。

4.2 普通函數與遞歸函數的調用過程對比（圖片來自某視頻教程）

4.3實踐代碼

package main

import "fmt"

func test(a int) {
	if a == 1 {
		fmt.Println("a = ", a)
		return //終止函數條用
	}
	test(a - 1) //調用函數本身
	fmt.Println("a = ", a)
}
func main() {
	test(3)
	fmt.Println("main")
}
運行結果
a =  1
a =  2
a =  3
main

五、匿名函數

5.1 匿名函數的定義

匿名函數沒有函數名，只有函數體。函數可以作爲一種類型被賦值給變量，匿名函數也往往以變量方式被傳遞。
匿名函數經常被用於實現回調函數和閉包等。

匿名函數，沒有函數名字和函數定義以及調用
	f1 := func() {
		fmt.Println("a = ", a)
		fmt.Println("str = ", str)
	}
	f1() //執行函數

```go
定義匿名函數，同時調用
	func() {
		fmt.Printf("a = %d,str = %s\n", a, str)
	}() //後面的()代表調用此匿名函數

定義帶參數的匿名函數，同時調用
	func(i, j int) {
		fmt.Printf("i = %d,j = %d\n", i, j)
	}(10, 20)

定義帶兩個參數的匿名函數，同時調用
	x, y := func(i, j int) (max, min int) {
		if i > j {
			max = i
			min = j

		} else {
			max = j
			min = i
		}

		return

	}(10, 20)
	fmt.Printf("x = %d,y = %d\n", x, y)

5.2 實踐代碼

package main

import "fmt"

func main() {
	a := 10
	str := "mike"
	//匿名函數，沒有函數名字和函數定義以及調用
	f1 := func() {
		fmt.Println("a = ", a)
		fmt.Println("str = ", str)
	}
	f1() //執行函數

	//給一個函數起別名
	type funcType func() //函數沒有參數，沒有返回值
	//聲明變量
	var f2 funcType
	f2 = f1
	f2()

	//定義匿名函數，同時調用
	func() {
		fmt.Printf("a = %d,str = %s\n", a, str)
	}() //後面的()代表調用此匿名函數

	//定義帶參數的匿名函數，同時調用
	func(i, j int) {
		fmt.Printf("i = %d,j = %d\n", i, j)
	}(10, 20)

	//定義帶兩個參數的匿名函數，同時調用
	x, y := func(i, j int) (max, min int) {
		if i > j {
			max = i
			min = j

		} else {
			max = j
			min = i
		}

		return

	}(10, 20)
	fmt.Printf("x = %d,y = %d\n", x, y)
}

運行結果
a =  10
str =  mike
a =  10
str =  mike
a = 10,str = mike
i = 10,j = 20
x = 20,y = 10