Zwei Scheiben in Go verknüpfen

1. Deklaration von Slice
2. Verkettung von Slices
3. Funktionsweise der Funktion append()

In Go ist ein slice die dynamische Datenstruktur, die mehrere Elemente desselben Datentyps speichert. Man kann sie sich auch als Arrays variabler Größe vorstellen, die eine Indizierung ab Array haben, aber ihre Größe ist nicht festgelegt, da sie in der Größe verändert werden können. Da Slices von Natur aus dynamisch sind, können wir ein neues Element anhängen, um zwei oder mehr Slices mit Hilfe der append-Funktion zu slicen oder zu verketten.

Deklaration von Slice

Die Deklaration von Slices ist ähnlich wie bei Arrays, aber die Größe wird nicht angegeben.

package main

import "fmt"

func main() {
    var Slice1 = []int{1, 2, 3, 4}
    fmt.Printf("Length of Slice: %v\n",len(Slice1))
    fmt.Printf("First Element: %v\n",Slice1[0])
    fmt.Printf("Second Element: %v\n",Slice1[1])
    fmt.Printf("Third Element: %v\n",Slice1[2])
    fmt.Printf("Fourth Element: %v\n",Slice1[3])

}

Ausgabe:

Length of Slice: 4
First Element: 1
Second Element: 2
Third Element: 3
Fourth Element: 4

Verkettung von Slices

Wir verwenden die eingebaute append() Funktion, um Elemente zur Liste hinzuzufügen oder zwei oder mehr Scheiben miteinander zu verketten. Wenn genügend Kapazität vorhanden ist, wird das Ziel erneut geschnitten, um die neuen Elemente aufzunehmen. Wenn keine ausreichende Kapazität verfügbar ist, wird ein neues Underlying zugewiesen und der Inhalt kopiert. Schließlich gibt die Funktion anhängen die aktualisierte Scheibe zurück.

Ein einzelnes Element an Slice anhängen

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)  
    fmt.Printf("slice_1: %v\n", slice_1)
    fmt.Printf("slice_2: %v\n", slice_2)

}

Ausgabe:

slice_1: [1 2]
slice_2: [1 2 3]

Mehrere Elemente an einen Slice anhängen

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)
    slice_3 := append(slice_2, 4,5,6)   
    fmt.Printf("slice_3: %v\n", slice_3)

}

Ausgabe:

slice_3: [1 2 3 4 5 6]

Zwei Scheiben verknüpfen

package main

import "fmt"

func main() {
    var slice_3 = []int{1, 2, 3, 4, 5, 6}
    var slice_4 = []int{7,8}
    
    slice_5 := append(slice_3,slice_4...) 
    fmt.Printf("slice_4: %v\n", slice_4)
    fmt.Printf("slice_5: %v\n", slice_5)

}

Ausgabe:

slice_4: [7 8]
slice_5: [1 2 3 4 5 6 7 8]

Ein wichtiger Punkt, der bei der Verkettung von zwei Slices in einem Rutsch zu beachten ist, ist, dass ... nach slice_4 wesentlich ist, da append() eine variadische Funktion ist, genau wie andere variadische Funktionen. Mit ... können Sie mehrere Argumente von einem Slice an eine Funktion übergeben. Hier wird die Funktion anhängen rekursiv für jedes Element in slice_4 aufgerufen.

Eine Zeichenkette an einen Byte-Slice anhängen

var slice []byte = append([]byte("abc "), "def"...)
fmt.Printf("slice: %v\n", slice)

Ausgabe:

slice: [97 98 99 32 100 101 102]

Hier werden die Zeichen in UTF-8 mit 3 Bytes kodiert, die den ASCII-Wert der Zeichen darstellen. Das Slice-Byte kann zurück in String as konvertiert werden:

slice_str := string(slice)
fmt.Printf("String: %v\n", slice_str)

Ausgabe:

Slice: abc def

Funktionsweise der Funktion append()

Die eingebaute Funktion append() nimmt eine Slice, hängt alle Elemente an das Ende einer Eingabeslice an und gibt schließlich die verkettete Slice zurück. Wenn die Zielscheibe eine ausreichende Kapazität hat, wird die Scheibe erneut geschnitten, um die neu angehängten Elemente aufzunehmen. Wenn die Kapazität der Zielscheibe jedoch nicht ausreicht, wird ein neues Array erstellt, und die in den vorhandenen Slices vorhandenen Elemente werden in das neue Array kopiert, und schließlich wird ein neues Array von der Funktion zurückgegeben.

package main

import "fmt"

func main() {

    slice_1 := []int{0, 1, 2}
    fmt.Println("slice_1 : ", slice_1)
    fmt.Println("Capacity of slice_1: ", cap(slice_1))

    res_1 := append(slice_1, 3)
    fmt.Println("res_1 : ", res_1)
    fmt.Println("Capacity of res_1: ", cap(res_1))

    slice_2 := make([]int, 3, 5)  //Create slice_1 with length 3 and capacity 5
    copy(slice_2, []int{0, 1, 2}) //Copy elements into slice_1
    fmt.Println("slice_2 : ", slice_2)
    fmt.Println("Capacity of slice_2: ", cap(slice_2))

    res_2 := append(slice_2, 3)
    fmt.Println("res_2 : ", res_2)
    fmt.Println("Capacity of res_2: ", cap(res_2))

}

Ausgabe:

slice_1 :  [0 1 2]
Capacity of slice_1:  3
res_1 :  [0 1 2 3]
Capacity of res_1:  6
slice_2 :  [0 1 2]
Capacity of slice_2:  5
res_2 :  [0 1 2 3]
Capacity of res_2:  5

Hier hat slice_1 nicht genügend Kapazität, um ein neues Element anzuhängen, also wird ein neues Slice mit der Kapazität 6 erstellt, und alle Elemente in den vorhandenen Slices werden in das neu erstellte Slice kopiert.

Allerdings hat slice_2 genügend Kapazität, um neue Elemente anzuhängen, so daß Elemente in der bestehenden Scheibe angehängt werden.