Golang教程-Go切片

Go切片

在Go中，切片是对底层数组的动态大小分段视图。该分段可以是整个数组，也可以是数组的子集。我们通过指定起始和结束索引来定义数组的子集。切片提供了对底层数组的动态窗口。

切片数据类型示例：

package main  
import (  
   "fmt"  
)  
func main() {  
   odd := [6]int{2, 4, 6, 8, 10, 12}  
   var s []int = odd[1:4]  
   fmt.Println(s)  
}  

输出：

[4 6 8]

切片类似于对数组的引用。切片本身不存储任何数据。如果我们更改数组的元素，它也会修改底层数组。如果其他切片引用了相同的底层数组，它们的值也会被改变。

切片类似于数组引用。以下是切片的示例：

package main  
import "fmt"  
func main() {  
   names := [4]string{  
      "John",  
      "Jim",  
      "Jack",  
      "jen",  
   }  
   fmt.Println(names)  
   slice1 := names[0:2]  
   slice2 := names[1:3]  
   fmt.Println(slice1, slice2)  
   slice2[0] = "ZZZ"  
   fmt.Println(slice1, slice2)  
   fmt.Println(names)  
}  

输出：

[John Jim Jack jen]
[John Jim] [Jim Jack]
[John ZZZ] [ZZZ Jack]
[John ZZZ Jack jen]

切片字面量

切片字面量类似于没有长度的数组字面量。以下是一个没有长度的切片的示例：

package main  
import "fmt"  
func main() {  
   s := []struct {  
      i int  
      b bool  
   }{  
      {1, true},  
      {2, false},  
      {3,true},  
      {4, true},  
      {5, false},  
      {6, true},  
   }  
   fmt.Println(s)  
}  

输出：

[{1 true} {2 false} {3 true} {4 true} {5 false} {6 true}]

省略下限或上限

在切片中，我们可以省略下限或上限。下限或上限的默认值为零。

package main  
import "fmt"  
func main() {  
   slice1 := []int{2,4,8,10,12,14}  
   slice2 := slice1[2:4]  
   fmt.Println(slice2)  
   slice3 := slice1[:3]  
   fmt.Println(slice3)  
   slice4 := slice1[2:]  
   fmt.Println(slice4)  
   fmt.Println(slice1)  
}  

输出：

[8 10]
[2 4 8]
[8 10 12 14]
[2 4 8 10 12 14]

切片长度和容量

切片具有长度和容量。长度是存储元素的数量，容量是从切片开始计算的底层数组的元素数量。

要获取长度，我们使用len(slice)函数，要获取容量，我们使用cap(slice)函数。

输出：

package main  
import "fmt"  
func main() {  
   slice1 := []int{2,4,6,8,10,12,14}  
   printSlice(slice1)  
   // 将切片切片以使其长度为零  
   slice2 := slice1[:0]  
   printSlice(slice2)  
   // 扩展它的长度  
   slice3 := slice1[:4]  
   printSlice(slice3)  
   //删除它的前两个值  
   slice4 := slice1[2:]  
   printSlice(slice4)  
}  
func printSlice(s []int) {  
   fmt.Printf("length =%d capacity=%d %v\n", len(s), cap(s), s)  
}  

输出：

length =7 capacity=7 [2 4 6 8 10 12 14]
length =0 capacity=7 []
length =4 capacity=7 [2 4 6 8]
length =5 capacity=5 [6 8 10 12 14]

切片的make函数

我们也可以使用make函数创建切片。make函数创建一个大小为零的数组，并返回数组的切片。

package main  
import "fmt"  
func main() {  
   slice := make([]int, 10)  
   printSlice("slice", slice)  
   slice1 := make([]int, 0, 10)  
   printSlice("slice1", slice1)  
   slice2 := slice1[:5]  
   printSlice("slice2", slice2)  
   slice3 := slice2[2:5]  
   printSlice("slice3", slice3)  
}  
func printSlice(s string, x []int) {  
   fmt.Printf("%s length=%d capacity=%d %v\n",  
      s, len(x), cap(x), x)  
}  

输出：

slice length=10 capacity=10 [0 0 0 0 0 0 0 0 0 0]
slice1 length=0 capacity=10 []
slice2 length=5 capacity=10 [0 0 0 0 0]
slice3 length=3 capacity=8 [0 0 0]