共计 3168 个字符，预计需要花费 8 分钟才能阅读完成。
Go 语言学习笔记 -07 数组与切片
数组
Go 语言中的数组是一个长度固定，由雷同类型的元素组成
申明
只申明，不初始化，默认为数据类型的零值
var arr [个数]数据类型申明并初始化
var arr [5]int = [5]int{} // [0,0,0,0,0]
var arr [5]int = [5]{1,2,3,4,5} // [1,2,3,4,5]为某些地位设置值，其余放弃为 0
var arr [5]int = [5]int{3:9} // [0,1,3,9,0] 为第 4 个元素设置值，其余放弃为 0 应用 ... 主动设置元素个数
var arr = [...]{1,2,3,4,5}应用 ... 设置稠密数组
var arr = [...]{49:50} // 设置第 50 个元素值为 50，其余的为 0 多维数组申明
var arr [2][3]int // 申明了一个 2 行 3 列的数组能够拆开来看，看作 2 个[3]int
多为数组初始化
// 第 2 维当前的类型申明可写可不写
var arr = [2][3]int{[3]int{1,2,3},[3]int{4,5,6}}
var arr = [2][3]int{{1,2,3},{4,5,6}}ch07/main.go
package main
import "fmt"
func main() {
// 申明不初始化，默认为数据类型的零值
var arr1 [5]int
fmt.Println("arr1", arr1)
// 申明并初始化
var arr2 [5]int = [5]int{1, 2, 3, 4, 5}
fmt.Println("arr2", arr2)
// 为某些地位设置值，其余放弃为 0
var arr3 [5]int = [5]int{3: 9}
fmt.Println("arr4", arr3)
// 应用... 主动设置元素个数
var arr4 = [...]int{4: 5}
fmt.Println("arr4", arr4)
// 多维数组
var arr5 = [2][3]int{[3]int{1, 2, 3}, {4, 5, 6}}
fmt.Println("arr5", arr5)
}输入
arr1 [0 0 0 0 0]
arr2 [1 2 3 4 5]
arr4 [0 0 0 9 0]
arr4 [0 0 0 0 5]
arr5 [[1 2 3] [4 5 6]]获取数组的长度
应用内置函数 len 获取
package main
import "fmt"
func main() {var arr = [5]int{}
fmt.Printf("arr 的长度为 %d", len(arr))
}输入
arr 的长度为 5 读取数组的值
应用下标获取数组的值，下标从 0 开始，不反对正数获取
package main
import "fmt"
func main() {var arr = [5]int{1, 2, 3, 4, 5}
fmt.Printf("arr[1]=%d", arr[1])
}切片
切片与数组很相像，只是它的长度不是固定的，随着元素的增多动静地变动
切片在 go 中的底层实现，是由一个指向底层数组的指针，切片的长度（切片元素的个位）以及底层数组的长度（切片的最大容量）三局部组成
能够通过内置函数 len 获取切片长度，通过内置函数 cap 获取切片容量
ch07/lenandcap/main.go
package main
import "fmt"
func main() {var slice = []int{1, 2, 3, 4, 5}
fmt.Printf("slice 的长度为：%d, 容量为：%d", len(slice), cap(slice))
}输入
slice 的长度为：5, 容量为：5申明
var slice []数据类型申明并初始化，长度和容量相等
var slice = []int{1,2,3,4,5} // [1,2,3,4,5] len=5 cap=5只申明不初始化，长度和容量都为 0，切片的默认值为 nil
var slice []int // []int(nil) len=0 cap=0ch07/sliceinit/main.go
package main
import "fmt"
func main() {var slice1 = []int{1, 2, 3, 4, 5}
var slice2 []int
fmt.Printf("slice1 %v 长度为：%d，容量为：%d\n", slice1, len(slice1), cap(slice1))
fmt.Printf("slice2 %#v 长度为：%d，容量为：%d\n", slice2, len(slice2), cap(slice2))
}输入
slice1 [1 2 3 4 5] 长度为：5，容量为：5
slice2 []int(nil) 长度为：0，容量为：0通过 make 函数创立切片
var slice = make([]数据类型，长度，容量)ch07/makeslice/main.go
package main
import "fmt"
func main() {slice := make([]int, 5)
slice2 := make([]int, 5, 10)
fmt.Printf("slice %v 长度：%d，容量：%d\n", slice, len(slice), cap(slice))
fmt.Printf("slice2 %v 长度：%d，容量：%d\n", slice2, len(slice2), cap(slice2))
}输入
slice [0 0 0 0 0] 长度：5，容量：5
slice2 [0 0 0 0 0] 长度：5，容量：10通过数组创立切片
能够通过 array[low:high:max] 模式从一个数组中获取到一个切片，此时切片起始元素是数组下标为 low 的元素，切片的长度为 high-low，切片的容量为max-low，切片的底层数组就是就是array，换言之，批改切片的值，array 同样也会受到影响
array[low:high]，max省略时，max的默认值为数组的长度
array[:]能够失去一个和 arr 元素一样的切片
ch07/arraytoslice/main.go
package main
import "fmt"
func main() {arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
slice1 := arr[2:7:8] // [2,3,4,5,6]
slice2 := arr[:] // [1,2,3,4,5,6,7,8,9,10]
slice3 := arr[3:4] // [4]
fmt.Printf("slice1 %v，长度：%d，容量：%d\n", slice1, len(slice1), cap(slice1))
fmt.Printf("slice2 %v，长度：%d，容量：%d\n", slice2, len(slice2), cap(slice2))
fmt.Printf("slice3 %v，长度：%d，容量：%d\n", slice3, len(slice3), cap(slice3))
// 批改切片的第 4 个元素，及把 6 改为 12
slice1[3] = 12
// 原数组 arr 产生扭转
fmt.Printf("批改后 slice1 %v，长度：%d，容量：%d\n", slice1, len(slice1), cap(slice1))
fmt.Printf("批改后 slice2 %v，长度：%d，容量：%d\n", slice2, len(slice2), cap(slice2))
fmt.Printf("批改后 arr %v\n", arr)
}输入
slice1 [3 4 5 6 7]，长度：5，容量：6
slice2 [1 2 3 4 5 6 7 8 9 10]，长度：10，容量：10
slice3 [4]，长度：1，容量：7
批改后 slice1 [3 4 5 12 7]，长度：5，容量：6
批改后 slice2 [1 2 3 4 5 12 7 8 9 10]，长度：10，容量：10
批改后 arr [1 2 3 4 5 12 7 8 9 10] 笔记地址
github：https://github.com/xianyuyixi…
交流学习
微信号：xianyuyixia
微信公众号：闲渔一下
