5

Go 语言数组 - 隐姓埋名4869

 2 years ago
source link: https://www.cnblogs.com/lvrui/p/16051921.html
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
neoserver,ios ssh client

Go 语言数组

引言
  数组是相同数据类型的一组数据的集合，数组一旦定义长度不能修改，数组可以通过下标（或者叫索引)来访问元素。

  相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。
数组元素可以通过索引（位置）来读取（或者修改），索引从0 开始，第一个元素索引为 0，第二个索引为1，以此类推。

一、数组的定义

var variable_name [SIZE] variable_type　　
variable_name:数组的名称
SIZE:数组长度，必须是常量
variable_type:数组保存元素的类型
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循环遍历数组，返回数组下标和对应的值；若不想要下标，可以使用空白标识符_来取代


report

Recommend

About Joyk


Aggregate valuable and interesting links.
Joyk means Joy of geeK