Einführung
In Go sindarrays undslicesdata structures, die aus einer geordneten Folge von Elementen bestehen. Diese Datensammlungen eignen sich hervorragend, wenn Sie mit vielen verwandten Werten arbeiten möchten. Mit ihnen können Sie zusammengehörige Daten zusammenhalten, Ihren Code komprimieren und dieselben Methoden und Vorgänge für mehrere Werte gleichzeitig ausführen.
Obwohl Arrays und Slices in Go geordnete Sequenzen von Elementen sind, gibt es signifikante Unterschiede zwischen den beiden. Einarray in Go ist eindata structure, das aus einer geordneten Folge von Elementen besteht, deren Kapazität zum Zeitpunkt der Erstellung definiert wurde. Sobald ein Array seine Größe zugewiesen hat, kann die Größe nicht mehr geändert werden. Aslice ist dagegen eine Version eines Arrays mit variabler Länge, die Entwicklern, die diese Datenstrukturen verwenden, mehr Flexibilität bietet. Slices sind Arrays in anderen Sprachen.
In Anbetracht dieser Unterschiede gibt es bestimmte Situationen, in denen Sie eine über der anderen verwenden würden. Wenn Sie noch nicht mit Go vertraut sind, kann es verwirrend sein, zu bestimmen, wann sie verwendet werden sollen: Obwohl die Vielseitigkeit der Segmente sie in den meisten Situationen zu einer angemesseneren Wahl macht, gibt es bestimmte Fälle, in denen Arrays die Leistung Ihres Programms optimieren können.
In diesem Artikel werden Arrays und Slices ausführlich behandelt. Dort finden Sie die erforderlichen Informationen, um bei der Auswahl zwischen diesen Datentypen die richtige Wahl treffen zu können. Darüber hinaus werden die gängigsten Methoden zum Deklarieren und Arbeiten mit Arrays und Slices beschrieben. Das Lernprogramm enthält zunächst eine Beschreibung der Arrays und ihrer Handhabung, gefolgt von einer Erläuterung der Segmente und ihrer Unterschiede.
Arrays
Arrays sind Sammlungsdatenstrukturen mit einer festgelegten Anzahl von Elementen. Da die Größe eines Arrays statisch ist, muss die Datenstruktur den Speicher nur einmal zuweisen, im Gegensatz zu einer Datenstruktur mit variabler Länge, die den Speicher dynamisch zuweisen muss, damit er in Zukunft größer oder kleiner werden kann. Obwohl die feste Länge der Arrays die Arbeit mit ihnen etwas erschweren kann, kann die einmalige Speicherzuweisung die Geschwindigkeit und Leistung Ihres Programms erhöhen. Aus diesem Grund verwenden Entwickler normalerweise Arrays, wenn sie Programme in Fällen optimieren, in denen die Datenstruktur niemals eine variable Anzahl von Elementen benötigt.
Ein Array definieren
Arrays werden definiert, indem die Größe des Arrays in Klammern[ ] angegeben wird, gefolgt vom Datentyp der Elemente. Für ein Array in Go müssen alle Elemente gleichdata type sein. Nach dem Datentyp können Sie die einzelnen Werte der Array-Elemente in geschweiften Klammern{ } deklarieren.
Das folgende ist das allgemeine Schema zum Deklarieren eines Arrays:
[capacity]data_type{element_values}[.note] #Note: Es ist wichtig zu beachten, dass jede Deklaration eines neuen Arrays einen eigenen Typ erstellt. Obwohl[2]int und[3]int beide ganzzahlige Elemente haben, machen ihre unterschiedlichen Längen ihre Datentypen inkompatibel.
#
Wenn Sie die Werte der Elemente des Arrays nicht deklarieren, ist der Standardwert Null. Dies bedeutet, dass die Elemente des Arrays leer sind. Für ganze Zahlen wird dies durch0 dargestellt, und für Zeichenfolgen wird dies durch eine leere Zeichenfolge dargestellt.
Das folgende Arraynumbers enthält beispielsweise drei ganzzahlige Elemente, die noch keinen Wert haben:
var numbers [3]intWenn Sienumbers drucken, erhalten Sie die folgende Ausgabe:
Output[0 0 0]Wenn Sie die Werte der Elemente beim Erstellen des Arrays zuweisen möchten, setzen Sie die Werte in geschweifte Klammern. Ein Array von Zeichenfolgen mit festgelegten Werten sieht folgendermaßen aus:
[4]string{"blue coral", "staghorn coral", "pillar coral", "elkhorn coral"}Sie können ein Array in einer Variablen speichern und ausdrucken:
coral := [4]string{"blue coral", "staghorn coral", "pillar coral", "elkhorn coral"}
fmt.Println(coral)Wenn Sie ein Programm mit den vorhergehenden Zeilen ausführen, erhalten Sie die folgende Ausgabe:
Output[blue coral staghorn coral pillar coral elkhorn coral]Beachten Sie, dass es beim Drucken keine Abgrenzung zwischen den Elementen im Array gibt, sodass Sie nur schwer erkennen können, wo ein Element endet und ein anderes beginnt. Aus diesem Grund ist es manchmal hilfreich, stattdessen die Funktionfmt.Printfzu verwenden, mit der Zeichenfolgen formatiert werden können, bevor sie auf dem Bildschirm gedruckt werden. Geben Sie dem Verb%q diesen Befehl, um die Funktion anzuweisen, die Werte in Anführungszeichen zu setzen:
fmt.Printf("%q\n", coral)Dies führt zu folgenden Ergebnissen:
Output["blue coral" "staghorn coral" "pillar coral" "elkhorn coral"]Jetzt wird jeder Artikel zitiert. Das Verb
weist den Formatierer an, am Ende eine Zeilenrückgabe hinzuzufügen.
Mit einer allgemeinen Vorstellung davon, wie Arrays deklariert werden und woraus sie bestehen, lernen Sie nun, wie Sie Elemente in einem Array mit einer Indexnummer angeben.
Indizierung von Arrays (und Slices)
Jedes Element in einem Array (und auch ein Slice) kann einzeln durch Indizierung aufgerufen werden. Jedes Element entspricht einer Indexnummer, bei der es sich um einen Wert voninthandelt, der von der Indexnummer0 beginnt und hochzählt.
In den folgenden Beispielen wird ein Array verwendet, Sie können jedoch auch ein Slice verwenden, da beide in der Indizierung identisch sind.
Für das Arraycoral sieht die Indexaufschlüsselung folgendermaßen aus:
| "Blaue Koralle" | "Hirschhornkoralle" | "Säulenkoralle" | "Elchhornkoralle" |
|---|---|---|---|
0 |
1 |
2 |
3 |
Das erste Element, die Zeichenfolge"blue coral", beginnt bei Index0, und das Slice endet bei Index3 mit dem Element"elkhorn coral".
Da jedes Element in einem Slice oder Array eine entsprechende Indexnummer hat, können wir auf sie genauso zugreifen und sie bearbeiten wie mit anderen sequentiellen Datentypen.
Jetzt können wir ein diskretes Element des Slice aufrufen, indem wir auf seine Indexnummer verweisen:
fmt.Println(coral[1])Outputstaghorn coralDie Indexnummern für dieses Slice reichen von0-3, wie in der vorherigen Tabelle gezeigt. Um also eines der Elemente einzeln aufzurufen, beziehen wir uns auf die folgenden Indexnummern:
coral[0] = "blue coral"
coral[1] = "staghorn coral"
coral[2] = "pillar coral"
coral[3] = "elkhorn coral"Wenn wir das Arraycoral mit einer Indexnummer aufrufen, die größer als3 ist, liegt es außerhalb des Bereichs, da es nicht gültig ist:
fmt.Println(coral[18])Outputpanic: runtime error: index out of rangeBeim Indizieren eines Arrays oder Slices müssen Sie immer eine positive Zahl verwenden. Im Gegensatz zu einigen Sprachen, bei denen Sie mit einer negativen Zahl rückwärts indizieren können, führt dies in Go zu einem Fehler:
fmt.Println(coral[-1])Outputinvalid array index -1 (index must be non-negative)Mit dem Operator+können wir Zeichenfolgenelemente in einem Array oder Slice mit anderen Zeichenfolgen verketten:
fmt.Println("Sammy loves " + coral[0])OutputSammy loves blue coralWir konnten das String-Element bei der Indexnummer0 mit dem String"Sammy loves " verketten.
Mit Indexnummern, die Elementen in einem Array oder Slice entsprechen, können wir diskret auf jedes Element zugreifen und mit diesen Elementen arbeiten. Um dies zu demonstrieren, werden wir uns als nächstes ansehen, wie ein Element an einem bestimmten Index geändert wird.
Elemente ändern
Mit der Indizierung können Sie Elemente innerhalb eines Arrays oder Slices ändern, indem Sie ein indexnummeriertes Element auf einen anderen Wert setzen. Dies gibt uns eine bessere Kontrolle über die Daten in unseren Slices und Arrays und ermöglicht es uns, einzelne Elemente programmgesteuert zu bearbeiten.
Wenn wir den Zeichenfolgenwert des Elements am Index1 des Arrayscoral von"staghorn coral" auf"foliose coral" ändern möchten, können wir dies folgendermaßen tun:
coral[1] = "foliose coral"Wenn wir nuncoral drucken, ist das Array anders:
fmt.Printf("%q\n", coral)Output["blue coral" "foliose coral" "pillar coral" "elkhorn coral"]Nachdem Sie nun wissen, wie Sie einzelne Elemente eines Arrays oder Slices bearbeiten, sehen wir uns einige Funktionen an, mit denen Sie flexibler mit Auflistungsdatentypen arbeiten können.
Elemente mitlen() zählen
In Go istlen() eine integrierte Funktion, mit der Sie mit Arrays und Slices arbeiten können. Wie bei Zeichenfolgen können Sie die Länge eines Arrays oder Slice berechnen, indem Sielen() verwenden und das Array oder Slice als Parameter übergeben.
Um beispielsweise herauszufinden, wie viele Elemente sich im Arraycoralbefinden, verwenden Sie Folgendes:
len(coral)Wenn Sie die Länge für das Arraycoral ausdrucken, erhalten Sie die folgende Ausgabe:
Output4Dies gibt die Länge des Arrays4 im Datentypint an, was korrekt ist, da das Arraycoral vier Elemente enthält:
coral := [4]string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral"}Wenn Sie ein Array von Ganzzahlen mit mehr Elementen erstellen, können Sie auch die Funktionlen()verwenden:
numbers := [13]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
fmt.Println(len(numbers))Dies würde zu folgender Ausgabe führen:
Output13Obwohl diese Beispielarrays relativ wenige Elemente enthalten, ist die Funktionlen() besonders nützlich, wenn bestimmt werden soll, wie viele Elemente sich in sehr großen Arrays befinden.
Als Nächstes wird erläutert, wie einem Auflistungsdatentyp ein Element hinzugefügt wird, und wie das Anhängen dieser statischen Datentypen aufgrund der festgelegten Länge von Arrays zu einem Fehler führt.
Anhängen von Elementen mitappend()
append() ist eine in Go integrierte Methode, die einem Sammlungsdatentyp Elemente hinzufügt. Diese Methode funktioniert jedoch nicht, wenn sie mit einem Array verwendet wird. Wie bereits erwähnt, unterscheidet sich ein Array in erster Linie von einem Slice dadurch, dass die Größe eines Arrays nicht geändert werden kann. Dies bedeutet, dass Sie die Werte von Elementen in einem Array zwar ändern können, das Array jedoch nach der Definition nicht vergrößern oder verkleinern können.
Betrachten wir das Array voncoral:
coral := [4]string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral"}Angenommen, Sie möchten das Element"black coral" zu diesem Array hinzufügen. Wenn Sie versuchen, dieappend()-Funktion mit dem Array zu verwenden, geben Sie Folgendes ein:
coral = append(coral, "black coral")Sie erhalten eine Fehlermeldung als Ausgabe:
Outputfirst argument to append must be slice; have [4]stringUm dies zu beheben, erfahren Sie mehr über den Slice-Datentyp, das Definieren eines Slice und das Konvertieren von einem Array in ein Slice.
Scheiben
Aslice ist ein Datentyp in Go, der einemutable oder eine veränderbare, geordnete Folge von Elementen ist. Da die Größe eines Slice variabel ist, gibt es viel mehr Flexibilität bei der Verwendung. Wenn Sie mit Datensammlungen arbeiten, die möglicherweise in Zukunft erweitert oder verkleinert werden müssen, stellt die Verwendung eines Slice sicher, dass Ihr Code bei dem Versuch, die Länge der Sammlung zu manipulieren, nicht auf Fehler stößt. In den meisten Fällen ist diese Wandlungsfähigkeit die mögliche Neuzuweisung von Speicher wert, die manchmal von Slices im Vergleich zu Arrays benötigt wird. Wenn Sie viele Elemente speichern oder über Elemente iterieren müssen und diese Elemente problemlos ändern möchten, möchten Sie wahrscheinlich mit dem Slice-Datentyp arbeiten.
Slice definieren
Slices werden definiert, indem der Datentyp deklariert wird, dem ein leerer Satz eckiger Klammern ([]) und eine Liste von Elementen zwischen geschweiften Klammern ({}) vorangestellt sind. Sie werden feststellen, dass im Gegensatz zu Arrays, bei denen einint zwischen den Klammern erforderlich ist, um eine bestimmte Länge zu deklarieren, ein Slice nichts zwischen den Klammern hat, was seine variable Länge darstellt.
Erstellen wir ein Slice, das Elemente vom Datentyp "Zeichenfolge" enthält:
seaCreatures := []string{"shark", "cuttlefish", "squid", "mantis shrimp", "anemone"}Wenn wir das Slice ausdrucken, sehen wir die Elemente, die sich im Slice befinden:
fmt.Printf("%q\n", seaCreatures)Dies führt zu folgenden Ergebnissen:
Output["shark" "cuttlefish" "squid" "mantis shrimp" "anemone"]Wenn Sie ein Slice einer bestimmten Länge erstellen möchten, ohne die Elemente der Sammlung noch zu füllen, können Sie die integrierte Funktionmake()verwenden:
oceans := make([]string, 3)Wenn Sie dieses Stück drucken, erhalten Sie:
Output["" "" ""]Wenn Sie den Speicher für eine bestimmte Kapazität vorab zuweisen möchten, können Sie ein drittes Argument anmake() übergeben:
oceans := make([]string, 3, 5)Dies würde einen auf Null gesetzten Schnitt mit einer Länge von3 und einer vorab zugewiesenen Kapazität von5 Elementen ergeben.
Sie wissen jetzt, wie ein Slice deklariert wird. Dies löst jedoch noch nicht den Fehler, den wir zuvor mit dem Arraycoralhatten. Um die Funktionappend() mitcoral zu verwenden, müssen Sie zunächst lernen, wie Sie Abschnitte eines Arrays herausschneiden.
Aufteilen von Arrays in Scheiben
Durch die Verwendung von Indexnummern zur Bestimmung von Anfangs- und Endpunkten können Sie einen Unterabschnitt der Werte innerhalb eines Arrays aufrufen. Dies wird alsslicing des Arrays bezeichnet. Sie können dies tun, indem Sie einen Bereich von Indexnummern erstellen, die durch einen Doppelpunkt in Form von[first_index:second_index] getrennt sind. Es ist jedoch wichtig zu beachten, dass beim Schneiden eines Arrays das Ergebnis ein Slice und kein Array ist.
Angenommen, Sie möchten nur die mittleren Elemente des Arrayscoralohne das erste und letzte Element drucken. Sie können dies tun, indem Sie ein Slice erstellen, das bei Index1 beginnt und kurz vor Index3 endet:
fmt.Println(coral[1:3])Wenn Sie ein Programm mit dieser Zeile ausführen, erhalten Sie Folgendes:
Output[foliose coral pillar coral]Wenn Sie ein Slice wie in[1:3] erstellen, beginnt bei der ersten Zahl das Slice (einschließlich), und die zweite Zahl ist die Summe aus der ersten Zahl und der Gesamtzahl der Elemente, die Sie abrufen möchten:
array[starting_index : (starting_index + length_of_slice)]In diesem Fall haben Sie das zweite Element (oder den Index 1) als Ausgangspunkt und insgesamt zwei Elemente aufgerufen. So würde die Berechnung aussehen:
array[1 : (1 + 2)]So sind Sie zu dieser Notation gekommen:
coral[1:3]Wenn Sie den Anfang oder das Ende des Arrays als Start- oder Endpunkt des Slice festlegen möchten, können Sie eine der Zahlen in der Syntax vonarray[first_index:second_index]weglassen. Wenn Sie beispielsweise die ersten drei Elemente des Arrayscoral drucken möchten, dh"blue coral","foliose coral" und"pillar coral", können Sie dies tun, indem Sie Folgendes eingeben:
fmt.Println(coral[:3])Dies wird drucken:
Output[blue coral foliose coral pillar coral]Dies druckte den Anfang des Arrays und stoppte unmittelbar vor dem Index3.
Um alle Elemente am Ende eines Arrays einzuschließen, kehren Sie die Syntax um:
fmt.Println(coral[1:])Dies würde die folgende Scheibe ergeben:
Output[foliose coral pillar coral elkhorn coral]In diesem Abschnitt wurde das Aufrufen einzelner Teile eines Arrays durch Ausschneiden von Unterabschnitten beschrieben. Als Nächstes erfahren Sie, wie Sie mithilfe von Slicing ganze Arrays in Slices konvertieren.
Konvertieren von einem Array in ein Slice
Wenn Sie ein Array erstellen und eine variable Länge festlegen, können Sie es in ein Slice konvertieren. Verwenden Sie zum Konvertieren eines Arrays in ein Slice den Slicing-Prozess, den Sie im SchrittSlicing Arrays into Slicesdieses Lernprogramms gelernt haben. Wählen Sie diesmal jedoch das gesamte Slice aus, indem Sie beide Indexnummern weglassen, die die Endpunkte bestimmen würden:
coral[:]Beachten Sie, dass Sie die Variablecoral nicht in ein Slice selbst konvertieren können, da der Typ einer Variablen, sobald sie in Go definiert ist, nicht mehr geändert werden kann. Um dies zu umgehen, können Sie den gesamten Inhalt des Arrays als Slice in eine neue Variable kopieren:
coralSlice := coral[:]Wenn SiecoralSlice drucken, erhalten Sie die folgende Ausgabe:
Output[blue coral foliose coral pillar coral elkhorn coral]Versuchen Sie nun, das Elementblack coral wie im Array-Abschnitt hinzuzufügen, indem Sieappend() mit dem neu konvertierten Slice verwenden:
coralSlice = append(coralSlice, "black coral")
fmt.Printf("%q\n", coralSlice)Dies gibt das Slice mit dem hinzugefügten Element aus:
Output["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral"]Wir können auch mehr als ein Element in eine einzelneappend()-Anweisung einfügen:
coralSlice = append(coralSlice, "antipathes", "leptopsammia")Output["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral" "antipathes" "leptopsammia"]Um zwei Slices miteinander zu kombinieren, können Sieappend() verwenden. Sie müssen jedoch das zweite Argument erweitern, um es mit der Erweiterungssyntax von...anzuhängen:
moreCoral := []string{"massive coral", "soft coral"}
coralSlice = append(coralSlice, moreCoral...)Output["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral" "antipathes" "leptopsammia" "massive coral" "soft coral"]Nachdem Sie nun gelernt haben, wie Sie ein Element an Ihr Slice anhängen, schauen wir uns an, wie Sie ein Element entfernen.
Ein Element aus einem Slice entfernen
Im Gegensatz zu anderen Sprachen bietet Go keine integrierten Funktionen zum Entfernen eines Elements aus einem Slice. Elemente müssen aus einer Scheibe entfernt werden, indem sie herausgeschnitten werden.
Um ein Element zu entfernen, müssen Sie die Elemente vor diesem Element herausschneiden, die Elemente nach diesem Element herausschneiden und diese beiden neuen Segmente ohne das zu entfernende Element anhängen.
Wenni der Index des zu entfernenden Elements ist, sieht das Format dieses Prozesses folgendermaßen aus:
slice = append(slice[:i], slice[i+1:]...)Entfernen Sie auscoralSlice das Element"elkhorn coral". Dieser Artikel befindet sich an der Indexposition von3.
coralSlice := []string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral", "black coral", "antipathes", "leptopsammia", "massive coral", "soft coral"}
coralSlice = append(coralSlice[:3], coralSlice[4:]...)
fmt.Printf("%q\n", coralSlice)Output["blue coral" "foliose coral" "pillar coral" "black coral" "antipathes" "leptopsammia" "massive coral" "soft coral"]Jetzt befindet sich das Element an der Indexposition3, die Zeichenfolge"elkhorn coral", nicht mehr in unserem SlicecoralSlice.
Mit demselben Ansatz können wir auch einen Bereich löschen. Angenommen, wir wollten nicht nur die Elemente"elkhorn coral", sondern auch"black coral" und"antipathes" entfernen. Wir können einen Bereich im Ausdruck verwenden, um dies zu erreichen:
coralSlice := []string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral", "black coral", "antipathes", "leptopsammia", "massive coral", "soft coral"}
coralSlice = append(coralSlice[:3], coralSlice[6:]...)
fmt.Printf("%q\n", coralSlice)Dieser Code entfernt den Index3,4 und5 aus dem Slice:
Output["blue coral" "foliose coral" "pillar coral" "leptopsammia" "massive coral" "soft coral"]Nachdem Sie nun wissen, wie Sie Elemente zu einem Slice hinzufügen und daraus entfernen, sehen Sie sich an, wie Sie die Datenmenge messen, die ein Slice zu einem bestimmten Zeitpunkt enthalten kann.
Messen der Kapazität eines Slice mitcap()
Da Slices eine variable Länge haben, funktioniertlen()+`method is not the best option to determine the size of this data type. Instead, you can use the `+cap(), um die Kapazität eines Slice zu lernen. Hier sehen Sie, wie viele Elemente ein Slice enthalten kann. Dies hängt davon ab, wie viel Speicher dem Slice bereits zugewiesen wurde.
[.note] #Note: Da Länge und Kapazität eines Arrays immer gleich sind, funktioniert die Funktioncap() auf Arrays nicht.
#
Eine häufige Verwendung fürcap() besteht darin, ein Slice mit einer voreingestellten Anzahl von Elementen zu erstellen und diese Elemente dann programmgesteuert auszufüllen. Dies vermeidet mögliche unnötige Zuweisungen, die auftreten könnten, wennappend() verwendet werden, um Elemente hinzuzufügen, die über die derzeit zugewiesene Kapazität hinausgehen.
Nehmen wir das Szenario, in dem wir eine Liste von Zahlen erstellen möchten,0 bis3. Wir können dazuappend() in einer Schleife verwenden, oder wir können zuerst das Slice vorab zuweisen undcap() verwenden, um die Werte zu durchlaufen.
Zunächst können wir uns die Verwendung vonappend() ansehen:
numbers := []int{}
for i := 0; i < 4; i++ {
numbers = append(numbers, i)
}
fmt.Println(numbers)Output[0 1 2 3]In diesem Beispiel haben wir ein Slice erstellt und dann einefor-Schleife erstellt, die viermal iteriert. Bei jeder Iteration wurde der aktuelle Wert der Schleifenvariableni an den Index desnumbers-Slice angehängt. Dies kann jedoch zu unnötigen Speicherzuordnungen führen, die Ihr Programm verlangsamen können. Beim Hinzufügen zu einem leeren Slice überprüft das Programm bei jedem Aufruf zum Anhängen die Kapazität des Slices. Wenn das Slice durch das hinzugefügte Element diese Kapazität überschreitet, reserviert das Programm zusätzlichen Speicher, um dies zu berücksichtigen. Dies verursacht zusätzlichen Overhead in Ihrem Programm und kann zu einer langsameren Ausführung führen.
Füllen wir nun das Slice ohneappend(), indem wir eine bestimmte Länge / Kapazität vorab zuweisen:
numbers := make([]int, 4)
for i := 0; i < cap(numbers); i++ {
numbers[i] = i
}
fmt.Println(numbers)Output[0 1 2 3]In diesem Beispiel haben wirmake() verwendet, um ein Slice zu erstellen, und es hat4 Elemente vorab zugewiesen. Wir haben dann diecap()-Funktion in der Schleife verwendet, um durch jedes auf Null gesetzte Element zu iterieren und jedes zu füllen, bis es die vorab zugewiesene Kapazität erreicht hat. In jeder Schleife haben wir den aktuellen Wert der Schleifenvariableni in den Index dernumbers-Schicht eingefügt.
Während die Strategienappend() undcap() beide funktional äquivalent sind, vermeidet das Beispielcap()zusätzliche Speicherzuweisungen, die mit der Funktionappend() erforderlich gewesen wären.
Konstruktion mehrdimensionaler Schichten
Sie können auch Slices definieren, die aus anderen Slices bestehen, und zwar als Elemente, wobei jede Liste in Klammern in den größeren Klammern des übergeordneten Slices eingeschlossen ist. Sammlungen solcher Scheiben werden alsmultidimensional slices bezeichnet. Man kann sich vorstellen, dass diese mehrdimensionale Koordinaten darstellen. Beispielsweise könnte eine Sammlung von fünf Schnitten mit jeweils sechs Elementen ein zweidimensionales Gitter mit einer horizontalen Länge von fünf und einer vertikalen Höhe von sechs darstellen.
Untersuchen wir die folgende mehrdimensionale Schicht:
seaNames := [][]string{{"shark", "octopus", "squid", "mantis shrimp"}, {"Sammy", "Jesse", "Drew", "Jamie"}}Um auf ein Element in diesem Segment zuzugreifen, müssen Sie mehrere Indizes verwenden, einen für jede Dimension des Konstrukts:
fmt.Println(seaNames[1][0])
fmt.Println(seaNames[0][0])Im vorhergehenden Code identifizieren wir zuerst das Element bei Index0 des Slice bei Index1, dann geben wir das Element bei Index0 des Slice bei Index0 an . Dies ergibt folgendes:
OutputSammy
sharkNachfolgend sind die Indexwerte für die restlichen einzelnen Elemente aufgeführt:
seaNames[0][0] = "shark"
seaNames[0][1] = "octopus"
seaNames[0][2] = "squid"
seaNames[0][3] = "mantis shrimp"
seaNames[1][0] = "Sammy"
seaNames[1][1] = "Jesse"
seaNames[1][2] = "Drew"
seaNames[1][3] = "Jamie"Wenn Sie mit mehrdimensionalen Slices arbeiten, müssen Sie berücksichtigen, dass Sie auf mehr als eine Indexnummer verweisen müssen, um auf bestimmte Elemente innerhalb des jeweiligen verschachtelten Slices zuzugreifen.
Fazit
In diesem Tutorial haben Sie die Grundlagen der Arbeit mit Arrays und Slices in Go kennengelernt. Sie haben in mehreren Übungen gezeigt, wie Arrays eine feste Länge haben, während Slices eine variable Länge haben, und festgestellt, wie sich dieser Unterschied auf die situative Verwendung dieser Datenstrukturen auswirkt.
Um die Datenstrukturen in Go weiter zu untersuchen, lesen Sie unseren Artikel überUnderstanding Maps in Go oder erkunden Sie die gesamteHow To Code in Go-Reihe.