go 語言陣列

隱姓埋名4869發表於2022-03-24
Go陣列

Go 語言陣列

 

引言
  陣列是相同資料型別的一組資料的集合，陣列一旦定義長度不能修改，陣列可以通過下標（或者叫索引)來訪問元素。

  相對於去宣告 number0, number1, ..., number99 的變數，使用陣列形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易於擴充套件。
陣列元素可以通過索引（位置）來讀取（或者修改），索引從0 開始，第一個元素索引為 0，第二個索引為1，以此類推。

 

 

 

一、陣列的定義

1. 語法

var variable_name [SIZE] variable_type　　
variable_name:陣列的名稱
SIZE:陣列長度，必須是常量
variable_type:陣列儲存元素的型別

　　

2. 示例

package main

import "fmt"

func main() {
	var a [3]int    //定義一個int型別的陣列a，長度是3
	var b [2]string //定義一個字串型別的陣列b，長度是2

	fmt.Printf("a: %T\n", a) //使用%T來輸出型別
	fmt.Printf("b: %T\n", b)
	fmt.Printf("a: %v\n", a)
	fmt.Printf("b: %v\n", b)
}


//輸出結果如下，可以看到沒初始化的值，int是0，而字串則是空的字串
a: [3]int
b: [2]string
a: [0 0 0]
b: [ ]

　　

 

從上面執行的結果中可以看出來，陣列和長度和元素型別共同組成了陣列的型別

 

二、陣列的初始化

初始化，就是給陣列的元素賦值，沒有初始化的陣列，預設元素值都是零值，布林型別是false，字串是空字串。

1. 未初始化的陣列

package main

import "fmt"

func main() {
	var a [2]bool
	var b [2]int
	var c [3]string
	var d [3]float32

	fmt.Printf("a: %v\n", a)
	fmt.Printf("b: %v\n", b)
	fmt.Printf("c: %v\n", c)
	fmt.Printf("d: %v\n", d)

}


//輸出結果如下
a: [false false]
b: [0 0]
c: [  ]
d: [0 0 0]

　　

2. 使用初始化列表

package main

import "fmt"

func main() {
	var a = [3]int{1, 2, 3}
	var b = [2]string{"hello world"}
	var c = [2]bool{true, false}

	a1 := [2]int{1, 2} //型別推斷
	fmt.Printf("a: %v\n", a)
	fmt.Printf("b: %v\n", b)
	fmt.Printf("c: %v\n", c)
	fmt.Printf("a1: %v\n", a1)
}

//輸出結果如下
a: [1 2 3]
b: [hello world ]
c: [true false]
a1: [1 2]

　　

 

使用初始化列表，就是將值寫在大括號裡面

 

 

 

3. 省略陣列長度

如果陣列長度不確定，可以使用 ...代替陣列的長度，編譯器會根據元素個數自行推斷陣列的長度

package main

import "fmt"

func main() {
	var a = [...]int{1, 2, 3, 4, 5}
	var b = [...]string{"hello", "world", "hello", "go"}
	var c = [...]bool{true, false}

	a1 := [...]int{1, 2} //型別推斷

	fmt.Printf("a: %v\n", a)
	fmt.Printf("b: %v\n", b)
	fmt.Printf("c: %v\n", c)
	fmt.Printf("a1: %v\n", a1)
}

//輸出結果如下
a: [1 2 3 4 5]
b: [hello world hello go]
c: [true false]
a1: [1 2]

　　

 

4. 指定索引值的方式來初始化

可以通過指定所有方式來初始化，未指定的所有預設值為零值

package main

import "fmt"

func main() {
	var a = [...]int{0: 1, 2: 2}
	var b = [...]string{1: "hello", 2: "go"}
	var c = [...]bool{2: true, 5: false}

	a1 := [...]int{1, 2} //型別推斷

	fmt.Printf("a: %v\n", a)
	fmt.Printf("b: %v\n", b)
	fmt.Printf("c: %v\n", c)
	fmt.Printf("a1: %v\n", a1)
}

//輸出結果如下
a: [1 0 2]
b: [ hello go]
c: [false false true false false false]
a1: [1 2]

　　

總結
初始化陣列中{}中的元素個數不能大於[]中的數字。
如果忽略[]中的數字不設定陣列大小，Go 語言會根據元素的個數來設定陣列的大小：

5. 訪問陣列元素

陣列元素可以通過索引（位置）來讀取。
格式為陣列名後加中括號，中括號中為索引的值。陣列的最大下標為陣列長度-1，大於這個下標會發生陣列越界。
示例

package main

import "fmt"

func main() {
	var a [2]int
	a[0] = 100
	a[1] = 200
	fmt.Printf("a[0]: %v\n", a[0])
	fmt.Printf("a[1]: %v\n", a[1])

	//對陣列進行修改
	a[0] = 1
	a[1] = 2
	fmt.Println("---------修改後--------")
	fmt.Printf("a[0]: %v\n", a[0])
	fmt.Printf("a[1]: %v\n", a[1])
}

//輸出結果如下
a[0]: 100
a[1]: 200
---------修改後--------
a[0]: 1
a[1]: 2

　　

 

 

 

6. 根據陣列長度遍歷陣列

可以根據陣列長度，通過for迴圈的方式來遍歷陣列，陣列的長度可以使用len函式獲得

使用len()函式獲取陣列的長度

package main

import "fmt"

func main() {
	var a1 = [3]int{1, 2, 3}
	fmt.Printf("len(a1): %v\n", len(a1))

	var a2 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	fmt.Printf("len(a2): %v\n", len(a2))
}

//輸出結果如下
len(a1): 3
len(a2): 9

　　

陣列遍歷，根據長度和下標

package main

import "fmt"

func main() {
	a := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	for i := 0; i < len(a); i++ {
		fmt.Printf("a[%d]:%v\n", i, a[i])
	}
}

//輸出結果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9

　　

使用for range

package main

import "fmt"

func main() {
	var a = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	for i, v := range a {				//i也可以使用空白識別符號代替，不接受索引的值
		fmt.Printf("a[%v]:%v\n", i, v)
	}
}

//輸出結果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9

　　

 

總結

    • 陣列的元素可以通過下標的方式來訪問，下標的最大長度為陣列長度-1，如果大於這個下標則會越界

    • 遍歷陣列的兩種方法：
      ① 通過 for迴圈，長度可以使用len()獲取
      ② 通過for range迴圈遍歷陣列，返回陣列下標和對應的值；若不想要下標，可以使用空白識別符號_來取代

 

相關文章