// 使用 make 函数创建切片
// var 切片变量 = make([]类型， 长度, 容量)
var slice = make([]int, 5, 5)

// 以下两种声明方式是等价的
// 方式1
var slice = make([]int, 5)
​
// 方式2
var slice = make([]int, 5, 5)

// 声明并初始化切片
// 在声明切片时，指定切片所有元素
var slice = []int{1, 2, 3}
​
// 初始化部分元素
// 初始化索引为1的元素为1，索引2为6， 索引5为10
var slice = []int{1:1, 2:6, 5:10}

// 使用字面量声明切片
// 情况一：空切片
// 切片的元素值是切片类型的零值，即 int 0, string '', 引用类型 nil
var slice = []int{}
// 尝试赋值会报错：runtime error: index out of range [0] with length 0
slice[0] = 1
​
// 情况二：nil 切片
var slice []int
// 尝试赋值会报错：runtime error: index out of range [0] with length 0
slice[0] = 1

// 原切片 slice
var slice = []int{1, 2, 3, 4, 5}
​
// 对slice进行切片生成新切片 newSlice
// 复制整个 slice 切片
var newSlice = slice[:]
​
// 复制 索引 1 到 3 的元素, 注意新切片不包含索引为 3 的元素
var newSlice = slice[1:3] // [2 3]
​
// 复制 slice 第一个元素 到索引为 2 的元素
// 不用写第一个索引
var newSlice = slice[:2] // [1 2]
​
// 复制 slice 索引为2 的元素 到 最后一个元素
// 不用写第二个索引
var newSlice = slice[2:]
​

var slice = []int{1, 2, 3, 4, 5}
​
// 以下两种方式相等
// 方式一
var newSlice = slice[2:4:5]
​
// 方式二, 第三个参数默认是 slice的长度
var newSlice = slice[2:4]

// 原切片 slice, 长度为5， 容量为5，类型为 int
var slice = []int{1, 2, 3, 4, 5}
​
// 新切片 newSlice 长度=2 (即4-2), 容量=3 (即5-2)
var newSlice = slice[2:4]
​
// 尝试把新切片容量改为大于 slice 容量(5) 的值
// 运行时会报错：slice bounds out of range [::6] with capacity 5
var newSlice = slice[2:4:6]
​
// 可以使用内置函数 len, cap 查看切片的长度和容量
log.Println(len(newSlice), cap(newSlice))

var slice = []int{1, 2, 3, 4, 5} // [1 2 3 4 5]
var newSlice = slice[2:4] // [3 4]
​
// 将 newSlice 第一个元素改为 66
newSlice[0] = 66 // newSlice 为 [66 4]
// slice 也会被影响
log.Println(slice) // [1 2 66 4 5]

var slice = []int{1, 2, 3, 4, 5} // [1 2 3 4 5]
// 解构 slice 元素 到一个新的空切片中，
// 因为空切片会基于新数组创建的,不会和 slice 共享底层数组
// 所以影响到 slice 的切片
var newSlice = append([]int{}, slice...)
​
// 再次更改 newSlice 的元素
newSlice[0] = 66 // [66 2 3 4 5]
// slice 不会被影响
log.Println(slice) // [1 2 3 4 5]

package main
import "log"
​
func main() {// len=2, cap=2var slice = []int{1, 2}// 不会创建新底层数组newSlice := slice[:1]
​// 底层数组容量（2）足够，不会创建新底层数组// 修改 newSlice, slice 不会被影响newSlice[0] = 100//  newSlice=[100], len=1, cap=2//log.Printf("newSlice=%v, len=%d, cap=%d", newSlice, len(newSlice), cap(newSlice))//  slice=[100 2], len=2, cap=2//log.Printf("slice=%v, len=%d, cap=%d", slice, len(slice), cap(slice))
​// 底层数组容量（2）足够， 不会创建新底层数组// slice 也会被影响newSlice = append(newSlice, 66)//  newSlice=[100 66], len=2, cap=2//log.Printf("newSlice=%v, len=%d, cap=%d", newSlice, len(newSlice), cap(newSlice))//  slice=[100 66], len=2, cap=2//log.Printf("slice=%v, len=%d, cap=%d", slice, len(slice), cap(slice))
​// 底层数组容量不足，会创建一个新的底层数组// slice 不会被影响newSlice = append(newSlice, 999)//  newSlice=[100 66 999], len=3, cap=4//log.Printf("newSlice=%v, len=%d, cap=%d", newSlice, len(newSlice), cap(newSlice))//  slice=[100 66], len=2, cap=2//log.Printf("slice=%v, len=%d, cap=%d", slice, len(slice), cap(slice))
​// 此时再次修改 newSlice， slice将不再被影响// 因为此时的 newSlice 和 slice 已经不再共享底层数组newSlice[0] = 777// newSlice=[777 66 999], len=3, cap=4log.Printf("newSlice=%v, len=%d, cap=%d", newSlice, len(newSlice), cap(newSlice))//  slice=[100 66], len=2, cap=2log.Printf("slice=%v, len=%d, cap=%d", slice, len(slice), cap(slice))
}

