一、函式的閉包基本內容

 1 package main
 2 
 3 import "fmt"
 4 
 5 // 閉包 ： 一個函式與其相關的引用環境組合而成的實體
 6 
 7 //Adder 這個函式的返回值為一個型別為func(int) int的函式 這就是組成了一個閉包
 8 func Adder() func(int) int {
 9     var x int
10     return func(d int) int {
11         x += d
12         return x
13     }
14 }
15 func main() {
16     //注意 "f = Adder()" 和 "f = Adder" 的區別
 

17     var f = Adder() //這裡其實是返回到那個匿名函式 f稱之為這個匿名函式的閉包
18 
19     fmt.Println(f(1))
20     fmt.Println(f(20))
21     fmt.Println(f(300))
22     //因為f還是在生命週期內，所以以上三個呼叫Adder中，並且公用一個x
23 
24     //呼叫f函式不寫引數會報錯
25     //fmt.Println(f())
26 
27     //新開一個閉包，這裡面是的是f1的x
28     var f1 = Adder()
29     fmt.Println("f1（500）的值為：",f1(500))
 
30     fmt.Println("f1（20）的值為：",f1(20))
31     //兩者之間的x互不影響
32     fmt.Println("f（40）的值為：",f(40))
33 
34 }

二、案例一

 1 package main
 2 
 3 //閉包的例子2
 4 func add(num int) func(int) int {
 5     return func(i int) int {
 6         return i + num
 7     }
 8 }
 9 
10 func main() {
11     f := add(10)
12     println(f(10),f(20),f(2)) //
 
思考思考輸出是什麼呢？
13 
14     f1 := add(200)
15     println(f1(10))
16     println(f1(20))
17     println(f1(-12))
18 }

三、案例二

 1 package main
 2 
 3 import "time"
 4 
 5 func main() {
 6     //上面這個匿名函式一直使用的是外面的i
 7     for i:=0; i<5; i++ {
 8         go func() {
 9             println(i)
10         }()
11     }
12     time.Sleep(time.Second*1)
13     println("-------上面執行結束--------")
14 
15     //這裡是將i作為引數傳入閉包函式
16     for i:=0; i<5; i++ {
17         go func(index int) {
18             println(index)
19         }(i)
20     }
21     time.Sleep(time.Second*1)
22     println("-------下面執行結束--------")
23 }

四、案例三 -字尾匹配

 1 package main
 2 
 3 import "strings"
 4 
 5 //判斷後綴 Suffix函式傳一個字尾，匹配name是否有這個字尾 如果沒有就加上
 6 func SuffixFunc(str string) func(string) string {
 7     return func(name string) string {
 8         if !strings.HasSuffix(name,str) {
 9             return name + str
10         }
11         return name
12     }
13 }
14 //上面的函式可以寫成下面這樣子 意思差不多吧
15 func hasSuffix(str string, rear string) string {
16     if !strings.HasSuffix(str, rear) {
17         return str + rear
18     }
19     return str
20 }
21 func main() {
22     suffix1 := SuffixFunc(".jpg")
23     suffix2 := SuffixFunc(".png")
24 
25     println(suffix1("001"))
26     println(suffix1("002.jpg"))
27     println(suffix2("003"))
28     println(suffix2("004.png"))
29 
30     println("非常的好用，就是麻煩了一點，例如我可以這樣子寫")
31 
32     str1 := "123"
33     str2 := "456.jpg"
34     rear := ".jpg"
35     //res := strings.HasSuffix(str1,rear) ? str1 : str1 + rear 居然不支援三目運算子？
36     println(hasSuffix(str1, rear))
37     println(hasSuffix(str2,rear))
38 }