Scheiben in Golang
In der Go-Sprache ist Slice leistungsfähiger, flexibler und bequemer als ein Array und eine leichtgewichtige Datenstruktur. Slice ist eine Sequenz variabler Länge, die Elemente eines ähnlichen Typs speichert, es ist Ihnen nicht erlaubt, unterschiedliche Typen von Elementen in demselben Slice zu speichern. Es ist wie ein Array mit einem Indexwert und einer Länge, aber die Größe des Segments wird geändert, sie haben nicht wie ein Array eine feste Größe. Slice und ein Array sind intern miteinander verbunden, ein Slice ist eine Referenz auf ein darunterliegendes Array. Es ist erlaubt, doppelte Elemente im Slice zu speichern. Die erste Indexposition in einem Slice ist immer 0 und die letzte ist (Länge des Slice – 1) .
Slice-Erklärung
Ein Slice wird genau wie ein Array deklariert, enthält aber nicht die Größe des Slices. So kann es je nach Anforderung wachsen oder schrumpfen.
Syntax:
[]T
or
[]T{}
or
[]T{value1, value2, value3, ...value n}
Hier ist T der Typ der Elemente. Beispielsweise:
var my_slice[]int
Komponenten von Slice
Ein Slice besteht aus drei Komponenten:
- Zeiger : Der Zeiger wird verwendet, um auf das erste Element des Arrays zu zeigen, auf das durch den Slice zugegriffen werden kann. Hierbei ist es nicht erforderlich, dass das spitze Element das erste Element des Arrays ist.
- Länge: Die Länge ist die Gesamtzahl der im Array vorhandenen Elemente.
- Kapazität: Die Kapazität stellt die maximale Größe dar, bis zu der sie erweitert werden kann.
Lassen Sie uns all diese Komponenten anhand eines Beispiels diskutieren:
Beispiel:
Go
// Golang program to illustrate
// the working of the slice components
package main
import "fmt"
func main() {
// Creating an array
arr := [7]string{"This", "is", "the", "tutorial",
"of", "Go", "language"}
// Display array
fmt.Println("Array:", arr)
// Creating a slice
myslice := arr[1:6]
// Display slice
fmt.Println("Slice:", myslice)
// Display length of the slice
fmt.Printf("Length of the slice: %d", len(myslice))
// Display the capacity of the slice
fmt.Printf("\nCapacity of the slice: %d", cap(myslice))
}
Ausgabe:
Array: [This is the tutorial of Go language] Slice: [is the tutorial of Go] Length of the slice: 5 Capacity of the slice: 6
Erläuterung: Im obigen Beispiel erstellen wir einen Slice aus dem gegebenen Array. Hier zeigte der Zeiger des Slice auf Index 1, da die Untergrenze des Slice auf eins gesetzt ist, sodass der Zugriff auf Elemente ab Index 1 beginnt. Die Länge des Slice beträgt 5, was bedeutet, dass die Gesamtzahl der im Slice vorhandenen Elemente gleich ist 5 und die Kapazität des Slice 6 bedeutet, dass es maximal 6 Elemente darin speichern kann.
Wie erstelle und initialisiere ich ein Slice?
In der Go-Sprache kann ein Slice auf folgende Weise erstellt und initialisiert werden:
- Slice-Literal verwenden: Sie können ein Slice mit dem Slice-Literal erstellen. Die Erstellung eines Slice-Literals ist genauso wie bei einem Array-Literal, aber mit einem Unterschied dürfen Sie die Größe des Slices nicht in den eckigen Klammern [] angeben. Wie im folgenden Beispiel gezeigt, ist die rechte Seite dieses Ausdrucks das Slice-Literal.
var my_slice_1 = []string{"Geeks", "for", "Geeks"}
Hinweis: Denken Sie immer daran, wenn Sie ein Slice mit einem String-Literal erstellen, wird zuerst ein Array erstellt und danach eine Slice-Referenz darauf zurückgegeben.
Beispiel:
Go
// Golang program to illustrate how
// to create a slice using a slice
// literal
package main
import "fmt"
func main() {
// Creating a slice
// using the var keyword
var my_slice_1 = []string{"Geeks", "for", "Geeks"}
fmt.Println("My Slice 1:", my_slice_1)
// Creating a slice
//using shorthand declaration
my_slice_2 := []int{12, 45, 67, 56, 43, 34, 45}
fmt.Println("My Slice 2:", my_slice_2)
}
Ausgabe:
My Slice 1: [Geeks for Geeks] My Slice 2: [12 45 67 56 43 34 45]
- Verwenden eines Arrays: Da wir bereits wissen, dass das Slice die Referenz des Arrays ist, können Sie ein Slice aus dem angegebenen Array erstellen. Um ein Slice aus dem gegebenen Array zu erstellen, müssen Sie zuerst die untere und obere Grenze angeben, was bedeutet, dass Slice Elemente aus dem Array nehmen kann, beginnend mit der unteren Grenze bis zur oberen Grenze. Es enthält nicht die Elemente oben von der oberen Grenze. Wie im folgenden Beispiel gezeigt:
Syntax:
array_name[low:high]
Diese Syntax gibt einen neuen Slice zurück.
Hinweis: Der Standardwert der Untergrenze ist 0 und der Standardwert der Obergrenze ist die Gesamtzahl der Elemente, die in dem gegebenen Array vorhanden sind.
Beispiel:
Go
// Golang program to illustrate how to
// create slices from the array
package main
import "fmt"
func main() {
// Creating an array
arr := [4]string{"Geeks", "for", "Geeks", "GFG"}
// Creating slices from the given array
var my_slice_1 = arr[1:2]
my_slice_2 := arr[0:]
my_slice_3 := arr[:2]
my_slice_4 := arr[:]
// Display the result
fmt.Println("My Array: ", arr)
fmt.Println("My Slice 1: ", my_slice_1)
fmt.Println("My Slice 2: ", my_slice_2)
fmt.Println("My Slice 3: ", my_slice_3)
fmt.Println("My Slice 4: ", my_slice_4)
}
Ausgabe:
My Array: [Geeks for Geeks GFG] My Slice 1: [for] My Slice 2: [Geeks for Geeks GFG] My Slice 3: [Geeks for] My Slice 4: [Geeks for Geeks GFG]
- Bereits vorhandenen Slice verwenden: Es ist auch erlaubt, einen Slice aus dem gegebenen Slice zu erstellen. Um ein Slice aus dem gegebenen Slice zu erstellen, müssen Sie zuerst die untere und obere Grenze angeben, was bedeutet, dass Slice Elemente aus dem gegebenen Slice nehmen kann, beginnend mit der unteren Grenze bis zur oberen Grenze. Es enthält nicht die Elemente oben von der oberen Grenze. Wie im folgenden Beispiel gezeigt:
Syntax:
slice_name[low:high]
Diese Syntax gibt einen neuen Slice zurück.
Hinweis: Der Standardwert der unteren Grenze ist 0 und der Standardwert der oberen Grenze ist die Gesamtzahl der Elemente, die in dem gegebenen Slice vorhanden sind.
Beispiel:
Go
// Golang program to illustrate how to
// create slices from the slice
package main
import "fmt"
func main() {
// Creating s slice
oRignAl_slice := []int{90, 60, 40, 50,
34, 49, 30}
// Creating slices from the given 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]
// Display the result
fmt.Println("Original Slice:", oRignAl_slice)
fmt.Println("New Slice 1:", my_slice_1)
fmt.Println("New Slice 2:", my_slice_2)
fmt.Println("New Slice 3:", my_slice_3)
fmt.Println("New Slice 4:", my_slice_4)
fmt.Println("New Slice 5:", my_slice_5)
}
Ausgabe:
Original Slice: [90 60 40 50 34 49 30] New Slice 1: [60 40 50 34] New Slice 2: [90 60 40 50 34 49 30] New Slice 3: [90 60 40 50 34 49] New Slice 4: [90 60 40 50 34 49 30] New Slice 5: [40 50]
- Verwendung der make()-Funktion: Sie können ein Slice auch mit der make()-Funktion erstellen, die von der go-Bibliothek bereitgestellt wird. Diese Funktion benötigt drei Parameter, dh Typ, Länge und Kapazität. Hier ist der Kapazitätswert optional. Es weist ein zugrunde liegendes Array mit einer Größe zu, die gleich der angegebenen Kapazität ist, und gibt einen Slice zurück, der auf das zugrunde liegende Array verweist. Im Allgemeinen wird die Funktion make() verwendet, um ein leeres Slice zu erstellen. Hier sind leere Slices diejenigen Slices, die eine leere Array-Referenz enthalten.
Syntax:
func make([]T, len, cap) []T
Beispiel:
Go
// Go program to illustrate how to create slices
// Using make function
package main
import "fmt"
func main() {
// Creating an array of size 7
// and slice this array till 4
// and return the reference of the slice
// Using make function
var my_slice_1 = make([]int, 4, 7)
fmt.Printf("Slice 1 = %v, \nlength = %d, \ncapacity = %d\n",
my_slice_1, len(my_slice_1), cap(my_slice_1))
// Creating another array of size 7
// and return the reference of the slice
// Using make function
var my_slice_2 = make([]int, 7)
fmt.Printf("Slice 2 = %v, \nlength = %d, \ncapacity = %d\n",
my_slice_2, len(my_slice_2), cap(my_slice_2))
}
Ausgabe:
Slice 1 = [0 0 0 0], length = 4, capacity = 7 Slice 2 = [0 0 0 0 0 0 0], length = 7, capacity = 7
Wie iteriere ich über ein Slice?
Sie können auf folgende Weise über Slice iterieren:
- Verwenden der for-Schleife: Dies ist der einfachste Weg, Slice zu iterieren, wie im folgenden Beispiel gezeigt:
Beispiel:
Go
// Golang program to illustrate the
// iterating over a slice using
// for loop
package main
import "fmt"
func main() {
// Creating a slice
myslice := []string{"This", "is", "the", "tutorial",
"of", "Go", "language"}
// Iterate using for loop
for e := 0; e < len(myslice); e++ {
fmt.Println(myslice[e])
}
}
Ausgabe:
This is the tutorial of Go language
- Range in for-Schleife verwenden: Es ist erlaubt, mit range in der for-Schleife über ein Slice zu iterieren. Mithilfe von range in der for-Schleife können Sie den Index und den Elementwert erhalten, wie im Beispiel gezeigt:
Beispiel:
Go
// Golang program to illustrate the iterating
// over a slice using range in for loop
package main
import "fmt"
func main() {
// Creating a slice
myslice := []string{"This", "is", "the", "tutorial",
"of", "Go", "language"}
// Iterate slice
// using range in for loop
for index, ele := range myslice {
fmt.Printf("Index = %d and element = %s\n", index+3, ele)
}
}
Ausgabe:
Index = 3 and element = This Index = 4 and element = is Index = 5 and element = the Index = 6 and element = tutorial Index = 7 and element = of Index = 8 and element = Go Index = 9 and element = language
- Verwenden eines leeren Bezeichners in der For-Schleife: Wenn Sie im Bereich der For-Schleife den Indexwert der Elemente nicht erhalten möchten, können Sie anstelle der Indexvariablen ein Leerzeichen (_) verwenden, wie im folgenden Beispiel gezeigt:
Beispiel :
Go
// Golang program to illustrate the iterating over
// a slice using range in for loop without an index
package main
import "fmt"
func main() {
// Creating a slice
myslice := []string{"This", "is", "the",
"tutorial", "of", "Go", "language"}
// Iterate slice
// using range in for loop
// without 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 zu Slice
- Nullwert-Slice: In der Go-Sprache dürfen Sie ein Null-Slice erstellen, das kein Element enthält. Die Kapazität und Länge dieses Slice ist also 0. Das Nil-Slice enthält keine Array-Referenz, wie im folgenden Beispiel gezeigt:
Beispiel:
Go
// Go program to illustrate a zero value slice
package main
import "fmt"
func main() {
// Creating a zero value slice
var myslice []string
fmt.Printf("Length = %d\n", len(myslice))
fmt.Printf("Capacity = %d ", cap(myslice))
}
Ausgabe:
Length = 0 Capacity = 0
- Ändern von Slice: Wie wir bereits wissen, ist Slice ein Referenztyp, der auf ein zugrunde liegendes Array verweisen kann. Wenn wir also einige Elemente im Slice ändern, dann sollten die Änderungen auch im referenzierten Array stattfinden. Oder mit anderen Worten, wenn Sie Änderungen am Slice vorgenommen haben, werden diese auch im Array widergespiegelt, wie im folgenden Beispiel gezeigt:
Beispiel:
Go
// Golang program to illustrate
// how to modify the slice
package main
import "fmt"
func main() {
// Creating a zero value slice
arr := [6]int{55, 66, 77, 88, 99, 22}
slc := arr[0:4]
// Before modifying
fmt.Println("Original_Array: ", arr)
fmt.Println("Original_Slice: ", slc)
// After modification
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]
- Vergleich von Slice: In Slice können Sie nur den Operator == verwenden , um zu überprüfen, ob das angegebene Slice null ist oder nicht. Wenn Sie versuchen, zwei Slices mit Hilfe des Operators == zu vergleichen, erhalten Sie einen Fehler, wie im folgenden Beispiel gezeigt:
Beispiel:
Go
// Golang program to check if
// the slice is nil or not
package main
import "fmt"
func main() {
// creating slices
s1 := []int{12, 34, 56}
var s2 []int
// If you try to run this commented
// code compiler will give an error
/*s3:= []int{23, 45, 66}
fmt.Println(s1==s3)
*/
// Checking if the given slice is nil or not
fmt.Println(s1 == nil)
fmt.Println(s2 == nil)
}
Ausgabe:
false true
Hinweis: Wenn Sie zwei Slices vergleichen möchten, verwenden Sie den Bereich für die Schleife, um jedes Element abzugleichen, oder Sie können die DeepEqual- Funktion verwenden.
- Mehrdimensionales Slice: Mehrdimensionale Slices sind genau wie das multidimensionale Array, außer dass Slice nicht die Größe enthält.
Beispiel:
Go
// Go program to illustrate the multi-dimensional slice
package main
import "fmt"
func main() {
// Creating multi-dimensional slice
s1 := [][]int{{12, 34},
{56, 47},
{29, 40},
{46, 78},
}
// Accessing multi-dimensional slice
fmt.Println("Slice 1 : ", s1)
// Creating multi-dimensional slice
s2 := [][]string{
[]string{"Geeks", "for"},
[]string{"Geeks", "GFG"},
[]string{"gfg", "geek"},
}
// Accessing multi-dimensional slice
fmt.Println("Slice 2 : ", s2)
}
Ausgabe:
Slice 1 : [[12 34] [56 47] [29 40] [46 78]] Slice 2 : [[Geeks for] [Geeks GFG] [gfg geek]]
- Slice sortieren: In der Go-Sprache dürfen Sie die im Slice vorhandenen Elemente sortieren. Die Standardbibliothek der Go-Sprache stellt das Sort-Paket bereit, das verschiedene Arten von Sortiermethoden zum Sortieren der Slices von Ints , Float64s und Strings enthält . Diese Funktionen sortieren die verfügbaren Elemente immer in aufsteigender Reihenfolge.
Beispiel:
Go
// Go program to illustrate how to sort
// the elements present in the slice
package main
import (
"fmt"
"sort"
)
func main() {
// Creating Slice
slc1 := []string{"Python", "Java", "C#", "Go", "Ruby"}
slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89}
fmt.Println("Before sorting:")
fmt.Println("Slice 1: ", slc1)
fmt.Println("Slice 2: ", slc2)
// Performing sort operation on the
// slice using sort function
sort.Strings(slc1)
sort.Ints(slc2)
fmt.Println("\nAfter sorting:")
fmt.Println("Slice 1: ", slc1)
fmt.Println("Slice 2: ", slc2)
}
Ausgabe:
Before sorting: Slice 1: [Python Java C# Go Ruby] Slice 2: [45 67 23 90 33 21 56 78 89] After sorting: Slice 1: [C# Go Java Python Ruby] Slice 2: [21 23 33 45 56 67 78 89 90]