Go Sprachelemente (Slice)

In der Sprache Go ist SliceArrayStärker, flexibel, bequem und leichtgewichtig. Eine Datenstruktur, die sich anpassen lässt. Slice ist eine veränderbare Sequenz mit variabler Länge, die zur Speicherung von Elementen desselben Typs verwendet wird und die Speicherung verschiedener Typen in einem Slice nicht zulässt. Wie ein Array mit Indizes und Länge, aber die Größe eines Slices kann angepasst werden, und ein Slice ist nicht wie ein Array auf eine feste Größe festgelegt. Intern sind Slice und Array miteinander verbunden, und ein Slice ist eine Referenz auf das Basisarray. Es ist erlaubt, wiederholte Elemente in einem Slice zu speichern.Der erste Indexort im Schnitt ist immer 0, während der letzte Indexort (Länge des Schnittes - 1) sein wird. 1).

Erklärung des Schnittes

Die Erklärung des Schnittes ist wie bei einem Array, aber ohne die Größe des Schnittes. Daher kann er nach Bedarf wachsen oder schrumpfen.

Syntax:

[]T
oder
[]T{}
oder
[]T{value1, value2, value3, ...value n}

Hierbei ist T der Typ des Elements. Zum Beispiel:

var my_slice[]int

Bestandteile des Schnittes

Ein Schnitt enthält drei Komponenten:

• Zeiger:Der Zeiger wird verwendet, um auf den ersten Element des Arrays zu verweisen, das durch den Schnitt zugänglich ist. Hier muss das verweisende Element nicht der erste Element des Arrays sein.

• Länge:Die Länge ist die Gesamtzahl der Elemente, die im Array existieren.

• Kapazität:Die Kapazität bedeutet die maximale erweiterbare Größe.

Lassen Sie uns alle diese Komponenten anhand von Beispielen diskutieren:

