go語言之行--數組、切片、map

一、內置函數

• append ：追加元素到slice里,返回修改后的slice
• close ：關閉channel
• delete ：從map中刪除key對應的value
• panic  ： 用於異常處理，停止常規的goroutine
• recover ：用於異常處理，允許程序定義goroutine的panic動作
• imag ：返回復數(complex)的實部
• real  ： 返回復數(complex)的虛部
• make :用來分配內存，主要分配引用類型，返回Type本身(只能應用於slice, map, channel)
• new ：分配內存，主要分配值類型，返回指向Type的指針，如int
• cap  ：容量，容積capacity
• copy ：復制slice，返回復制的數目
• len ：返回長度

二、數組與切片

概念：同一組數據類型的固定長度的序列

注意：

• 長度數數組類型的一部分，因此var a[2] int 和 var a[3] int是不同的類型
• 數組索引是從0開始(python相同)，訪問超過了索引會panic
• 數組定義完成之后，每個位置會有默認值，int類型，默認值為0，string類型默認為空字符串
• 數組屬於值類型，當對其進行拷貝並修改副本值時，並不會改變原來的值

定義方法：

//第一種
//var <數組名稱> [<數組長度>]<數組元素>
var arr [2]int
    arr[0]=1
    arr[1]=2

//第二種
var a []int
a = make([]int, 4)

//第三種
//var <數組名稱> = [<數組長度>]<數組元素>{元素1,元素2,...}
var arr = [2]int{1,2}
//或者
arr := [2]int{1,2}

//第四種
//var <數組名稱> [<數組長度>]<數組元素> = [...]<元素類型>{元素1,元素2,...}
var arr = [...]int{1,2}
//或者
arr := [...]int{1,2}

//第五種
//var <數組名稱> [<數組長度>]<數組元素> = [...]<元素類型>{索引1:元素1,索引2:元素2,...}
var arr = [...]int{1:1,0:2}
//或者
arr := [...]int{1:1,0:2}

數組遍歷

package main

import "fmt"

func main()  {
    var arr = [...] int {0:2,1:4,2:8}

    for i := 0; i<len(arr); i++ {
        fmt.Println(arr[i])
    }


    }//結果：2,4,8

package main

import "fmt"

func test(a *[3] int )  { //傳遞地址
    (*a)[0]=100
    return
}

func main()  {
    var arr [3] int
    test(&arr)           //使用&取地址
    fmt.Println(arr[0])


    }//結果：100

package main

import (
"fmt"
)

func fab(n int) {
    var a []int
    a = make([]int, n)

    a[0] = 1
    a[1] = 1

    for i := 2; i < n; i++ {
        a[i] = a[i-1] + a[i-2]
    }
    for _, v := range a {
        fmt.Println(v)
    }
}

func main() {
    fab(5)
}

多維數組

多維數組，相當於多添加了維數

package main

import "fmt"

func main() {
    var a [5][4][3] int  //三維數組
    a[1][1][0]=1
    a[1][0][0]=1
    a[1][1][1]=1
    fmt.Println(a)
}

切片

概念：切片是對數組的引用，數組的長度不便，但是切片長度是可以變化的。

切片的特性和數組一樣，因此遍歷、長度計算等和數組一樣

切片定義和數組的定義方式在於是否有長度定義，有長度定義為數組、沒有長度定義為切片

//方式一，使用make創建
slice1 := make([]type, len,capacity)  或者var slice1 []type = make([]type, len,capacity)//其中capacity(容量)為可選參數

//方式二,直接初始化
slice2 :=[] int {1,2} //長度為2，容量為2

//方式三，從數組中獲取切片，與python一樣
slice3 := arr[startIndex:endIndex] //將arr數組中從下標startIndex到endIndex-1下的元素創建為一個新的切片
slice4 := arr[startIndex:]         //缺省endIndex時將表示一直到arr數組的最后一個元素
slice5 := arr[:endIndex]           //缺省startIndex時將表示從arr數組的第一個元素開始

切片操作

len：計算長度（長度是指已經被賦過值的最大下標+1）

cap：求容量（容量是指切片可容納的最多元素個數）

