Go 語言切片是對陣列的抽象。

Go 陣列的長度不可改變，在特定場景中這樣的集合就不太適用，Go中提供了一種靈活，功能強悍的內建型別切片(“動態陣列”),與陣列相比切片的長度是不固定的，可以追加元素，在追加時可能使切片的容量增大。

• 定義一個未指定大小的切片var identifier []type 或者用make()函式來建立切片var slice1 []type = make([]type, len) 或者簡寫為slice1 := make([]type, len)
• 指定容量，capacity引數可選 make([]T, length, capacity)
• 切片初始化s :=[] int {1,2,3 }

s :=[] int {1,2,3 }
初始化切片s,是陣列arr的引用

s := arr[:] 
將arr中從下標startIndex到endIndex-1 下的元素建立為一個新的切片

s := arr[startIndex:endIndex] 
將arr中從下標startIndex到最後一個元素建立為一個新的切片

s := arr[startIndex:] 
預設startIndex時將表示從arr的第一個元素開始

s := arr[:endIndex] 


s1 := s[startIndex:endIndex] 
通過切片s初始化切片s1


s :=make([]int
 
,len,cap) 
通過內建函式make()初始化切片s,[]int 標識為其元素型別為int的切片

• len() 和 cap() 函式分別測陣列的長度和最長能達到多少
• 個切片在未初始化之前預設為 nil，長度為 0，cap為0
• 切片擷取

  numbers := []int{0,1,2,3,4,5,6,7,8}   
   /* 列印子切片從索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

• append() 和 copy() 函式 如果想增加切片的容量，我們必須建立一個新的更大的切片並把原分片的內容都拷貝過來。

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允許追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片新增一個元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同時新增多個元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 建立切片 numbers1 是之前切片的兩倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷貝 numbers 的內容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

• range Go 語言中 range 關鍵字用於 for 迴圈中迭代陣列(array)、切片(slice)、通道(channel)或集合(map)的元素。在陣列和切片中它返回元素的索引和索引對應的值，在集合中返回 key-value 對的 key 值。

package main
import "fmt"
func main() {
    //這是我們使用range去求一個slice的和。使用陣列跟這個很類似
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
    //如果將for後面的_去掉，結果是6
    //這是因為 for _ 表示遍歷陣列的下標，從nums[0]，nums[1]，nums[2]依次開始遍歷，
    //所以最後的值為sum=2+3+4=9；但是如果把 for _ 去掉，就變成了遍歷0 1 2，所以sum=0+1+2=3。
        sum += num
    }
    fmt.Println("sum:", sum)
    //在陣列上使用range將傳入index和值兩個變數。上面那個例子我們不需要使用該元素的序號，所以我們使用空白符"_"省略了。有時侯我們確實需要知道它的索引。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    //range也可以用在map的鍵值對上。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    //range也可以用來列舉Unicode字串。第一個引數是字元的索引，第二個是字元（Unicode的值）本身。
    for i, c := range "go" {
    //這段程式碼中 i 表示陣列小標，從0開始計數，c表示字元所對應的ASCII值，
    //所以遍歷 [hello]這個字元陣列，得到了每個陣列下標下的字元所對應的ASCII值。
        fmt.Println(i, c)
    }
}

• 集合 1.map建立

//make（）函式建立
var mymap  map[string]string /*建立集合 */
    mymap  = make(map[string]string)

map關鍵字建立
 mymap  := map[string]string{"France": "Paris", "Italy": "Rome", 
 "Japan": "Tokyo", "India": "New delhi"}

• 向map中新增資料

    mymap  [ "France" ] = "Paris"
    mymap  [ "Italy" ] = "羅馬"
    mymap  [ "Japan" ] = "東京"
    mymap  [ "India " ] = "新德里"

• map的遍歷

    /*使用鍵輸出地圖值 */ for country := range countryCapitalMap {
        fmt.Println(country, "首都是", mymap  [country])
    }

• 刪除元素delete(mymap , "France")

• 遞迴函式

func recursion() {
   recursion() /* 函式呼叫自身 */
}

func main() {
   recursion()
}

• go語言遞迴函式應用

package main

import "fmt"

func Factorial(n uint64)(result uint64) {
    if (n > 0) {
        result = n * Factorial(n-1)
        return result
    }
    return 1
}

func main() {  
    var i int = 15
    fmt.Printf("%d 的階乘是 %d\n", i, Factorial(uint64(i)))
}
sout  : 15 的階乘是 1307674368000