Okay, lassen Sie uns in eine der vielseitigsten und wesentlichen Funktionen von Go eintauchen - Scheiben. Wenn Sie aus einer anderen Sprache kommen, können Sie Scheiben als ähnlich wie Arrays betrachten. Und ja, sie haben einige Ähnlichkeiten, aber Scheiben bringen viel mehr Kraft, Flexibilität und GO-spezifische Magie auf den Tisch! ?

Was ist überhaupt ein Stück? ?

In Go sind Scheiben ein Typ, mit dem Sie mit Elementenlisten arbeiten können (wie ein Array), aber sie sind dynamisch, was bedeutet, dass sie nach Bedarf wachsen und schrumpfen können. Sie müssen keine feste Länge im Voraus angeben, wie Sie es mit einem Array tun würden. Sie werden von Arrays unter der Motorhaube gesichert, aber Sie erhalten so viel mehr Kontrolle. Stellen Sie sich sie als kühlere, flexiblere Geschwister von Arrays vor.

Also ist ein Stück in Go tatsächlich ein "Fenster" über einem zugrunde liegenden Array. Sie können die Größe dieses Fensters ändern, indem Sie es wachsen oder verkleinern - und es ist so glatt wie ein Stück Kuchen. ?

ein Stück erstellen?
Das Erstellen einer Scheibe 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 

initialisiert auf einen leeren String
Wenn Sie Make machen, sagen Sie, dass Sie ein Stück mit einer bestimmten Länge erstellen, aber von einem Array unterstützt werden, das es für Sie verwaltet. Sie müssen sich also keine Sorgen um die Speicherzuweisungsdetails machen. ?

Länge und Kapazität?

Zwei entscheidende Konzepte in Scheiben sind Länge und Kapazität. Die Länge ist die Anzahl der Elemente, die derzeit in der Scheibe sind, während die Kapazität die Gesamtzahl der Elemente ist, die sie halten kann, bevor sie die Größe ändern muss.

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

Wenn Sie anfangen, Elemente anzuhängen, verdoppeln Sie die Kapazität, wenn sie sich ausfüllen, sodass Sie sich keine Sorgen machen müssen, eine Decke zu schlagen.

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

Muster
Anhang zu Scheiben: Go's integrierte Magie? ✨
Das Hinzufügen von Elementen zu einer Scheibe ist so einfach wie Pie mit GO -Anhangfunktion. Sie können ein oder mehrere Elemente gleichzeitig hinzufügen, und gehen Sie alle Änderungen und Speichermaterial 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 automatische Funktionsfunktion macht Slices super griffbereit, insbesondere wenn Sie nicht wissen, wie groß Ihre Liste wird.

Ein Stück Scheiben schneiden?

schneiden in go ist tatsächlich dort, wo die Dinge wirklich Spaß machen. Sie können eine "Unterklasse" 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. Sie enden mit den Elementen an den Positionen 1, 2 und 3, aber nicht 4.

Diese Unterklasse teilt immer noch das gleiche zugrunde liegende Array mit der Originalscheibe, wodurch sich die Änderungen an das andere auswirken:

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 Kopie verwenden, um eine unabhängige Version des Slice zu erstellen:

newSlice := make([]int, len(subSlice))
copy(newSlice, subSlice)

Kapazität mit Anhang ändern?

Wenn Sie eine Slice benötigen, die größer als die aktuelle Kapazität ist, erstellt der Anhang automatisch ein neues, größeres Array im Hintergrund und kopiert alles. Dies ist unglaublich effizient und ein großer Teil dessen, was Scheiben großartig macht. Wenn der Anhang ein neues Array erstellt, verteilt es doppelt so viele Kapazitäten - und gibt Ihnen Raum zum Wachstum!

Schneiden und Gedächtniseffizienz?

Hier ist ein kleines Geheimnis: Während das Schneiden super leistungsstark ist, kann es manchmal zu Speicherlecks führen, wenn Sie nicht vorsichtig sind. Da sich die Scheiben auf das gleiche zugrunde liegende Array beziehen, bleibt das Array möglicherweise im Speicher, selbst wenn Sie nur einen kleinen Teil davon verwenden.

Zum Beispiel:

bigSlice := make([]int, 1_000_000) // A big slice with a lot of elements
smallSlice := bigSlice[:10]        // A tiny slice from it

// Now `smallSlice` only uses 10 elements, but the underlying array with
// 1,000,000 elements is still in memory! ?

In solchen Fällen ist es am besten, eine Kopie zu verwenden, um ein wirklich unabhängiges Slice zu erstellen, das nur die Daten enthält, die Sie benötigen, und den Rest des Speichers zu befreien.

miniSlice := make([]int, len(smallSlice))
copy(miniSlice, smallSlice) // Now `miniSlice` is completely separate!

Mehrdimensionale Scheiben?

Brauchen Sie mehr als eine Dimension? Sie können auch mehrdimensionale Scheiben erstellen! Dies kann für Dinge wie Gitter oder Tische praktisch sein. Deklarieren Sie einfach ein Stück Scheiben:

matrix := [][]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
}
fmt.Println(matrix) // [[1 2 3] [4 5 6] [7 8 9]]

Jede "Reihe" ist ein Stück für sich, sodass Sie sie bei Bedarf unabhängig wachsen können.

matrix[0] = append(matrix[0], 10)
fmt.Println(matrix) // [[1 2 3 10] [4 5 6] [7 8 9]]

Die Nil Slice?

Ein Null -Slice ist einfach ein Stück, das noch nicht initialisiert wurde. Es hat keine Länge und Kapazität von Null, kann aber dennoch mit Funktionen wie Anhang ohne Panik verwendet werden.

var nilSlice []int // Declared, but not initialized
fmt.Println(len(nilSlice)) // 0
fmt.Println(cap(nilSlice)) // 0

Wenn Sie sich an ein Nil -Slice anhängen, initialisieren Sie es einfach automatisch für Sie. Es ist ein ordentlicher Trick, um den Ärmel im Ärmel zu haben.

Fallstricke und Best Practices?
Achten Sie auf gemeinsame Speicher: Denken Sie daran, die Scheiben teilen Speicher mit dem Original -Array. Dies ist großartig für die Leistung, aber seien Sie vorsichtig, wenn Sie Teile eines großen Arrays schneiden, um nicht benötigte Daten im Speicher zu halten.

Vorsicht vor der Größe: Wenn Sie angehängt sind, müssen Sie möglicherweise ein neues zugrunde liegendes Array erstellen, wenn die aktuelle Kapazität voll ist. Dies kann effizienter sein als viele kleine Änderungen, aber Sie sind sich des Overheads bewusst, wenn Sie mit großen Datensätzen zu tun haben.

Vermeiden Sie vorzeitige Optimierung: GO behandelt eine Menge Speicherzuweisung und die automatische Größe mit Scheiben. Der Versuch, diese Details zu mikromanieren, kann häufig Ihren Code chasiger und weniger effizient machen. Trust Go's Slice Mechanics, um in den meisten Fällen das Richtige zu tun.