Go Sprache Scheibe (Slice)

Go Sprache Scheibe ist ein Array von Abstraktion.

Gehen Länge des Arrays kann nicht geändert werden, so dass die Sammlung nicht als nützlich in bestimmten Szenarien ist, bietet Go eine flexible, leistungsstarke Einbautyp Abschnitt ( "dynamische Array"), im Vergleich zu der Array-Slice Länge nicht fest können die Elemente hinzugefügt werden, wenn zusätzliche Kapazität erhöht Scheiben machen kann.

Definierte Scheibe

Sie können eine Reihe von nicht näher Größe erklären die Scheibe zu definieren:

var identifier []type

Geschnittene Länge erklärend.

Oder eine Scheibe zu schaffen Funktion machen ():

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

也可以简写为

slice1 := make([]type, len)

Sie können auch die Kapazität angeben, in denen die Kapazität ist optional.

make([]T, length, capacity)

Hier len ist die Länge der Anordnung und auch die Anfangslänge der Scheibe.

Slice-Initialisierung

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

Direkte Initialisierung Abschnitte [] einen Slice-Typ darstellen, {1,2,3} Initialisierungswerte, gefolgt von 1,2,3 seine Kappe = len = 3

s := arr[:] 

Initialisierung slice s, ist ein Verweis auf das Array arr

s := arr[startIndex:endIndex] 

Es wird eine neue Scheibe mit dem Element am Index start endIndex 1-under in arr erstellen

s := arr[startIndex:] 

Das letzte Element ist standardmäßig zum arr, wenn endIndex

s := arr[:endIndex] 

Anzeige aus dem ersten Element des VAZ Standardstartstart

s1 := s[startIndex:endIndex] 

Stück für Stück s initialize s1

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

Durch eingebaute Funktion make () Scheibe s Initialisiert, [] int identifiziert seine Elemente vom Typ int Scheiben

len () und Kappe () Funktion

Slice ist indiziert und kann durch die Länge len () Verfahren erhalten werden.

Scheibe stellt ein Verfahren der Kapazitätskappe () zu berechnen bis zu einer maximalen Anzahl von Scheiben gemessen werden.

Die folgenden speziellen Beispiele:

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)
}

Führen Sie das obige Beispiel Ausgabe lautet:

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

Leer (nil) in Scheiben geschnitten

Ein Stück vor nicht initialisierten Standardwert ist null, eine Länge von 0, Beispiele sind wie folgt:

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)
}

Führen Sie das obige Beispiel Ausgabe lautet:

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

Scheibe Abfangen

Sie können die Intercept - Scheibe gesetzt [Untergrenze: obere Grenze ] durch untere und obere Einstellung Beispiele sind wie folgt:

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)
}

Führen Sie die oben genannten Code Ausgabeergebnisse:

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]

anhängen () und kopieren () Funktion

Wenn Sie die Kapazität der Scheibe zu erhöhen wollen, müssen wir ein neues und größeres Stück der ursprünglichen Fragmente des Inhalts erstellen kopiert wird.

Der folgende Code beschreibt die Kopie von der Scheibe und der Kopiermethode ein neues Element hinzuzufügen Scheibenverfahren anzuhängen.

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)
}

Der Ausgang wird der obige Code wird ausgeführt:

len=0 cap=0 slice=[]
len=1 cap=2 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=8 slice=[0 1 2 3 4]
len=5 cap=16 slice=[0 1 2 3 4]