Go
Scheiben

Einführung

Syntax

• slice: = make ([] type, len, cap) // ein neues Slice erstellen
• Slice = Anhängen (Slice, Element) // Element an ein Slice anhängen
• Slice = Anhängen (Slice, Elemente ...) // Slice-Elemente an ein Slice anhängen
• len: = len (Slice) // Liefert die Länge eines Slice
• cap: = cap (slice) // Liefert die Kapazität eines Slice
• elNum: = copy (dst, slice) // kopiere den Inhalt eines Slice in ein anderes Slice

Anhängen an Scheibe

slice = append(slice, "hello", "world")

Zwei Scheiben zusammen hinzufügen

slice1 := []string{"!"}
slice2 := []string{"Hello", "world"}
slice  := append(slice1, slice2...)

Laufen Sie auf dem Go Playground

Elemente entfernen / "Scheiben schneiden"

Wenn Sie ein oder mehrere Elemente aus einem Slice entfernen müssen oder wenn Sie mit einem Sub-Slice eines anderen vorhandenen arbeiten müssen. Sie können die folgende Methode verwenden.

In den folgenden Beispielen wird Slice of Int verwendet, dies funktioniert jedoch mit allen Slice-Typen.

Dafür brauchen wir ein Stück, von dem wir einige Elemente entfernen werden:

slice := []int{1, 2, 3, 4, 5, 6} 
// > [1 2 3 4 5 6]

Wir brauchen auch die Indexe der Elemente, die entfernt werden sollen:

// index of first element to remove (corresponding to the '3' in the slice)
var first = 2

// index of last element to remove (corresponding to the '5' in the slice)
var last = 4 

Und so können wir das Slice "schneiden" und unerwünschte Elemente entfernen:

// keeping elements from start to 'first element to remove' (not keeping first to remove), 
// removing elements from 'first element to remove' to 'last element to remove'
// and keeping all others elements to the end of the slice
newSlice1 := append(slice[:first], slice[last+1:]...)
// > [1 2 6]

// you can do using directly numbers instead of variables
newSlice2 := append(slice[:2], slice[5:]...)
// > [1 2 6]

// Another way to do the same
newSlice3 := slice[:first + copy(slice[first:], slice[last+1:])]
// > [1 2 6]

// same that newSlice3 with hard coded indexes (without use of variables)
newSlice4 := slice[:2 + copy(slice[2:], slice[5:])]
// > [1 2 6]

Um nur ein Element zu entfernen, müssen Sie einfach den Index dieses Elements als erstes UND als den letzten zu entfernenden Index angeben:

var indexToRemove = 3
newSlice5 := append(slice[:indexToRemove], slice[indexToRemove+1:]...)
// > [1 2 3 5 6]

// hard-coded version:
newSlice5 := append(slice[:3], slice[4:]...)
// > [1 2 3 5 6]

Sie können auch Elemente vom Anfang des Slice entfernen:

newSlice6 := append(slice[:0], slice[last+1:]...)
// > [6]

// That can be simplified into
newSlice6 := slice[last+1:]
// > [6]

Sie können auch einige Elemente vom Ende des Slice entfernen:

newSlice7 := append(slice[:first], slice[first+1:len(slice)-1]...)
// > [1 2]

// That can be simplified into
newSlice7 := slice[:first]
// > [1 2]

Wenn das neue Segment genau dieselben Elemente wie das erste enthalten muss, können Sie dasselbe verwenden, jedoch mit last := first-1 .
(Dies kann nützlich sein, wenn Ihre Indizes zuvor berechnet wurden.)

Länge und Kapazität

Scheiben haben sowohl Länge als auch Kapazität. Die Länge eines Slices ist die Anzahl der Elemente, die sich aktuell im Slice befinden, während die Kapazität der Anzahl der Elemente entspricht, die das Slice aufnehmen kann, bevor es neu zugewiesen werden muss.

Beim Erstellen eines Slice mithilfe der integrierten Funktion make() können Sie seine Länge und optional die Kapazität angeben. Wenn die Kapazität nicht explizit angegeben ist, hat dies die angegebene Länge.

var s = make([]int, 3, 5) // length 3, capacity 5

Sie können die Länge eines Slices mit der eingebauten Funktion len() überprüfen:

var n = len(s) // n == 3

Sie können die Kapazität mit der integrierten Funktion cap() überprüfen:

var c = cap(s) // c == 5

Von make() erzeugte Elemente werden auf den Nullwert für den Elementtyp des Slice gesetzt:

for idx, val := range s {
    fmt.Println(idx, val)
}
// output:
// 0 0
// 1 0
// 2 0

