Pergi sepotong bahasa (Slice)

Kepingan bahasa Go ialah abstraksi tatasusunan.

Panjang tatasusunan Go tidak boleh diubah Dalam senario tertentu, koleksi sedemikian tidak sesuai dengan jenis terbina dalam yang fleksibel dan berkuasa ("tatasusunan dinamik"). slice tidak tetap. Elemen boleh ditambah, yang boleh meningkatkan kapasiti kepingan.

Menentukan Slices

Anda boleh mengisytiharkan tatasusunan saiz yang tidak ditentukan untuk menentukan kepingan:

var identifier []type

Slice tidak perlu menentukan panjangnya.

Atau gunakan fungsi make() untuk mencipta kepingan:

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

Anda juga boleh menentukan kapasiti, dengan kapasiti ialah parameter pilihan.

make([]T, length, capacity)

Di sini len ialah panjang tatasusunan dan juga panjang awal hirisan.

Pengamatan hirisan

s :=[] int {1,2,3 }

Asalkan hirisan secara langsung, [] menunjukkan jenis hirisan, nilai pemulaan {1,2,3} ialah 1,2,3 mengikut urutan 3

s := arr[:]

Initialize slice s, yang merupakan rujukan kepada array arr

s := arr[startIndex:endIndex]

Cipta elemen dalam arr daripada subskrip startIndex ke endIndex-1 sebagai kepingan baharu

s := arr[startIndex:]

Tiada Apabila endIndex diabaikan, ia akan mewakili sehingga ke elemen terakhir arr

s := arr[:endIndex]

Apabila startIndex lalai, ia akan mewakili bermula dari elemen pertama arr

s1 := s[startIndex:endIndex]

Mulakan kepingan s1 hingga slice s

s :=make([]int,len,cap)

Memulakan slice s melalui fungsi terbina dalam make(), []int mengenal pasti kepingan yang jenis elemennya adalah int

len() dan cap() fungsi

kepingan boleh diindeks, dan panjang boleh diperolehi dengan kaedah len().

Slices menyediakan kaedah untuk mengira kapasiti cap() boleh mengukur berapa lama kepingan boleh.

Berikut ialah contoh khusus:

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Hasil keluaran contoh di atas ialah:

len=3 cap=5 slice=[0 0 0]

Kepingan kosong (tiada)

Potongan pada masa hadapan Sebelum pemulaan, lalai adalah sifar dan panjangnya ialah 0. Contoh adalah seperti berikut:

package main

import "fmt"

func main() {
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
      fmt.Printf("切片是空的")
   }
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Hasil output contoh di atas ialah:

len=0 cap=0 slice=[]
切片是空的

Slice interception

boleh ditetapkan dengan menetapkan had bawah dan Had atas digunakan untuk menetapkan slice interception [lower-bound:upper-bound] Contohnya adalah seperti berikut:

package main

import "fmt"

func main() {
   /* 创建切片 */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)

   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)

   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)

   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)

}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Hasil keluaran melaksanakan kod di atas ialah:

len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]
len=3 cap=7 slice=[2 3 4]

tambah( ) dan copy() fungsi

Jika kita ingin meningkatkan kapasiti kepingan , kita mesti mencipta kepingan baru yang lebih besar dan menyalin kandungan kepingan asal.

Kod berikut menerangkan kaedah salin daripada kepingan dan kaedah tambah untuk menambahkan elemen baharu pada kepingan.

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}