GO语言：切片

package main

import "fmt"

func main(){
	data := []int{1, 2, 3, 4, 5} //定义一个切片
	fmt.Println(data[0:3]) //切片，索引0-3（不包括索引3）
        fmt.Println(data[3:])  //切片，索引3到最后一个
	fmt.Println(data[:3])  //切片，从索引0-3（不包括索引3）
        fmt.Println(data[:])   //切片，全部
        fmt.Println(len(data)) //切片目前的长度
	fmt.Println(cap(data)) //切片的最大容量
}

package main

import "fmt"

func show(x []int) {//x 的类型是切片，切片中的元素是int
	fmt.Println(len(x), cap(x), x)
}

func main(){
	var slice []int = make([]int, 10, 15) //创造一个用于切片的数组
        //最后一个参数可以省略（默认与前一个参数相同）
        
	show(slice)

}

package main

import "fmt"

func main(){
	var names []string //一个空切片 长度 == 最大容量 == 0

	names = append(names, "Tom") //长度 +1，最大容量 +1
	names = append(names, "Jack", "Lisa")//长度 +2，最大容量 +2
        //append可以给切片扩容

	var data []string = make([]string, 5, 10)//切片类型，长度，最大容量
	copy(data, names) //切片data能copy切片names多少数据取决于data的长度而不是容量

	fmt.Println(names)
	fmt.Println(data)
}

切片的长度与最大容量的区别
1. go语言中，数组的长度是固定的
2. slice只是基于数组的一种抽象类型，它自身并没有保存什么数据，它只是指向了一个数组而已
3. 假设指向的数组长度是L，slice指向第n个元素
4. 切片的容量就是L-n
5. 切片的长度就是在n到L之间允许你访问的长度（所以切片的长度<=最大容量）
package main

import "fmt"

func printSlice(x []int) {
	fmt.Println("len =", len(x), "cap =", cap(x), x)
}

func main(){
	nums := []int{1, 2, 3, 4, 5}

	nums = nums[:0]
	printSlice(nums) 
        /*
        1.切之前指向的数组：[1, 2, 3, 4, 5]
        2.从索引0切到索引0 ，可访问的长度0 - 0 = 0，[]
        3.此时指向的数组：[1, 2, 3, 4, 5] ，容量为：5-0
        */
                        
	nums = nums[1:3]
	printSlice(nums)
        /*
        1.切之前指向的数组：[1, 2, 3, 4, 5]
        2.从索引1切到索引3，可访问的长度3 - 1 = 2，[2, 3]
        3.此时指向的数组：[2, 3, 4, 5]，容量为5 - 1 = 4
        */

	nums = nums[1:3]
	printSlice(nums)
        /*
        1.切之前指向的数组：[2, 3, 4, 5]
        2.从索引1切到索引3，可访问的长度3 - 1 = 2，[3， 4]
        3.此时指向的数组：[3, 4, 5]，容量为5 - 1 = 4
        */
        
        //由此可见切片容量只跟从哪个索引开始切和指向的数组的长度有关
        //切片长度（及可显示的长度）只跟从哪个索引切和切到哪个索引为止有关
}