Slices: Das Rückgrat von Go!

Okay, tauchen wir ein in eine der vielseitigsten und wichtigsten Funktionen von Go – Slices. Wenn Sie aus einer anderen Sprache kommen, stellen Sie sich Slices möglicherweise ähnlich wie Arrays vor. Und ja, sie haben einige Ähnlichkeiten, aber Slices bringen viel mehr Kraft, Flexibilität und Go-spezifische Magie auf den Tisch! ?

Was ist überhaupt ein Slice? ?

In Go sind Slices ein Typ, mit dem Sie mit Listen von Elementen arbeiten können (wie ein Array), aber sie sind dynamisch, was bedeutet, dass sie je nach Bedarf wachsen und schrumpfen können. Es ist nicht erforderlich, im Voraus eine feste Länge anzugeben, wie Sie es bei einem Array tun würden. Sie werden durch Arrays unter der Haube unterstützt, aber Sie erhalten so viel mehr Kontrolle. Betrachten Sie sie als die cooleren und flexibleren Geschwister von Arrays.

Ein Slice in Go ist also eigentlich ein „Fenster“ über einem zugrunde liegenden Array. Sie können die Größe dieses Fensters ändern, indem Sie es vergrößern oder verkleinern – und es ist so glatt, als würde man ein Stück Kuchen anschneiden. ?

Ein Slice erstellen?
Das Erstellen eines Slice ist ziemlich einfach:

// Using a literal
numbers := []int{1, 2, 3, 4, 5}

// Using the make function
sliceOfStrings := make([]string, 5) // a slice of 5 strings, each 

mit einer leeren Zeichenfolge initialisiert
Mit make weisen Sie Go an, ein Slice mit einer bestimmten Länge zu erstellen, das jedoch von einem Array unterstützt wird, das es für Sie verwaltet. Sie müssen sich also keine Gedanken über die Details der Speicherzuteilung machen. ?

Länge und Kapazität?

Zwei entscheidende Konzepte bei Scheiben sind Länge und Kapazität. Die Länge ist die Anzahl der Elemente, die sich derzeit im Slice befinden, während die Kapazität die Gesamtzahl der Elemente ist, die es aufnehmen kann, bevor die Größe geändert werden muss.

numbers := []int{1, 2, 3}
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // 3 (same as length here)

Wenn Sie mit dem Anhängen von Elementen beginnen, verdoppelt Go die Kapazität, sobald es voll ist, sodass Sie sich keine Sorgen machen müssen, dass Sie an eine Obergrenze stoßen.

numbers = append(numbers, 4)
fmt.Println(len(numbers)) // 4
fmt.Println(cap(numbers)) // probably 6 now, depending on Go’s growth 

Muster
An Slices anhängen: Gos integrierte Magie ?✨
Mit der Append-Funktion von Go ist das Hinzufügen von Elementen zu einem Slice ein Kinderspiel. Sie können ein oder mehrere Elemente auf einmal hinzufügen, und Go übernimmt die gesamte Größenänderung und Speicherverwaltung für Sie.

numbers := []int{1, 2, 3}
numbers = append(numbers, 4, 5, 6) // Adding multiple elements at once
fmt.Println(numbers) // [1 2 3 4 5 6]

Diese Funktion zur automatischen Größenänderung macht Slices sehr praktisch, insbesondere wenn Sie nicht wissen, wie groß Ihre Liste sein wird.

Eine Scheibe schneiden??

Das Slicen in Go macht wirklich Spaß. Sie können ein „Unter-Slice“ eines vorhandenen Slice erstellen, ohne die Elemente zu kopieren.

numbers := []int{10, 20, 30, 40, 50}
subSlice := numbers[1:4] // Just takes a "slice" of the original slice
fmt.Println(subSlice) // [20 30 40]

In Zahlen[1:4] ist der erste Index (1) inklusive und der letzte Index (4) exklusiv. Am Ende befinden sich die Elemente an den Positionen 1, 2 und 3, aber nicht an 4.

Dieses Sub-Slice nutzt immer noch das gleiche zugrunde liegende Array wie das Original-Slice, daher wirken sich Änderungen an einem auf das andere aus:

subSlice[0] = 25
fmt.Println(numbers) // [10 25 30 40 50]
fmt.Println(subSlice) // [25 30 40]

