Golang Slice

Dieser Artikel wird tief in die Arbeit mit Scheiben in der Go -Programmiersprache eintauchen.

Wir sind alle mit Arrays vertraut, entweder in Go oder in anderen Programmiersprachen. Ein Array ist eine Sammlung von Elementen eines verwandten Datentyps (abhängig). In Go kann ein Array nur Elemente eines ähnlichen Typs halten. Arrays haben eine feste Länge und können nicht wachsen oder schrumpfen, sobald die Größe definiert ist.

Ein Schicht ist eine dynamisch große Ansicht der Elemente eines Arrays. Eine Scheibe ist sehr flexibel, sodass Sie die Größe der Größe ändern können. Die Größe muss jedoch unter der Kapazität des zugrunde liegenden Arrays bleiben.

Eine Scheibe deklarieren

Wir können eine Scheibe mit einer einfachen Syntax wie unten gezeigt deklarieren:

var Slice_Name [] Daten _type

In der obigen Syntax beginnen wir zunächst den Slice_Name, gefolgt von einem Paar quadratische Klammern und dem Datentyp für das Slice.

Sie werden feststellen, dass die Scheibenerklärung der eines Arrays sehr ähnlich ist. Wir geben jedoch keine Größe für ein Stück an.

Scheibe erstellen - Methode 1

Es gibt zwei Methoden, um ein Stück in Go zu erstellen. Das erste ist die Verwendung des wörtlichen Formats. Dies ist der in der obigen Syntax gezeigten genau ähnlich.

Der folgende Code erstellt beispielsweise ein Stück namens My_Slice:

Paket Main
importieren "fmt"
funcmain ()
var my_slice = [] int 1, 2, 3, 4, 5, 6
fmt.Println (my_slice)

Das obige Beispiel erzeugt eine Scheibe vom Typ int mit Standardwerten. Wenn Sie nicht die VAR -Methode der Variablendeklaration verwenden möchten, können Sie die folgende Syntax verwenden:

my_slice: = [] int 1,2,3,4,5,6

Die obige Methode ist als Slice buchstäblich bekannt.

Scheibe erstellen - Methode 2

Die zweite Methode zum Erstellen eines Slice in GO besteht darin, die Funktion Make -Funktion zu verwenden.

Die Syntax ist wie:

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

Die Funktion nimmt in diesem Fall einen Datentyp, eine Länge und Kapazität an. Die Funktion zuteilt ein Array mit der Größe, wie durch den Kapazitätsparameter angegeben. Die Funktion gibt ein Slice zurück, das auf dieses Array verweist.

Um es in der Praxis zu sehen, siehe unten:

Slice_var: = make ([] int, 10)
fmt.Println (Slice_var)

In diesem Beispiel wird ein Stück der Größe 10 und des Int -Typs deklariert. Die resultierende Ausgabe ist eine Scheibe von 0 Werten.

[0 0 0 0 0 0 0 0 0]

Sie können die Werte mithilfe der Indexnotation dem Slice zuweisen.

Um einen Wert bei Index 1 zuzuweisen, können wir dies tun:

Slice_var [0] = 10
fmt.Println (Slice_var)

Der obige Code sollte zurückgeben:

[10 0 0 0 0 0 0 0 0]

Beachten Sie, dass das Element bei Index 0 aktualisiert wird, um den neuen Wert widerzuspiegeln.

Scheibeneigenschaften

Es gibt zwei wichtige Eigenschaften einer Scheibe, mit der Sie vertraut sein sollten. Die Länge und die Kapazität.

Die Länge der Scheibe bezieht sich auf die Gesamtzahl der von der Scheibe gehaltenen Elemente. Dies wird aus dem ersten Element der Scheibe gezählt.

Um die Länge und die Kapazität einer Scheibe zu erhalten, können Sie die Methoden Len () bzw. CAP () verwenden.

Ein Beispiel ist wie nachstehend demonstriert:

Paket Main
importieren "fmt"
funcmain ()
Varmy_Slice = [] int 1, 2, 3, 4, 5, 6
fmt.Println ("Länge:", Len (my_Slice))
fmt.Println ("Kapazität:", Cap (my_slice))

Der obige Beispielcode sollte die Länge und die Kapazität des Slice als:

Engles: 6
Kapazität: 6

Gehen Sie Indexschneide

Wussten Sie, dass wir ein Stück aus vorhandenen Scheiben bilden können?

Wir können dies erreichen, indem wir einen index gebundenen Index mit einer niedrigen und hohen Bindung angeben. Zum Beispiel ein neues Stück mit Elementen von Index 1 bis 5 erstellen:

NEW_SLICE: = MY_SLICE [1: 5]
fmt.Println (new_slice)
Die resultierende Scheibe wird:
[2 3 4 5]

Iteration in Scheiben

Wir können über ein Array mit dem Klassiker für eine Schleife iterieren.

Zum Beispiel:

Paket Main
importieren "fmt"
funcmain ()
Varmy_Slice = [] String "Python", "JavaScript", "Go", "Rust", "Dart"
FORI, Item: = Rangemy_Slice
fmt.Println (ich, Artikel)

Im obigen Beispiel verwenden wir eine für die Schleife und eine Range -Anweisung, um über den Index und das Element des Slice zu iterieren. Die resultierende Ausgabe:

0 Python
1 JavaScript
2 Gehen Sie
3 Rost
4 Dart

Wenn Sie die Range -Anweisung nicht verwenden möchten, um über die Scheibe zu schleifen, können Sie die Länge der Scheibe als:

für i: = 0; ich < len(my_slice); i++
fmt.Println (my_slice [i])

Das obige Beispiel gibt eine ähnliche Ausgabe wie die Verwendung des Bereichskonstrukts zurück.

Gehen Sie das Element kopieren

Mit der Kopiermethode können Sie Elemente von einer Slice zu einer anderen kopieren. Betrachten Sie das folgende Beispiel:

funccopy_slice ()
Slice_1: = [] int 1, 2, 3, 4, 5
Slice_2: = [] int 6, 7, 8, 9, 10
NEW_SLICE: = COPY (SLICE_1, SLICE_2)
fmt.Printf ("%d Elemente kopiert", New_Slice)

Die Funktion gibt die Gesamtzahl der kopierten Elemente zurück.

Mehrdimensionale Scheibe

Sie können auch ein mehrdimensionales Stück erstellen. Es bedeutet im Grunde genommen ein Stück Scheiben. Ein Beispiel ist wie gezeigt:

funcmulti_slice ()
Multi_Slice: = [] [] int
1, 2,
3, 4,
5, 6,
7, 8,

fmt.Println (multi_slice)

Das obige Beispiel sollte eine mehrdimensionale Scheibe als:

[[1 2] [3 4] [5 6] [7 8]]

Um in einem mehrdimensionalen Array auf Elemente zuzugreifen, können Sie Indizes als:

fmt.Println (multi_slice [0] [0])

Die obige Syntax gibt das erste Element in der ersten Scheibe zurück.

Abschluss

Dieser Leitfaden hilft Ihnen bei den Grundlagen der Arbeit mit Scheiben in Go. Obwohl wir die Scheiben im Bereich dieses Tutorials nicht erschöpfen können, sollte es Ihnen den Einstieg bringen.