go第4天

                                                       內置函數

1. close：主要用來關閉channel
2. len：用來求長度，比如string，array，slice，map，channel
3. new：用來分配內存，主要用來分配值類型，比如int、struct。返回的是指針
4. make：用來分配內存，主要用來分配引用類型，比如chan、map、slice
5. append：用來追加元素到數組、slice中
6. panic和recover：用來做錯誤處理

                                                       遞歸函數

1. 一個函數調用自己就叫做遞歸

   package main
   
   import (
   	"fmt"
   )
   
   func calc(n int) int {
   	if n == 1 {
   		return 1
   	}
   	return calc(n-1) * n
   }
   
   func main() {
   	n := calc(5)
   	fmt.Println(n) //120
   	//分析：第1次進來是5即calc(5)，返回calc(4)*5
   	//分析：第2次進來是4即calc(4)，返回calc(3)*4
   	//分析：第3次進來是3即calc(3)，返回calc(2)*3
   	//分析：第4次進來是2即calc(2)，返回calc(1)*2
   	//分析：第5次進來是1即calc(1)，返回1
   	//calc(1) = 1
   	//calc(2) = 2
   	//calc(3) = 6
   	//calc(4) = 24
   	//calc(5) = 120
   }
   

    

2. 斐波那契數

   package main
   
   import (
   	"fmt"
   )
   
   func fab(n int) int {
   	if n <= 2 {
   		return 1
   	}
   	return fab(n-1) + fab(n-2)
   }
   
   func main() {
   
   	for i := 1; i < 10; i++ {
   		n := fab(i)
   		fmt.Println(n)
   	}
   }
   

    

3. 遞歸的設計原則

   1.一個大的問題能夠分解成相似的小問題
   2.定義好出口條件

                                                        閉包

 

1. 一個函數和與其相關的引用環境組合而成的實體
2. 閉包的例子

   package main
   
   import (
   	"fmt"
   	"strings"
   )
   
   func makeSuffixFunc(suffix string) func(string) string {
   	return func(name string) string {
   		if !strings.HasSuffix(name, suffix) {
   			return name + suffix
   		}
   		return name
   	}
   }
   func main() {
   
   	func1 := makeSuffixFunc(".bmp")
   	func2 := makeSuffixFunc(".jpg")
   	fmt.Println(func1("test"))  //test.bmp
   	fmt.Println(func2("test"))  //test.jpg
   	fmt.Println(func1("test1")) //test1.bmp
   	fmt.Println(func2("test2")) //test2.jpg
   }
   

                                                   數組與切片

 

1. 數組定義：var a[len]int
2. 長度是數組的一部分，因此，var a[5]int和var a[0]int是不同的類型
3. 數組是值類型，因此改變副本的值，不會改變本身的值
4. 數組初始化

   a.  var age0 [5]int = [5]int{1, 2, 3}
   b.  var age1 = [5]int{1, 2, 3}
   c.  var age2 = [...]int{1, 2, 3}
   d.  var str = [5]string{3: "hello world", 4: "tom"}

    

5. 多維數組

   var age [5][3]int
   var f [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}

                                                            切片

 

1. 切片是數組的一個引用，因此切片是引用類型
2. 切片的長度可以改變，因此切片是一個可變數組
3. 切片的定義：var 變量名 []類型，比如var str []string，var arr []int
4. 切片初始化：var slice []int = arr[start:end]，包含start到end但不包含end，start爲0是可以省略，end爲len(arr)時可以省略。
5. 如果要切片最後一個元素去掉，可以這樣寫：slice = slice[:len(slice)-1]
6. 通過make來創建切片

   var slice []type = make([]type,len)
   slice:=make([]type,len)
   slice:=make([]type,len,cap)

    

7. 用append內置函數操作切片，for range遍歷切片，copy拷貝切片

8. string底層就是要給byte數組，因此，也可以進行切片操作

   	str := "hello world"
   	s1 := str[0:5]
   	s2 := str[5:]

    

9. 排序和查找操作：排序操作主要在sort包中，sort.Ints對整數進行排序，sort.Strings對字符串進行排序，sort.Float64對浮點數進行排序。sort.SearchInts(a []int,b int)從數組a中查找b，a必須有序，sort.SearchFloats(a []float64,b float64)從數組a中查找b，a必須有序，sort.SearchStrings(a []Strings,b Strings)從數組a中查找b，a必須有序

                                                    map數據結構

1.  聲明：var 名稱 map[type]type
2. map相關操作

   var a map[string]string = map[string]string{"hello": "wold"}
   a = make(map[string]string, 10)
   a["hello"] = "world"  //插入或更新
   val, ok := a["hello"] //查找
   for k, v := range a {
   } //遍歷
   delete(a, "hello") //刪除
   len(a)             //長度

    

3. map是引用類型
4. map的切片：items:=make([]map[int]int,5)