復合數據類型是集合類，并且可以存儲多個單值。

在golang中存儲的數組是相同的數據類型，并且長度也是其中的一個屬性。在go中，數組的長度一旦定義，就不可變。如果聲明了長度的變量，只能賦值相同的長度的數組

數組是具有相同數據類型的數據項組成一組長度固定的序列，數據項叫做數組的元素，數組的長度必須是非負整數的常量，長度也是類型的一部分。

1.2 數組的聲明

聲明數組組成的元素類型以及存儲的元素長度，一旦數組長度設置后不可以更改，數組的每個元素會根據對應類型的零值進行初始化。

使用var進行聲明即可，長度和類型

var nums [10]int

如上，數組使用中括號[]，上述表示一個長度為10的int類型數組。

package main

import "fmt"

func main() {

var nums [10]int

fmt.Printf("%T ", nums)

fmt.Println("\n", nums)

}

我們可以打印下這個nums

[root@www.linuxea.com /opt/Golang/work2]# go run array.go

[10]int

[0 0 0 0 0 0 0 0 0 0]

!!! note

當定義了[10]int的時候，就會在內存申請10個int類型的元素。元素內的值是對應類型的零值存放。

所以，這里打印的是10個0。

我們可以多定義幾個其他類型

package main

import "fmt"

func main() {

var nums [10]int

var t1 [5]bool

var t2 [3]string

fmt.Printf("%T ", nums)

fmt.Println("\n", nums)

fmt.Println(t1)

fmt.Printf("%q",t2)

}

%q可以打印空字符串帶""，便于查看

運行結果如下：

[root@www.linuxea.com /opt/Golang/work2]# go run array.go

[10]int

[0 0 0 0 0 0 0 0 0 0]

[false false false false false]

["" "" ""]

分別是，10個0，5個false，3個空字符串

1.2數組的賦值

賦值的時候，需要和定義時候一樣，假如你賦值如下:

nums = [10]int{}

這和上面定義的變量是一樣，因為{}是空，都會是0值。

我們設置1~5

package main

import "fmt"

func main() {

var nums [10]int

nums = [10]int{1,2,3,4,5}

fmt.Println(nums)

}

這里也可以簡短聲明: nums := [10]int{1,2,3,4,5}

運行：

[root@www.linuxea.com /opt/Golang/work2]# go run array.go

[1 2 3 4 5 0 0 0 0 0]

這時候你會發現，賦值是正確了，但是仍然打印了10個元素，前五個被賦值了，沒有賦值的仍然是0.

1.3數組索引賦值

我們在換種方式，對第一個和最后一個進行賦值。

如果要進行這種賦值操作，必須使用索引，第一個就是0，最后一個就是9。

將第一個賦值為10，最后一個賦值為20，如下：

nums = [10]int{0:10,9:20}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array.go

[10 0 0 0 0 0 0 0 0 20]

我們也可以使用[...]來省略長度，但是必須輸夠長度

我們可以使用[...]的方式來進行自動推導有多少數組，而不是設置一個固定的值

package main

import "fmt"

func main() {

var nums [10]int

nums = [...]int{0:10,9:20}

}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array.go

[10 0 0 0 0 0 0 0 0 20]

或者這樣

nums02 := [...]int{1,2,3,4}

package main

import "fmt"

func main() {

nums02 := [...]int{1,2,3,4}

fmt.Println(nums02)

}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go

[1 2 3 4]

1.4數組的操作

定義nums01和nums02數組進行判斷

package main

import "fmt"

func main() {

nums01 := [...]int{0,1,2,3}

nums02 := [...]int{1,2,3,4}

fmt.Println(nums02 == nums01)

}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go

false

或者不等于

package main

import "fmt"

func main() {

nums01 := [...]int{0,1,2,3}

nums02 := [...]int{1,2,3,4}

fmt.Println(nums02 != nums01)

}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go

true

!!! warning

如果長度不相等是不能進行運算.

可以使用len計算數組的長度

1.5數組的索引操作

nums02 := [...]int{1,2,3,4}

我們現在獲取位于2和3的索引位置的數據.

索引范圍必須在可選值內 ，0~ len-1

package main

import "fmt"

func main() {

nums02 := [...]int{1,2,3,4}

fmt.Println(nums02[1],nums02[2])

}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go

2 3

修改

將索引0改成666

nums02 := [...]int{1,2,3,4}

nums02[0] = 666

而后在打印這個修改的索引0

fmt.Println(nums02[0])

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go

666

這里已經被修改。

1.6數組的遍歷

使用for遍歷上述的數組

package main

import "fmt"

func main() {

nums02 := [...]int{1,2,3,4}

nums02[0] = 666

for i :=0; i< len(nums02); i++{

fmt.Println(i,":",nums02[i])

}

}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go

0 : 666

1 : 2

2 : 3

3 : 4

for range遍歷

package main

import "fmt"

func main() {

nums02 := [...]int{1,2,3,4}

nums02[0] = 666

for index,value := range nums02 {

fmt.Println(index,":",value)

}

}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go

0 : 666

1 : 2

2 : 3

3 : 4

0 : 666

我們也可以使用下劃線，空白符來不接收

package main

import "fmt"

func main() {

nums02 := [...]int{1,2,3,4}

nums02[0] = 666

for _,value := range nums02 {

fmt.Println(value)

}

}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go

666

2

3

4

###1.7數組的切片操作

切片可以獲取一部分，字符串和數組都可以獲取一部分。如下

和之前字符串一樣，end不能超過其長度，最多和長度一樣。

我們設置start為0，end為3，我們先看下這個切片的類型

package main

import "fmt"

func main() {

var nums [10]int

nums = [10]int{1,2,3,4,5}

fmt.Printf("%T",nums[1:10])

}

運行

[root@www.linuxea.com /opt/Golang/work2]# go run array.go

[]int

數組切片之后的并不是是數組，而是另外的切片。

切片在字符串是用字符串的某一段組成的新的字符串。

切片在數組是數組中的元素組成一個新的集合。

在切片之后還可以跟一個值，這個值是容量，但是仍然不可以超過最大值。

package main

import "fmt"

func main() {

var nums [10]int

nums = [10]int{1,2,3,4,5}

fmt.Printf("%T",nums[1:10])

fmt.Printf("%T",nums[1:10:10])

}

[root@www.linuxea.com /opt/Golang/work2]# go run array.go

[]int[]int

除非另有說明，否則本站上的內容根據以下許可進行許可: CC署名-非商業性使用-相同方式共享4.0國際許可協議4.0進行許可

本文作者：www.linuxea.com for Mark

文章鏈接：http://www.linuxea.com/2494.html (轉載請注明本文出處和本章鏈接)

總結

以上是生活随笔為你收集整理的linux数组操作 增删改查,linuxea:go数组与数组增删改查(19)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。