SRE文档

深浅模式

1.golang数组 ​

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

1.1go语言数组的定义 ​

数组定义的语法：

go
var variable_name [Size]variable_type

variable_name----》数组名称
Size----》数组长度，必须是常量
variable_type ----》数组保存元素的类型
var variable_name [Size]variable_type

variable_name----》数组名称
Size----》数组长度，必须是常量
variable_type ----》数组保存元素的类型

1.2数组初始化 ​

初始化，就是给数组的元素赋值，没有初始化的数组，默认元素值都是零值,布尔类型是false,字符串是空字符串。

  • 初始化，就是将值直接放到大括号里
go
func arr() {
	//初始化列表
	var a = [2]int{1, 2}
	fmt.Printf("a:%v\n", a)

	//类型推断
	a1 := [2]int{5, 6}
	fmt.Printf("a1:%v\n", a1)

	var b = [2]string{"hello", "world"}
	fmt.Printf("b:%v\n", b)
}
func arr() {
	//初始化列表
	var a = [2]int{1, 2}
	fmt.Printf("a:%v\n", a)

	//类型推断
	a1 := [2]int{5, 6}
	fmt.Printf("a1:%v\n", a1)

	var b = [2]string{"hello", "world"}
	fmt.Printf("b:%v\n", b)
}
  • 没有初始化
go
func arrFunc() {
	var a [3]int
	var b [2]string
	fmt.Printf("a:%T\n", a)
	fmt.Printf("b:%T\n", b)
	fmt.Printf("a:%v\n", a)
	fmt.Printf("b:%v\n", b)
}
func arrFunc() {
	var a [3]int
	var b [2]string
	fmt.Printf("a:%T\n", a)
	fmt.Printf("b:%T\n", b)
	fmt.Printf("a:%v\n", a)
	fmt.Printf("b:%v\n", b)
}

1.3省略数组长度 ​

数组长度可以省略，使用...代替，更加初始化值得数量自动推断

go
func arrNumber() {
	var a = [...]int{1, 2, 3, 4}
	var b = [...]string{"kk", "pp", "go"}
	fmt.Printf("a:%v\n", a)
	fmt.Printf("b:%v\n", b)
    //打印数组长度
    fmt.Printf("len(a):%v\n", len(a))
    
	var c = [...]bool{true, false}
	fmt.Printf("c:%v\n", c)
}
func arrNumber() {
	var a = [...]int{1, 2, 3, 4}
	var b = [...]string{"kk", "pp", "go"}
	fmt.Printf("a:%v\n", a)
	fmt.Printf("b:%v\n", b)
    //打印数组长度
    fmt.Printf("len(a):%v\n", len(a))
    
	var c = [...]bool{true, false}
	fmt.Printf("c:%v\n", c)
}
  • 数组的修改
go
func arrModify() {
	var a = [...]int{1, 2, 3}
	fmt.Printf("a:%v\n", a)
    //根据索引修改
	a[0] = 100
	fmt.Printf("a=%v\n", a)
}
func arrModify() {
	var a = [...]int{1, 2, 3}
	fmt.Printf("a:%v\n", a)
    //根据索引修改
	a[0] = 100
	fmt.Printf("a=%v\n", a)
}

1.4访问数组元素 ​

可以通过下标的方式，来访问数组元素。元素的最大下标为数组长度-1，大于这个下标会发生数组越界。

go
func accessArr() {
	var a1 [2]int
	a1[0] = 100
	a1[1] = 200
	fmt.Printf("a1:%v\n", a1)
	fmt.Println("------------------------")
	a1[0] = 1000
	a1[1] = 2000
	fmt.Printf("a1:%v\n", a1)

	//越界
	//a1[3] = 1000
}
func accessArr() {
	var a1 [2]int
	a1[0] = 100
	a1[1] = 200
	fmt.Printf("a1:%v\n", a1)
	fmt.Println("------------------------")
	a1[0] = 1000
	a1[1] = 2000
	fmt.Printf("a1:%v\n", a1)

	//越界
	//a1[3] = 1000
}

1.5根据数组长度遍历数组 ​

可以根据长度，通过for循环的方式来遍历数组，数组的长度可以使用len函数获得。

go
func forArr() {
	a := [...]int{1, 2, 3, 4, 5, 6}
	for i := 0; i < len(a); i++ {
		fmt.Printf("a[%d]:%v\n", i, a[i])
	}
}
func forArr() {
	a := [...]int{1, 2, 3, 4, 5, 6}
	for i := 0; i < len(a); i++ {
		fmt.Printf("a[%d]:%v\n", i, a[i])
	}
}
go
func forArrRange() {
	a := [...]int{1, 2, 3, 4, 5, 6}
	for key, v := range a {
		fmt.Printf("a[%d]: %v\n", key, v)
	}
    for _, v := range a {
		fmt.Printf("v:%v\n", v)
	}
}
func forArrRange() {
	a := [...]int{1, 2, 3, 4, 5, 6}
	for key, v := range a {
		fmt.Printf("a[%d]: %v\n", key, v)
	}
    for _, v := range a {
		fmt.Printf("v:%v\n", v)
	}
}