// 和声明array一样，只是少了长度 var fslice []int

接下来我们可以声明一个slice，并初始化数据，如下所示：

slice := []byte {'a','b','c','d'}

slice可以从一个数组或一个已经存在的slice中再次声明。slice通过array[i:j]来获取，其中i是数组的开始位置，j是结束位置，但不包含array[j]，它的长度是j-i。

// 声明一个含有10个元素元素类型为byte的数组
var ar = [10]byte {'a','d','e','f','g','h','i','j'}

// 声明两个含有byte的slice
var a,b []byte

// a指向数组的第3个元素开始，并到第五个元素结束，
a = ar[2:5]
//现在a含有的元素: ar[2]、ar[3]和ar[4]

// b是数组ar的另一个slice
b = ar[3:5]
// b的元素是：ar[3]和ar[4]

注意slice和数组在声明时的区别：声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明slice时，方括号内没有任何字符。

它们的数据结构如下所示

slice有一些简便的操作

• slice的默认开始位置是0，ar[:n]等价于ar[0:n]
• slice的第二个序列默认是数组的长度，ar[n:]等价于ar[n:len(ar)]
• 如果从一个数组里面直接获取slice，可以这样ar[:]，因为默认第一个序列是0，第二个是数组的长度，即等价于ar[0:len(ar)]

下面这个例子展示了更多关于slice的操作：

// 声明一个数组
var array = [10]byte{'a','j'}
// 声明两个slice
var aSlice,bSlice []byte

// 演示一些简便操作
aSlice = array[:3] // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c
aSlice = array[5:] // 等价于aSlice = array[5:10] aSlice包含元素: f,g,h,i,j
aSlice = array[:]  // 等价于aSlice = array[0:10] 这样aSlice包含了全部的元素

// 从slice中获取slice
aSlice = array[3:7]  // aSlice包含元素: d,e,f,g，len=4，cap=7
bSlice = aSlice[1:3] // bSlice 包含aSlice[1],aSlice[2] 也就是含有: e,f
bSlice = aSlice[:3]  // bSlice 包含 aSlice[0],aSlice[1],aSlice[2] 也就是含有: d,f
bSlice = aSlice[0:5] // 对slice的slice可以在cap范围内扩展，此时bSlice包含：d,h
bSlice = aSlice[:]   // bSlice包含所有aSlice的元素: d,g

slice是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变该值，例如上面的aSlice和bSlice，如果修改了aSlice中元素的值，那么bSlice相对应的值也会改变。

从概念上面来说slice像一个结构体，这个结构体包含了三个元素：

• 一个指针，指向数组中slice指定的开始位置
• 长度，即slice的长度

• 最大长度，也就是slice开始位置到数组的最后位置的长度

  Array_a := [10]byte{'a','j'}
  Slice_a := Array_a[2:5]

上面代码的真正存储结构如下图所示

对于slice有几个有用的内置函数：

len获取slice的长度
• cap获取slice的最大容量
• append向slice里面追加一个或者多个元素，然后返回一个和slice一样类型的slice
• copy函数copy从源slice的src中复制元素到目标dst，并且返回复制的元素的个数