天天看點
傳回

【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類型預設為空字元串
  • 數組屬于值類型，當對其進行拷貝并修改副本值時，并不會改變原來的值

定義方法：

1 //第一種
 2 //var <數組名稱> [<數組長度>]<數組元素>
 3 var arr [2]int
 4     arr[0]=1
 5     arr[1]=2
 6 
 7 //第二種
 8 var a []int
 9 a = make([]int, 4)
10 
11 //第三種
12 //var <數組名稱> = [<數組長度>]<數組元素>{元素1,元素2,...}
13 var arr = [2]int{1,2}
14 //或者
15 arr := [2]int{1,2}
16 
17 //第四種
18 //var <數組名稱> [<數組長度>]<數組元素> = [...]<元素類型>{元素1,元素2,...}
19 var arr = [...]int{1,2}
20 //或者
21 arr := [...]int{1,2}
22 
23 //第五種
24 //var <數組名稱> [<數組長度>]<數組元素> = [...]<元素類型>{索引1:元素1,索引2:元素2,...}
25 var arr = [...]int{1:1,0:2}
26 //或者
27 arr := [...]int{1:1,0:2}

數組周遊 

1 package main
 2 
 3 import "fmt"
 4 
 5 func main()  {
 6     var arr = [...] int {0:2,1:4,2:8}
 7 
 8     for i := 0; i<len(arr); i++ {
 9         fmt.Println(arr[i])
10     }
11 
12 
13     }//結果：2,4,8
【GO語言】數組、切片、map
【GO語言】數組、切片、map
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

使用函數修改數組元素

【GO語言】數組、切片、map
【GO語言】數組、切片、map
1 package main
 2 
 3 import (
 4 "fmt"
 5 )
 6 
 7 func fab(n int) {
 8     var a []int
 9     a = make([]int, n)
10 
11     a[0] = 1
12     a[1] = 1
13 
14     for i := 2; i < n; i++ {
15         a[i] = a[i-1] + a[i-2]
16     }
17     for _, v := range a {
18         fmt.Println(v)
19     }
20 }
21 
22 func main() {
23     fab(5)
24 }

斐波那契數列

多元數組

多元數組，相當于多添加了維數

1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6     var a [5][4][3] int  //三維數組
 7     a[1][1][0]=1
 8     a[1][0][0]=1
 9     a[1][1][1]=1
10     fmt.Println(a)
11 }

切片

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

切片的特性和數組一樣，是以周遊、長度計算等和數組一樣

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

1 //方式一，使用make建立
 2 slice1 := make([]type, len,capacity)  或者var slice1 []type = make([]type, len,capacity)//其中capacity(容量)為可選參數
 3 
 4 //方式二,直接初始化
 5 slice2 :=[] int {1,2} //長度為2，容量為2
 6 
 7 //方式三，從數組中擷取切片，與python一樣
 8 slice3 := arr[startIndex:endIndex] //将arr數組中從下标startIndex到endIndex-1下的元素建立為一個新的切片
 9 slice4 := arr[startIndex:]         //預設endIndex時将表示一直到arr數組的最後一個元素
10 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初始化配置設定記憶體。

1 //隻聲明不初始化，直接使用會panic，需要使用make配置設定記憶體後方可使用
 2 var a map[keytype]valuetype
 3 var a map[string]string
 4 var a map[string]int
 5 var a map[int]string
 6 var a map[string]map[string]string　
 7 
 8 //聲明并初始化
 9 var a map[string]string
10 a = make(map[string]string, 8) //8代表容量
11 
12 a := make(map[string]string, 8)
13 a := make(map[string]string)
14 
15 var a map[string]string = map[string]string{}
16 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])
   }
}
Go語言開發
上一篇: 【go語言】結構體、連結清單
下一篇: 團隊開發沖刺1.3（2015.5.11）

繼續閱讀