Führen Sie es auf play.golang.org aus

Sie können nicht auf Elemente zugreifen, die über die Länge eines Slice hinausgehen, auch wenn der Index nicht ausgelastet ist

var x = s[3] // panic: runtime error: index out of range

Solange die Kapazität die Länge überschreitet, können Sie neue Elemente anfügen, ohne sie neu zuzuordnen:

var t = []int{3, 4}
s = append(s, t) // s is now []int{0, 0, 0, 3, 4}
n = len(s) // n == 5
c = cap(s) // c == 5

Wenn Sie an ein Slice anhängen, dem die Kapazität zur Aufnahme der neuen Elemente fehlt, wird das zugrunde liegende Array mit ausreichender Kapazität für Sie neu zugewiesen:

var u = []int{5, 6}
s = append(s, u) // s is now []int{0, 0, 0, 3, 4, 5, 6}
n = len(s) // n == 7
c = cap(s) // c > 5

Es empfiehlt sich daher, beim Erstellen eines Slice ausreichend Kapazität zuzuweisen, wenn Sie wissen, wie viel Speicherplatz Sie benötigen, um unnötige Neuzuordnungen zu vermeiden.

Inhalt von einem Slice in ein anderes Slice kopieren

Wenn Sie den Inhalt eines Slice in ein anfangs leeres Slice kopieren möchten, können Sie folgende Schritte ausführen, um dies zu erreichen:

1. Erstellen Sie das Quell-Slice:

var sourceSlice []interface{} = []interface{}{"Hello",5.10,"World",true}

2. Erstellen Sie die Zielscheibe mit:

• Länge = Länge von sourceSlice

var destinationSlice []interface{} = make([]interface{},len(sourceSlice))

3. Da das zugrunde liegende Array des Ziel-Slice nun groß genug ist, um alle Elemente des Quell-Slice aufzunehmen, können wir die Elemente mithilfe der eingebauten copy :

copy(destinationSlice,sourceSlice)

Slices erstellen

Slices sind der typische Weg, mit dem Programmierer Datenlisten speichern.

Um eine Slice-Variable zu deklarieren, verwenden Sie die Syntax []Type .

var a []int

Um eine Slice-Variable in einer Zeile zu deklarieren und zu initialisieren, verwenden Sie die Syntax []Type{values} .

var a []int = []int{3, 1, 4, 1, 5, 9}

Eine andere Möglichkeit, ein Slice zu initialisieren, ist die Funktion make . Es gibt drei Argumente: den Type des Slice (oder der Karte ), die length und die capacity .

a := make([]int, 0, 5)

Sie können mit append Elemente zu Ihrem neuen Slice hinzufügen.

a = append(a, 5)

Überprüfen Sie mit len die Anzahl der Elemente in Ihrem Slice.

length := len(a)

Überprüfen Sie die Kapazität Ihrer Scheibe mit einer cap . Die Kapazität ist die Anzahl der Elemente, die momentan für den Slice im Speicher vorhanden sind. Sie können bei Kapazität immer an ein Slice anhängen, da Go automatisch ein größeres Slice für Sie erstellt.

capacity := cap(a)

Sie können mit einer typischen Indizierungssyntax auf Elemente in einem Slice zugreifen.

a[0]  // Gets the first member of `a`

Sie können auch eine for Schleife über Scheiben mit range . Die erste Variable ist der Index im angegebenen Array und die zweite Variable ist der Wert für den Index.

for index, value := range a {
    fmt.Println("Index: " + index + " Value: " + value)  // Prints "Index: 0 Value: 5" (and continues until end of slice)
}

Spielplatz gehen

Filtern eines Slice

So filtern Sie ein Slice, ohne ein neues zugrunde liegendes Array zuzuordnen:

// Our base slice
slice := []int{ 1, 2, 3, 4 }
// Create a zero-length slice with the same underlying array
tmp := slice[:0]

for _, v := range slice {
  if v % 2 == 0 {
    // Append desired values to slice
    tmp = append(tmp, v)
  }
}

// (Optional) Reassign the slice
slice = tmp // [2, 4]

Nullwert des Slice

Der Nullwert von Slice ist nil , was die Länge und Kapazität 0 . Ein Slice ohne nil hat kein darunter liegendes Array. Es gibt aber auch Nicht-Null-Scheiben der Länge und Kapazität 0 , wie []int{} oder make([]int, 5)[5:] .

Jeder Typ, der nil-Werte hat, kann in nil Slice umgewandelt werden:

s = []int(nil)

Um zu testen, ob ein Slice leer ist, verwenden Sie:

if len(s) == 0　{
    fmt.Ptintf("s is empty.")
}