Go Array數組

數組是固定長度的特定類型元素組成的序列。

一個數字由零或多個元素組成。

數組的長度是固定，因此Go更常用Slice（切片，動態增長或收縮序列）。

數組是值類型，用索引下標訪問每個元素，范圍是0~len(數組)-1，訪問越界會panic異常

注意：賦值和傳參是復制整個數組而不是指針

//接收數組參數
func test(x [2]int){
  fmt.Printf("x: %p,%v\n",&x,x)
}

//對數組賦值語句
func main(){
  a:=[2]int{10,20}
  var b [2]int//初始化數組b
  b=a//a的值復制拷貝給b
  fmt.Printf("a: %p,%v\n",&a,a)
  fmt.Printf("b: %p,%v\n",&b,b)

  test(a)
}

　　實例

package main

import (
    "fmt"
)

func main() {
    /*
        定義數組
        var 數組名 [數組大小]數據類型
        var a1 [5]int

        定義數組后，5個元素都有默認值 0

        數組賦值方式
        a[0]=1
        a[1]=2

        數組的第一個元素的地址，就是數組的首地址
        數組各個元素地址間隔根據數組的數據類型決定,int64 8字節  int32 4字節
    */
    var intArr [5]int
    fmt.Println("intArr默認值是：", intArr)
    intArr[0] = 1
    intArr[1] = 2
    intArr[2] = 3
    fmt.Println("intArr賦值后的值是：", intArr)
    fmt.Printf("intArr數組地址是=%p\n", &intArr)
    fmt.Printf("intArr數組第一個元素地址是=%p\n", &intArr[0])
    fmt.Printf("intArr數組第二個元素地址是=%p\n", &intArr[1])
    fmt.Printf("intArr數組第三個元素地址是=%p\n", &intArr[2])

    //(全局聲明)
    //聲明賦值方式
    var a1 [5]string = [5]string{"大貓", "二狗"}
    //自動類型推導,未賦值的有默認值
    var a2 = [5]int{1, 2, 3}
    //自動判斷數組長度
    var a3 = [...]int{1, 2, 3, 4, 5}
    //指定索引賦值元素
    var a4 = [...]string{3: "狗蛋", 6: "貓屎"}
    //結構體類型數組
    var a5 = [...]struct {
        name string
        age  int
    }{
        {"王麻子", 10},
        {"呂秀才", 29},
    }
    fmt.Println(a1)
    fmt.Println(a2)
    fmt.Println(a3)
    fmt.Println(a4)
    fmt.Println(a5)
}

　　運行結果

GOROOT=/usr/local/go #gosetup
GOPATH=/Users/yuchao/go #gosetup
/usr/local/go/bin/go build -o /private/var/folders/dd/1j1pbw895772hqp2d2gfg00c0000gn/T/___go_build_main_go /Users/yuchao/go/src/gostudy/gobook/main.go #gosetup
/private/var/folders/dd/1j1pbw895772hqp2d2gfg00c0000gn/T/___go_build_main_go #gosetup
intArr默認值是： [0 0 0 0 0]
intArr賦值后的值是： [1 2 3 0 0]
intArr數組地址是=0xc42001c090
intArr數組第一個元素地址是=0xc42001c090
intArr數組第二個元素地址是=0xc42001c098
intArr數組第三個元素地址是=0xc42001c0a0
[大貓 二狗   ]
[1 2 3 0 0]
[1 2 3 4 5]
[   狗蛋   貓屎]
[{王麻子 10} {呂秀才 29}]

Process finished with exit code 0

　　

遍歷數組

package main

import "fmt"

func main() {
    var a1 = [...]int{1, 2, 3, 4, 5, 6}
    //通過索引取值
    for i := 0; i < len(a1); i++ {
        fmt.Println(a1[i])
    }

    //for循環遍歷數組，索引和值,index可以省略用占位符_
    for index, value := range a1 {
        fmt.Println(index, value)
    }

}

　　

數組使用細節

package main

import "fmt"

func main() {
    //數組是多個相同類型數據的組合，且長度固定，無法擴容
    var a1 [3]int
    a1[0] = 1
    a1[1] = 11
    //必須賦值int類型數據，否則報錯
    //a1[2] = 111.1

    //不得超出索引
    //a1[3]=111
    fmt.Println(a1)//有默認值[1 11 0]
}

　　

數組使用步驟：

1. 聲明數組
2. 給數組元素賦值
3. 使用數組
4. 數組索引從0開始，且不得越界否則panic
5. Go數組是值類型，變量傳遞默認是值傳遞，因此會進行值拷貝
6. 修改原本的數組，可以使用引用傳遞（指針），避免數據復制

package main

import (
    "fmt"
)

//函數接收值類型，默認有值拷貝
func test(arr [3]int) {
    arr[0] = 66
}

//函數修改原本數組，需要使用引用傳遞
func test2(arr *[3]int) {
    (*arr)[0] = 66 //可以縮寫arr[0]=66 編譯器自動識別,arr是指針類型
}

func main() {
    //聲明arr數組，需要考慮傳遞函數參數時，數組的長度一致性
    arr := [3]int{11, 22, 33}
    //test函數不會修改數組
    test(arr)
    fmt.Println(arr)
    //test2修改了數組
    test2(&arr)
    fmt.Println(arr)
}

　　

指針概念

指針數組： 元素為指針類型的數組

數組指針： 獲取變量數組變量的地址