copy: 拷貝切片

append：向切片中追加元素

注意事項：

使用append向切片追加元素，如果長度沒超過定義的切片的長度，返回原來的切片地址，如果超過了長度，切片會擴容進行重新分配地址。

package main

import "fmt"

func main() {
    var slice2 [] int = make([] int,2,3)
    fmt.Println(len(slice2),cap(slice2))

}//結果 2，3

package main

import "fmt"

func main() {
    var slice1 [] int = make([] int,2,3)
    slice2 :=[] int {2,2,2}

    fmt.Printf("%p--%d\n",slice1,slice1)
    slice1=append(slice1,1)    //追加單個元素
    fmt.Printf("slice1:%p--%d\n",slice1,slice1)
    slice3 :=append(slice1,slice2...) //追加另一個切片
    fmt.Printf("slice3:%p--%d\n",slice3,slice3)
    slice4 := make([] int,len(slice3))
    copy(slice4,slice3)         //拷貝slice3
    fmt.Printf("copy：slice3:%p--%d\n",slice3,slice3)
    fmt.Printf("slice4:%p--%d\n",slice4,slice4)
}

空(nil)切片

一個切片在未初始化之前默認為 nil，長度為 0

 

三、map

概念：map是go語言內置key-value的數據結構，與python的dict類似，可稱為字典或關聯數組。

map聲明與初始化

map屬於引用類型，聲明是不會分配內存的，需要make初始化分配內存。

//只聲明不初始化，直接使用會panic，需要使用make分配內存后方可使用
var a map[keytype]valuetype
var a map[string]string
var a map[string]int
var a map[int]string
var a map[string]map[string]string　

//聲明並初始化
var a map[string]string
a = make(map[string]string, 8) //8代表容量

a := make(map[string]string, 8)
a := make(map[string]string)

var a map[string]string = map[string]string{}
var a map[string]string =map[string]string{"name":"wd","age":"22"}

map嵌套

map可以嵌套，類似json格式,聲明時候只需要將value改為map，同樣使用之前需要初始化每一層的map，示例：

package main

import "fmt"

func main() {
    a := make(map[string]map[string]string,10)  //二層map嵌套，聲明外層map並初始化
    a["key1"] = make(map[string]string) //初始化第二層map
    a["key1"]["key2"] = "a1"
    a["key1"]["key3"] = "b1"
    a["key1"]["key4"] = "c1"
    fmt.Println(a)
}

map操作

增刪改查、求長度

mymap["name"] = "wd"   // 創建或者更新
delete(mymap, "name")    // 刪除
name := mymap["name"]    // 查詢 
len(mymap)  // 求長度 //測試key是否存在
package main
import "fmt"
func main() {
    a := make(map[string]string,10)
    a["key1"] = "wd"
    val,ok := a["key1"]   //ok為true時，代表有key
    if ok{
        fmt.Println(val)
    }else {
        fmt.Println("key1 is not exist")
    }

}

遍歷map

package main

import (
    "fmt"
)

func main() {
    a := map[string]string{"NAME":"WD","AGE":"22"}
    for k :=range a{   //使用key進行遍歷
        fmt.Println(a[k])
    }
    for k,v :=range a{    //使用key，value進行遍歷
        fmt.Println(k,v)
    }
}

 切片嵌套map

package main

import "fmt"

func main() {
    a := map[string]string{"NAME":"WD","AGE":"22"} //初始化map
    b := make([]map[string]string,3,3)   //初始化切片
    b[0]=a
    fmt.Println(b)
}

 map排序

go語言中的map都是無序的，並且無內置排序方法，所有如果我們想要對map進行排序，我們需要自己實現。

方法：

• 先獲取所有的key，將key進行排序
• 按照排序好的key進行遍歷

package main

import (
    "fmt"
    "sort"
)

func main() {
   a:= map[string]string{"1":"a","2":"b","3":"c","4":"d"}
   var keys [] string
   for k := range a{
       keys = append(keys, k)
   }
   sort.Strings(keys)//排序切片key
   fmt.Println(keys,len(keys))
   for _,val := range keys{   //循環key取值
       fmt.Println(a[val])
   }
}