Slice (Slice) in der Go-Sprache
Slices in der Go-Sprache sind eine Abstraktion über Arrays.
Die Länge von Go-Arrays kann nicht geändert werden, daher ist eine solche Sammlung in bestimmten Szenarien nicht sehr geeignet. Go bietet einen flexiblen und leistungsstarken integrierten Typ: Slice ("dynamisches Array"). Im Vergleich zu Arrays ist die Länge eines Slices nicht fest; Elemente können angehängt werden, und das Anhängen kann die Kapazität des Slices erhöhen.
Slices definieren
Sie können ein Array ohne Angabe der Größe deklarieren, um ein Slice zu definieren:
var identifier []type
Für Slices muss keine Länge angegeben werden.
Oder verwenden Sie diemake()-Funktion, um ein Slice zu erstellen:
var slice1 []type = make([]type, len) 也可以简写为 slice1 := make([]type, len)
Sie können auch die Kapazität angeben, wobeiKapazitätein optionaler Parameter ist.
make([]T, length, capacity)
Hier ist len die Länge des Arrays und auch die anfängliche Länge des Slices.
Slice-Initialisierung
s :=[] int {1,2,3 }
Initialisieren Sie das Slice direkt,[]was angibt, dass es sich um einen Slice-Typ handelt,{1,2,3}die Initialisierungswerte sind, in der Reihenfolge:1,2,3, seincap=len=3。
s := arr[:]
Initialisieren eines Slices, ist eine Referenz auf das Array arr.
s := arr[startIndex:endIndex]
Erstelle einen neuen Slice aus den Elementen von arr vom Index startIndex bis endIndex-1.
s := arr[startIndex:]
Wenn endIndex weggelassen wird, bedeutet das bis zum letzten Element von arr.
s := arr[:endIndex]
Wenn startIndex weggelassen wird, bedeutet das, vom ersten Element von arr aus zu beginnen.
s1 := s[startIndex:endIndex]
Initialisiere Slice s1 durch Slice s.
s :=make([]int,len,cap)
Durch die eingebaute Funktionmake()einen Slice initialisierens,[]intBezeichnet einen Slice, dessen Elementtyp int ist.
Funktionen len() und cap()
Slices sind indexierbar, und ihre Länge kann mit der Methode len() ermittelt werden.
Slices bieten die Methode cap() zur Berechnung der Kapazität, mit der gemessen werden kann, wie lang ein Slice maximal werden kann.
Im Folgenden finden sich konkrete Beispiele:
Beispiel
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)
}
Die Ausgabe des obigen Beispiels ist:
len=3 cap=5 slice=[0 0 0]
Leerer (nil) Slice
Bevor ein Slice initialisiert wird, ist er standardmäßig nil mit einer Länge von 0, zum Beispiel:
Beispiel
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
if(numbers == nil){
fmt.Printf("Der Slice ist leer")
}
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
Die Ausgabe des obigen Beispiels ist:
len=0 cap=0 slice=[] 切片是空的
Slicing eines Slices
Sie können untere und obere Grenzen festlegen, um einen Slice zu slicen.[lower-bound:upper-bound], Beispiel wie folgt:
Beispiel
import "fmt"
func main() {
/* Einen Slice erstellen */
numbers := []int{0,1,2,3,4,5,6,7,8}
printSlice(numbers)
/* Den ursprünglichen Slice ausgeben */
fmt.Println("numbers ==", numbers)
/* Teilslice von Index 1 (einschließlich) bis Index 4 (ausschließlich) ausgeben */
fmt.Println("numbers[1:4] ==", numbers[1:4])
/* Die Standard-Untergrenze ist 0 */
fmt.Println("numbers[:3] ==", numbers[:3])
/* Die Standard-Obergrenze ist len(s) */
fmt.Println("numbers[4:] ==", numbers[4:])
numbers1 := make([]int,0,5)
printSlice(numbers1)
/* Teilslice von Index 0 (einschließlich) bis Index 2 (ausschließlich) ausgeben */
number2 := numbers[:2]
printSlice(number2)
/* Teilslice von Index 2 (einschließlich) bis Index 5 (ausschließlich) ausgeben */
number3 := numbers[2:5]
printSlice(number3)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
Die Ausgabe beim Ausführen des obigen Codes ist:
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]
append()- und copy()-Funktionen
Wenn Sie die Kapazität eines Slices erhöhen möchten, müssen Sie einen neuen, größeren Slice erstellen und den Inhalt des ursprünglichen Slices in diesen kopieren.
Der folgende Code beschreibt die copy-Methode zum Kopieren von Slices und die append-Methode zum Anhängen neuer Elemente an einen Slice.
Beispiel
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
/* Ermöglicht das Anhängen an einen leeren Slice */
numbers = append(numbers, 0)
printSlice(numbers)
/* Ein Element zum Slice hinzufügen */
numbers = append(numbers, 1)
printSlice(numbers)
/* Mehrere Elemente gleichzeitig hinzufügen */
numbers = append(numbers, 2,3,4)
printSlice(numbers)
/* Slice numbers1 mit der doppelten Kapazität des vorherigen Slices erstellen */
numbers1 := make([]int, len(numbers), (cap(numbers))*2)
/* Kopiere den Inhalt von numbers nach numbers1 */
copy(numbers1,numbers)
printSlice(numbers1)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
Die Ausgabe beim Ausführen des obigen Codes ist:
len=0 cap=0 slice=[] len=1 cap=1 slice=[0] len=2 cap=2 slice=[0 1] len=5 cap=6 slice=[0 1 2 3 4] len=5 cap=12 slice=[0 1 2 3 4]Weitere Erweiterungen