//Schnitt
package　main
import　"fmt"
func　main()　{
　　　　//Erstellen Sie ein Array
　　　　arr := [7string{"das", "ist", "Golang", "Grundlage", "Lehr", "Online", "de.oldtoolbag.com"
　　　　//zeigt das Array an
　　　　fmt.Println("Array:", arr)
　　　　//Erstellen eines Slices
　　　　myslice := arr[1:6]
　　　　//zeigt den Schnitt an
　　　　fmt.Println("Schnitt:", myslice)
　　　　//zeigt die Länge des Schnittes an
　　　　fmt.Printf("Länge des Schnittes: %d", len(myslice))
　　　　//zeigt die Kapazität des Schnittes an
　　　　fmt.Printf("\nKapazität des Schnittes: %d", cap(myslice))
}

Ausgabe:

Array: [das ist die Golang-Basis-Unterricht Online de.oldtoolbag.com]
Schnitt: [ist die Grundlage der Golang-Basis-Unterricht Online]
Länge des Schnittes:　5
Kapazität des Schnittes:　6

Verwendungserklärung:Im obigen Beispiel erstellen wir einen Schnitt aus einem gegebenen Array. Hier weist der Zeiger auf Index1zuzugreifen, weil der untere Grenzwert des Schnittes auf1, daher beginnt es, ab Index1der Elemente. Die Länge des Schnittes ist5, zeigt die Gesamtzahl der Elemente im Schnitt an5, während der Schnitt6Die Kapazität bedeutet, dass am meisten gespeichert werden kann6von Elementen.

Wie erstellt und initialisiert man Schichten?

In der Programmiersprache Go können Sie auf die folgenden Arten Schichten erstellen und initialisieren:

• Verwenden Sie den Schnittwortliterals:Sie könnenVerwenden Sie den SchnittwortliteralsErstellen Sie einen Schnitt. Der Erstellung eines Schnittwortliterals ähnelt der eines Arraywortliterals, aber mit einem Unterschied: Es ist Ihnen nicht gestattet, die Größe des Schnittes in eckigen Klammern [] zu spezifizieren. Wie im folgenden Beispiel gezeigt, ist die rechte Seite ein Schnittwortliterals.

  var my_slice_1　= []string "{w3codeboxs "for", "w3codeboxs "}

  Hinweis:Behalten Sie im Auge, dass ein Slice aus einem Stringtext erstellt wird, zunächst ein Array erstellt wird, und dann eine Referenz auf diesen Slice zurückgegeben wird.

  Beispiel

  //　Verwenden Sie einen Slice-Literal
  package　main
  import　"fmt"
  func　main()　{
  　　　　//Verwenden Sie den Schlüsselwort "var", um einen Slice zu erstellen
  　　　　var my_slice_1　= []string "{w3codeboxs "for", "w3codeboxs "}
  　　　　fmt.Println("Mein Slice　1:", my_slice_1)
  　　　　//Erstellen eines Slices
  　　　　//Verwenden Sie eine verkürzte Deklaration
  　　　　my_slice_2　:=　[]int{12,　45,　67,　56,　43,　34,　45}
  　　　　fmt.Println("Mein Slice　2:", my_slice_2)
  }

  Ausgabe:

  Mein Slice　1: [w3codeboxs for w3codeboxs]
  Mein Slice　2: [12　45　67　56　43　34　45]

• Verwenden Sie das Array:Wir haben bereits erfahrenEin Slice ist eine Referenz auf ein ArrayDaher können Sie einen Slice aus einem gegebenen Array erstellen. Um einen Slice aus einem gegebenen Array zu erstellen, müssen zuerst der untere und der obere Grenzwert angegeben werden, was bedeutet, dass der Slice von der unteren Grenze bis zur oberen Grenze Elemente aus dem Array entnehmen kann. Es wird nicht das Element von der oberen Grenze mit einbezogen. Wie im folgenden Beispiel gezeigt wird:

  Syntax:

  array_name[low:high]

  Diese Syntax gibt einen neuen Slice zurück.

  Hinweis:Der Standardwert für den unteren Grenzwert ist 0, der Standardwert für den oberen Grenzwert ist die Gesamtzahl der Elemente im gegebenen Array.

• Beispiel

  //Erstellen Sie einen Slice aus einem Array
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　//Erstellen Sie ein Array
  　　　　arr := [4]string "{w3codeboxs "for", "w3codeboxs "GFG"}　
  　　
  　　　　//Erstellen Sie einen Slice aus einem gegebenen Array　
  　　　　var my_slice_1　= arr[1:2]　
  　　　　my_slice_2　:= arr[0:　
  　　　　my_slice_3　:= arr[:2]　
  　　　　my_slice_4　:= arr[:　
  　　
  　　　　//Anzeigeergebnis
  　　　　fmt.Println("Meine Liste: ", arr)　
  　　　　fmt.Println("Mein Slice　1: ", my_slice_1)　
  　　　　fmt.Println("Mein Slice　2: ", my_slice_2)　
  　　　　fmt.Println("Mein Slice　3: ", my_slice_3)　
  　　　　fmt.Println("Mein Slice　4: ", my_slice_4)　
  }

  Ausgabe:

  Meine Liste: [w3codeboxs for w3codeboxs GFG]
  Mein Slice　1: [for]
  Mein Slice　2: [w3codeboxs for w3codeboxs GFG]
  Mein Slice　3: [w3codeboxs for]
  Mein Slice　4: [w3codeboxs for w3codeboxs GFG]

• Verwenden Sie einen bereits vorhandenen Slice:Man kann auch einen Slice aus einem gegebenen Slice erstellen. Um einen Slice aus einem gegebenen Slice zu erstellen, müssen zuerst der untere und der obere Grenzwert angegeben werden, was bedeutet, dass der Slice von der unteren Grenze bis zur oberen Grenze Elemente aus dem gegebenen Slice entnehmen kann. Es wird nicht das Element von der oberen Grenze mit einbezogen. Wie im folgenden Beispiel gezeigt wird:

  Syntax:

  slice_name[low:high]

  Diese Syntax gibt einen neuen Slice zurück.

  Hinweis:Der Standardwert für den unteren Grenzwert ist 0, der Standardwert für den oberen Grenzwert ist die Gesamtzahl der Elemente im gegebenen Slice.

  Beispiel

  //Erstellen Sie einen Slice aus einem Slice
  package　main
  import　"fmt"
  func　main()　{
  　　　　//Erstellen eines Slices
  　　　　oRignAl_slice := []int{90,　60,　40,　50,　34,　49,　30}
  　　　　//Erstellen Sie einen Slice aus einem gegebenen Slice
  　　　　var my_slice_1　= oRignAl_slice[1:5]
  　　　　my_slice_2　:= oRignAl_slice[0:
  　　　　my_slice_3　:= oRignAl_slice[:6]
  　　　　my_slice_4　:= oRignAl_slice[:
  　　　　my_slice_5　:= my_slice_3[2:4]
  　　　　//Anzeigeergebnis
  　　　　fmt.Println("Ursprünglicher Slice:", oRignAl_slice)
  　　　　fmt.Println("Neue Schere"　1:", my_slice_1)
  　　　　fmt.Println("Neue Schere"　2:", my_slice_2)
  　　　　fmt.Println("Neue Schere"　3:", my_slice_3)
  　　　　fmt.Println("Neue Schere"　4:", my_slice_4)
  　　　　fmt.Println("Neue Schere"　5:", my_slice_5)
  }

  Ausgabe:

  Ursprüngliche Schere: [90　60　40　50　34　49　30]
  Neue Schere　1: [60　40　50　34]
  Neue Schere　2: [90　60　40　50　34　49　30]
  Neue Schere　3: [90　60　40　50　34　49]
  Neue Schere　4: [90　60　40　50　34　49　30]
  Neue Schere　5: [40　50]

• Verwenden Sie die make() Funktion:Sie können auch die von der go-Bibliothek bereitgestelltenmake() FunktionErstellen Sie die Schere. Diese Funktion nimmt drei Parameter, nämlich Typ, Länge und Kapazität. Hier ist der Kapazitätswert optional. Es wird die Größe des zugrunde liegenden Arrays, die gleich dem angegebenen Kapazitätswert ist, zugewiesen und eine Schere zurückgegeben, die das zugrunde liegende Array referenziert. Der make()-Funktion wird normalerweise zur Erstellung eines leeren Arrays verwendet. Hier sind leere Arrays diejenigen, die Referenzen auf leere Arrays enthalten.

  Syntax:

  func make([]T, len, cap) []T

  Beispiel

  //Verwenden Sie die make-Funktion
  package　main
  import　"fmt"
  func　main()　{
  　　　　//Erstellen Sie eine Schere mit7des Arrays
  　　　　//Dieses Array in4
  　　　　//und geben Sie den Verweis auf die Schere zurück
  　　　　//Verwenden Sie die make-Funktion
  　　　　var my_slice_1　= make([]int,　4,　7)
  　　　　fmt.Printf("Schere　1　= %v, 
  Länge = %d, 
  Kapazität = %d
  ", my_slice_1, len(my_slice_1), cap(my_slice_1))
  　　　　//Erstellen Sie einen anderen mit7des Arrays
  　　　　//und geben Sie den Verweis auf die Schere zurück
  　　　　//Verwenden Sie die make-Funktion
  　　　　var my_slice_2　= make([]int,　7)
  　　　　fmt.Printf("Schere　2　= %v, 
  Länge = %d, 
  Kapazität = %d
  ", my_slice_2, len(my_slice_2), cap(my_slice_2))
  }

  Ausgabe:

  Slice　1　= [0 0 0 0],　
  Länge =　4,　
  Kapazität =　7
  Slice　2　= [0 0 0 0 0 0 0],　
  Länge =　7,　
  Kapazität =　7

Wie kann man eine Schere durchlaufen?

Sie können die folgenden Methoden verwenden, um die Schere zu durchlaufen:

• Verwenden Sie die for-Schleife:Dies ist die einfachste Methode zur Iteration der Schere, wie im folgenden Beispiel gezeigt:

  Beispiel

  //　for-Schleife iteriert die Schere
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　//Erstellen eines Slices
  　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
  　　
  　　　　//Verwenden Sie die for-Schleife zum Iterieren
  　　　　for e := 0; e < len(myslice); e++　{　
  　　　　　　　　fmt.Println(myslice[e])　
  　　　　}　
  }

  Ausgabe:

  Dies
  ist
  das
  Anleitung
  von
  Go
  Sprache

• In der for-Schleife wird der Bereich verwendet:Es ist erlaubt, den Bereich in der for-Schleife zur Iteration der Schere zu verwenden. In der for-Schleife kann mit range der Index und der Wert des Elements erhalten werden, wie im Beispiel gezeigt:

  Beispiel

  //In der for-Schleife wird der Bereich der Schere verwendet
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　//Erstellen eines Slices
  　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
  　　
  　　　　　　　　//Iterieren eines Slices
  　　　　　　　　//Verwendung von range im for-Loop
  　　　　for index, ele := range myslice {　
  　　　　　　　　fmt.Printf("Index = %d und element = %s\n", index+3, ele)　
  　　　　}　
  }

  Ausgabe:

  Index =　3　und element = Dies
  Index =　4　und element = ist
  Index =　5　und element = das
  Index =　6　und element = Anleitung
  Index =　7　und element = von
  Index =　8　und element = Go
  Index =　9　und element = Sprache

• Verwendung eines Leerzeichens im for-LoopInnerhalb des Bereichs, wenn Sie den Indexwert des Elements nicht erhalten möchten, können Sie ein Leerzeichen (_)-Zeichen anstelle des Indexvariablen verwenden, wie im folgenden Beispiel gezeigt wird:
  

  Beispiel

  //Verwendung von range im for-Loop ohne Index　
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　//Erstellen eines Slices　
  　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
  　　
  　　　　　　　　//Iterieren eines Slices
  　　　　　　　　//Verwendung von range im for-Loop
  　　　　　　　　//Keine Index
  　　　　for _, ele := range myslice {　
  　　　　　　　　fmt.Printf("Element = %s\n", ele)　
  　　　　}　
  }

  Ausgabe:

  Element = This
  Element = is
  Element = the
  Element = tutorial
  Element = of
  Element = Go
  Element = language

Wichtige Punkte über Slices

1. Leerer Slice:In der Sprache Go ist es erlaubt, einen Slice ohne Elemente zu erstellen. Daher beträgt die Kapazität und die Länge dieses Slices 0. Ein nil-Slice enthält keine Referenz auf ein Array, wie im folgenden Beispiel gezeigt wird:

   Beispiel

   package　main　
   　　
   import　"fmt"
   　　
   func　main()　{　
   　　
   　　　　//　Erstellung eines leeren Slice
   　　　　var myslice []string　
   　　　　fmt.Printf("Length = %d\n", len(myslice))　
   　　　　fmt.Printf("Capacity = %d ", cap(myslice))　
   　　
   }

   Ausgabe:

   Length = 0
   Capacity = 0

2. Änderung des Slices:Wie wir bereits wissen, ist ein Slice ein Referenztyp, daher kann er auf das Basissubarray verweisen. Wenn wir also einige Elemente im Slice ändern, sollte diese Änderung auch im Referenzarray auftreten. Mit anderen Worten, wenn Sie Änderungen am Slice vornehmen, wird dies auch im Array widergespiegelt, wie im folgenden Beispiel gezeigt wird:

   Beispiel

   //Wie man einen Slice ändert
   package　main　
   　　
   import　"fmt"
   　　
   func　main()　{　
   　　
   　　　　//Erstellung eines leeren Slice
   　　　　arr := [6]int{55,　66,　77,　88,　99,　22}　
   　　　　slc := arr[0:4]　
   　　
   　　　　//vor der Änderung
   　　
   　　　　fmt.Println("Original_Array:　", arr)　
   　　　　fmt.Println("Original_Slice:　", slc)　
   　　
   　　　　//geändert　
   　　　　slc[0]　=　100　
   　　　　slc[1]　=　1000　
   　　　　slc[2]　=　1000　
   　　
   　　　　fmt.Println("\nNew_Array:　", arr)　
   　　　　fmt.Println("New_Slice:　", slc)　
   }

   Ausgabe:

   Original_Array:　　[55　66　77　88　99　22]
   Original_Slice:　　[55　66　77　88]
   New_Array:　　[100　1000　1000　88　99　22]
   New_Slice:　　[100　1000　1000　88]

3. Vergleich von Slices:in einem Slice können Sie nur==Operator überprüft, ob der gegebene Slice existiert. Wenn Sie==unterstützt werden können. Wenn Sie versuchen, die Vergleichsoperator

   Beispiel

   //Prüfen Sie, ob der Slice leer ist
   package　main　
   　　
   import　"fmt"
   　　
   func　main()　{　
   　　
   　　　　//Erstellen eines Slices
   　　　　s1　:=　[]int{12,　34,　56}　
   　　　　var　s2　[]int
   　　
   　　　　　　　　//Wenn Sie versuchen, diesen Kommentar auszuführen
   　　　　　　　　//Der Compiler gibt einen Fehler aus
   　　　　/*s3:=　[]int{23,　45,　66}　
   　　　　　　fmt.Println(s1==s3)　
   　　　　*/
   　　
   　　　　//Überprüfen Sie, ob der gegebene Slice nil ist
   　　　　fmt.Println(s1　==　nil)　
   　　　　fmt.Println(s2　==　nil)　
   }

   Ausgabe:

   false
   true

   Hinweis:Wenn Sie zwei Slices vergleichen möchten, verwenden Sie einen Loop mit Range, um jedes Element abzugleichen, oder Sie könnenDeepEqualFunktionen.

4. Mehrdimensionale Slices:Mehrdimensionale Slices sind wie mehrdimensionale Arrays, nur dass Slices keine Größe haben.

   Beispiel

   package　main　
   　　
   import　"fmt"
   　　
   func　main()　{　
   　　
   　　　　//Erstellen mehrdimensionaler Slices
   　　　　s1　:=　[][]int{{12,　34},　
   　　　　　　　　{56,　47},　
   　　　　　　　　{29,　40},　
   　　　　　　　　{46,　78},　
   　　　　}　
   　　
   　　　　//Zugriff auf mehrdimensionale Slices
   　　　　fmt.Println("Slice　1　:　",　s1)　
   　　
   　　　　//Erstellen mehrdimensionaler Slices　
   　　　　s2　:=　[][]string{　
   　　　　　　　　[]string{"w3codeboxs",　"for"},　
   　　　　　　　　[]string{"w3codeboxs",　"GFG"},　
   　　　　　　　　[]string{"gfg",　"w3codebox"},　
   　　　　}　
   　　
   　　　　//Zugriff auf mehrdimensionale Slices
   　　　　fmt.Println("Slice　2　:　",　s2)　
   　　
   }

   Ausgabe:

   Slice　1　:　　[[12　34]]56　47]]29　40]　[46　78]]
   Slice　2　:　　[[w3codeboxs　for]　[w3codeboxs　GFG]　[gfg　w3codebox]]

5. Slice-Sortierung:In der Programmiersprache Go können die Elemente in einem Slice sortiert werden. Die Standardbibliothek von Go bietet den Sortierpaket, das Funktionen für die Sortierung von int, float64verschiedene Sortiermethoden für Stringslices. Diese Funktionen sortieren stets die Slice nach aufsteigender Reihenfolge der verfügbaren Elemente.

   Beispiel

   //Existierende Elemente im Slice
   package　main　
   　　
   import　("　
   　　　　"fmt"
   　　　　"sort"
   )　
   　　
   func　main()　{　
   　　
   　　　　//Erstellen eines Slices
   　　　　slc1　:=　[]string{"Python",　"Java",　"C#",　"Go",　"Ruby"}　
   　　　　slc2　:=　[]int{45,　67,　23,　90,　33,　21,　56,　78,　89}　
   　　
   　　　　fmt.Println("Vor der Sortierung:")　
   　　　　fmt.Println("Slice　1:　",　slc1)　
   　　　　fmt.Println("Slice　2:　",　slc2)　
   　　
   　　　　//Die Verwendung von Sortierfunktionen für Slices
   　　　　sort.Strings(slc1)　
   　　　　sort.Ints(slc2)　
   　　
   　　　　fmt.Println("\nSortiert nach:")　
   　　　　fmt.Println("Slice　1:　",　slc1)　
   　　　　fmt.Println("Slice　2:　",　slc2)　
   　　
   }

   Ausgabe:

   Sortiert vor:
   Slice　1:　　[Python　Java　C#　Go　Ruby]
   Slice　2:　　[45　67　23　90　33　21　56　78　89]
   Sortiert:
   Slice　1:　　[C#　Go　Java　Python　Ruby]
   Slice　2:　　[21　23　33　45　56　67　78　89　90]