Go中函式、匿名函式和遞迴的使用

// code_005_functions project main.go
package main

import (
"fmt"
)

func Test1(a int, b, c string) (str3 string) {
fmt.Printf("%d, %s, %s", a, b, c)
return string(a) + b + c
}

func Test2() int {
i := 1
sum := 0
for i = 1; i <= 100; i++ {
sum += i
}
return sum
}

func Test3(num int) int {
//遞迴函式的使用
if num == 1 {
return 1
}
return num + Test3(num-1)
}

//函式作為引數傳遞，我們使用type來定義
//它的型別就是所有擁有相同的引數，相同的返回值的一種型別。
type FuncType func(int, int) int //func後面沒有函式名
func Calc(a, b int, f FuncType) (result int) {
result = f(a, b)
return
}
func Add(a, b int) int {
return a + b
}

func Minus(a, b int) int {
return a - b
}

func squares() func() int {
var x int
return func() int { //匿名函式
x++ //捕獲外部變數
return x * x
}
}

func main() {
//關鍵func、函式名、引數列表、返回值、函式體和返回語句
//函式名首字母小寫即為private，大寫即為public
//如果有返回值， 那麼必須在函式的內部新增return語句
str1 := Test1(11, "你好", "世界")
fmt.Println("\n" + str1)

//遞迴函式
sum := Test3(100)
fmt.Println(sum)

//函式作為引數傳遞
res1 := Calc(10, 20, Add)
res2 := Calc(100, 60, Minus)
fmt.Println(res1)
fmt.Println(res2)

//匿名函式與閉包
//所謂閉包就是一個函式“捕獲”了和它在同一作用域的其它常量和變數。
//這就意味著當閉包被呼叫的時候，不管在程式什麼地方呼叫，閉包能夠使用這些常量或者變數。
//它不關心這些捕獲了的變數和常量是否已經超出了作用域，所以只有閉包還在使用它，這些變數就還會存在。
//在Go語言裡，所有的匿名函式(Go語言規範中稱之為函式字面量)都是閉包。
str := "ck_god"
f1 := func() { //方式1：
fmt.Printf("哈哈哈,我是%s\n", str)
}
f1()
func() { //方式2：匿名函式
fmt.Println("不好意思，還是我")
}()

type FuncType func()
var f2 FuncType = f1
f2() //方式3：函式變數接收後呼叫

v := func(a, b int) (result int) {
result = a + b
return
}(1, 1) //方式4：有參有返回值的匿名函式
fmt.Println("v=", v)

//閉包捕獲外部變數特點:修改外部變數的值
fmt.Println("\n=========\n")
i := 10
str2 := "ck_god"
func() {
i = 100
str = "go"
fmt.Printf("內部:i = %d, str2 = %s\n", i, str2)
}()
fmt.Printf("外部:i = %d, str2 = %s\n", i, str2)

//匿名函式作為返回值
f := squares()
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
//我們看到變數的生命週期不由它的作用域決定：squares返回後，變數x仍然隱式的存在於f中
}