Go - Scheiben

Go Slice ist eine Abstraktion über Go Array. Mit Go Array können Sie Variablen definieren, die mehrere Datenelemente derselben Art enthalten können, es gibt jedoch keine integrierte Methode, um die Größe dynamisch zu erhöhen oder ein eigenes Subarray abzurufen. Slices überwinden diese Einschränkung. Es bietet viele Dienstprogrammfunktionen, die für das Array erforderlich sind, und wird häufig in der Go-Programmierung verwendet.

Ein Slice definieren

Um ein Slice zu definieren, können Sie es als Array deklarieren, ohne seine Größe anzugeben. Alternativ können Sie verwendenmake Funktion zum Erstellen eines Slice.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

len () und cap () Funktionen

Ein Slice ist eine Abstraktion über ein Array. Es verwendet tatsächlich Arrays als zugrunde liegende Struktur. Daslen() Funktion gibt die Elemente zurück, die in dem Slice vorhanden sind, in dem cap()Die Funktion gibt die Kapazität des Slice zurück (dh wie viele Elemente es aufnehmen kann). Das folgende Beispiel erläutert die Verwendung von Slice -

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

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

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

Keine Scheibe

Wenn ein Slice ohne Eingaben deklariert wird, wird es standardmäßig als Null initialisiert. Seine Länge und Kapazität sind Null. Zum Beispiel -

package main

import "fmt"

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

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

len = 0 cap = 0 slice = []
slice is nil

Subslicing

Mit Slice können die Untergrenze und die Obergrenze angegeben werden, um die Unterscheibe davon zu erhalten[lower-bound:upper-bound]. Zum Beispiel -

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

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]

Funktionen append () und copy ()

Man kann die Kapazität eines Slice mit dem erhöhen append()Funktion. Verwenden voncopy()Funktion wird der Inhalt eines Quell-Slice in ein Ziel-Slice kopiert. Zum Beispiel -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

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]