Um unbeabsichtigte Änderungen zu vermeiden, können Sie mithilfe von Kopieren eine unabhängige Version des Slice erstellen:

// Using a literal
numbers := []int{1, 2, 3, 4, 5}

// Using the make function
sliceOfStrings := make([]string, 5) // a slice of 5 strings, each 

Kapazität mit append ändern?

Wenn Sie ein Slice benötigen, das größer als seine aktuelle Kapazität ist, erstellt „Append“ automatisch ein neues, größeres Array im Hintergrund und kopiert alles. Das ist unglaublich effizient und trägt maßgeblich dazu bei, dass Slices großartig sind. Wenn „Append“ ein neues Array erstellt, wird die doppelte Kapazität der vorherigen zugewiesen – so haben Sie Raum zum Wachsen!

Slicing und Speichereffizienz?

Hier ist ein kleines Go-Geheimnis: Das Slicing ist zwar sehr leistungsstark, kann aber manchmal zu Speicherverlusten führen, wenn Sie nicht aufpassen. Da Slices auf dasselbe zugrunde liegende Array verweisen, bleibt das Array möglicherweise im Speicher, auch wenn Sie nur einen kleinen Teil davon verwenden.

Zum Beispiel:

numbers := []int{1, 2, 3}
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // 3 (same as length here)

In solchen Fällen ist es am besten, mit Copy ein wirklich unabhängiges Slice zu erstellen, das nur die Daten enthält, die Sie benötigen, und so den Rest des Speichers freizugeben.

numbers = append(numbers, 4)
fmt.Println(len(numbers)) // 4
fmt.Println(cap(numbers)) // probably 6 now, depending on Go’s growth 

Mehrdimensionale Scheiben ??

Benötigen Sie mehr als eine Dimension? Sie können auch mehrdimensionale Slices erstellen! Dies kann für Dinge wie Raster oder Tabellen praktisch sein. Deklarieren Sie einfach ein Stück Scheiben:

numbers := []int{1, 2, 3}
numbers = append(numbers, 4, 5, 6) // Adding multiple elements at once
fmt.Println(numbers) // [1 2 3 4 5 6]

Jede „Reihe“ ist ein Stück für sich, sodass Sie sie bei Bedarf unabhängig voneinander anbauen können.

numbers := []int{10, 20, 30, 40, 50}
subSlice := numbers[1:4] // Just takes a "slice" of the original slice
fmt.Println(subSlice) // [20 30 40]

Die Nilscheibe?

Ein Null-Slice ist einfach ein Slice, das noch nicht initialisiert wurde. Es hat keine Länge und Kapazität, kann aber trotzdem mit Funktionen wie Anhängen verwendet werden, ohne in Panik zu geraten.

subSlice[0] = 25
fmt.Println(numbers) // [10 25 30 40 50]
fmt.Println(subSlice) // [25 30 40]

Wenn Sie an ein Null-Slice anhängen, initialisiert Go es einfach automatisch für Sie. Es ist ein toller Trick, den man im Ärmel hat.

Fallstricke und Best Practices ?
Achten Sie auf gemeinsam genutzten Speicher: Denken Sie daran, dass Slices den Speicher mit dem ursprünglichen Array teilen. Dies ist großartig für die Leistung, aber seien Sie vorsichtig, wenn Sie Teile eines großen Arrays aufteilen, um zu vermeiden, dass nicht benötigte Daten im Speicher verbleiben.

Vorsicht bei der Größenänderung: Beim Anhängen muss Go möglicherweise ein neues zugrunde liegendes Array erstellen, wenn die aktuelle Kapazität voll ist. Dies kann effizienter sein als viele kleine Größenänderungen, aber seien Sie sich des Mehraufwands bewusst, wenn Sie mit großen Datensätzen arbeiten.

Vermeiden Sie vorzeitige Optimierung: Go übernimmt einen Großteil der Speicherzuweisung und Größenänderung automatisch mit Slices. Oft führt der Versuch, diese Details bis ins kleinste Detail zu verwalten, dazu, dass Ihr Code unübersichtlicher und weniger effizient wird. Vertrauen Sie darauf, dass die Slice-Mechanik von Go in den meisten Fällen das Richtige tut.

Das obige ist der detaillierte Inhalt vonSlices: Das Rückgrat von Go!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!