var slice []int
​
// 切片尾部增加元素
// 新增一个元素
slice = append(slice, 1)
​
// 新增多个元素
slice = append(slice, 1, 2)
​
// 新增多个元素, 切片作为参数，需要使用 ... 运算符来辅助解构切片
var newSlice = []int{1, 2, 3}
slice = append(slice, newSlice...)

// 切片首部增加元素
var slice = []int{1, 2}
​
// 首部增一个元素
slice = append([]int{5}, slice...)
// 首部增多个元素
var newSlice = []int{5, 6, 7}
slice = append(newSlice, slice...) 

// 切片中间某个位置插入元素
var slice = []int{1, 2, 3}
// 比如需要插入到元素索引i后, 则先以 i+1 为切割点，把 slice 切割成两半，
// 索引 i 前数据：slice[:i+1], 索引 i 后的数据: slice[i+1:]
// 然后再把 索引 i 后的数据: slice[i:]合并到需要插入的元素切片中如：append([]int{6, 7}, slice[i:]...)
// 最后再把合并后的切片合并到 索引 i 前数据：slice[:i]
// 如在元素索引1后增加元素
slice = append(slice[:2], append([]int{6, 7}, slice[2:]...)...)

var slice = []int{1, 2, 3, 4, 5, 6}
// 从切片首部删除
slice = slice[1:]
​
// 从切片尾部删除
slice = slice[:len(slice) - 2]
​
// 从切片中间删除, 如从索引为i，删除2个元素(i+2)
slice = append(slice[:1], slice[3:]...)
​
// 修改元素
var slice = []int{1, 2, 3}
slice[1] = 6
​
// 查找元素
var slice = []int{1, 2, 3}
log.Println("slice[1]=", slice[1])// 试图访问超出其长度的元素就会报错
a := slice[4]
​log.Println(a) // runtime error: index out of range [4] with length 3

// 修改前，会影响外部切片
func changeSliceValue(slice2 []int) {// 直接使用切换会影响函数外部的切片slice2[1] = 666log.Println("slice2=", slice2)
}
// 注意切片类型要一致
var slice = []int{1, 2, 3}
changeSliceValue(slice)
log.Println("slice=", slice)
​
// 修改后, 不会影响外部切片
func changeSliceValue(slice2 []int) {// 直接使用切换会影响函数外部的切片newSlice := append([]int{}, slice2...)newSlice[1] = 666log.Println("newSlice=", newSlice)
}
// 注意切片类型要一致
var slice = []int{1, 2, 3}
changeSliceValue(slice)
log.Println("slice=", slice)

var slice = []string{"Red", "Yellow", "Blue", "Green", "Gray"}
// for 循环迭代
for i:=0; i<len(slice); i++ {//log.Println(i, slice[i])log.Println(i, slice[i])
}
​
// for range 循环迭代
for i, color := range slice {log.Println(i, color)
}

// 声明
var slice = make([][]int, 2)// 声明 二维nil切片
var slice [][]int// 声明 空二维切片
var slice = [][]int{}// 字面量声明并初始化
var slice = [][]int{{1}, {1:1}}
// 将二维切片的元素赋值给其他切片
var slice2 = slice[1]
​
// 读取二维切片
log.Println(slice, slice[0], slice[1][1], slice2)