Golang Arrays und Slicing lernen

Arrays in der Go-Sprache

1.1 Definition und Deklaration von Arrays

Ein Array ist eine festgelegte Sequenz von Elementen des gleichen Typs. In der Go-Sprache wird die Länge eines Arrays als Teil des Array-Typs betrachtet. Das bedeutet, dass Arrays unterschiedlicher Längen als verschiedene Typen behandelt werden.

Die grundlegende Syntax zur Deklaration eines Arrays lautet:

var arr [n]T

Hier ist var das Schlüsselwort für die Variablendeklaration, arr ist der Array-Name, n stellt die Länge des Arrays dar, und T repräsentiert den Typ der Elemente im Array.

Beispielsweise zur Deklaration eines Arrays, das 5 Ganzzahlen enthält:

var myArray [5]int

In diesem Beispiel ist myArray ein Array, das 5 Ganzzahlen des Typs int enthalten kann.

1.2 Initialisierung und Verwendung von Arrays

Die Initialisierung von Arrays kann direkt bei der Deklaration oder durch das Zuweisen von Werten unter Verwendung von Indizes erfolgen. Es gibt mehrere Methoden zur Initialisierung von Arrays:

Direkte Initialisierung

var myArray = [5]int{10, 20, 30, 40, 50}

Es ist auch möglich, den Compiler die Länge des Arrays basierend auf der Anzahl der initialisierten Werte berechnen zu lassen:

var myArray = [...]int{10, 20, 30, 40, 50}

Hier zeigt ... an, dass die Länge des Arrays vom Compiler berechnet wird.

Initialisierung unter Verwendung von Indizes

var myArray [5]int
myArray[0] = 10
myArray[1] = 20
// Die restlichen Elemente werden mit 0 initialisiert, da der Nullwert von int 0 ist

Die Verwendung von Arrays ist ebenfalls einfach, und Elemente können unter Verwendung von Indizes abgerufen werden:

fmt.Println(myArray[2]) // Zugriff auf das dritte Element

1.3 Array-Traversierung

Zwei gängige Methoden zur Traversierung von Arrays sind die Verwendung der herkömmlichen for-Schleife und die Verwendung von range.

Traversierung unter Verwendung einer for-Schleife

for i := 0; i < len(myArray); i++ {
    fmt.Println(myArray[i])
}

Traversierung unter Verwendung von range

for index, value := range myArray {
    fmt.Printf("Index: %d, Wert: %d\n", index, value)
}

Der Vorteil der Verwendung von range ist, dass es zwei Werte zurückgibt: die aktuelle Indexposition und den Wert an dieser Position.

1.4 Eigenschaften und Einschränkungen von Arrays

In der Go-Sprache sind Arrays Werttypen, was bedeutet, dass beim Übergeben eines Arrays als Parameter an eine Funktion eine Kopie des Arrays übergeben wird. Daher werden in Funktionen in der Regel Slices oder Zeiger auf Arrays verwendet, wenn Änderungen am Originalarray erforderlich sind.

2 Slices in der Go-Sprache

2.1 Konzept von Slices

In der Go-Sprache ist ein Slice eine Abstraktion über ein Array. Die Größe eines Go-Arrays ist unveränderlich, was seine Verwendung in bestimmten Szenarien einschränkt. Slices in Go sind so konzipiert, dass sie flexibler sind und eine bequeme, flexible und leistungsstarke Schnittstelle für die Serialisierung von Datenstrukturen bieten. Slices selbst enthalten keine Daten; sie sind nur Verweise auf das zugrunde liegende Array. Ihre dynamische Natur wird hauptsächlich durch die folgenden Punkte charakterisiert:

Dynamische Größe: Im Gegensatz zu Arrays ist die Länge eines Slices dynamisch und kann sich bei Bedarf automatisch vergrößern oder verkleinern.
Flexibilität: Elemente können leicht mit der integrierten Funktion append zu einem Slice hinzugefügt werden.
Referenztyp: Slices greifen über Verweise auf Elemente im zugrunde liegenden Array zu, ohne Kopien der Daten zu erstellen.

2.2 Deklaration und Initialisierung von Slices

Die Syntax zur Deklaration eines Slice ähnelt der Deklaration eines Arrays, aber bei der Deklaration müssen Sie die Anzahl der Elemente nicht angeben. Beispielsweise lautet die Deklaration eines Slice von Ganzzahlen wie folgt:

var slice []int

Sie können einen Slice unter Verwendung eines Slice-Literals initialisieren:

slice := []int{1, 2, 3}

Die Variable slice oben wird als Slice initialisiert, der drei Ganzzahlen enthält.

Sie können auch einen Slice unter Verwendung der make-Funktion initialisieren, die es Ihnen ermöglicht, die Länge und die Kapazität des Slices anzugeben:

slice := make([]int, 5)  // Erstellen eines Slices von Ganzzahlen mit einer Länge und Kapazität von 5

Wenn eine größere Kapazität benötigt wird, können Sie die Kapazität als dritten Parameter an die make-Funktion übergeben:

slice := make([]int, 5, 10)  // Erstellen eines Slices von Ganzzahlen mit einer Länge von 5 und einer Kapazität von 10

2.3 Beziehung zwischen Slices und Arrays

Slices können erstellt werden, indem ein Segment eines Arrays spezifiziert wird, wodurch eine Referenz zu diesem Segment gebildet wird. Angenommen, wir haben das folgende Array:

array := [5]int{10, 20, 30, 40, 50}

Wir können einen Slice wie folgt erstellen:

slice := array[1:4]

Dieser Slice slice wird auf die Elemente im Array array von Index 1 bis Index 3 (inklusive Index 1, aber exklusive Index 4) verweisen.

Es ist wichtig zu beachten, dass der Slice die Werte des Arrays nicht wirklich kopiert; er zeigt nur auf ein kontinuierliches Segment des ursprünglichen Arrays. Daher wirken sich Modifikationen am Slice auch auf das zugrunde liegende Array aus und umgekehrt. Das Verständnis dieser Referenzbeziehung ist entscheidend für die effektive Verwendung von Slices.

2.4 Grundlegende Operationen mit Slices

2.4.1 Indexierung

Slices greifen mit Indizes auf ihre Elemente zu, ähnlich wie Arrays, wobei die Indexierung bei 0 beginnt. Zum Beispiel:

slice := []int{10, 20, 30, 40}
// Zugriff auf das erste und dritte Element
fmt.Println(slice[0], slice[2])

2.4.2 Länge und Kapazität

Slices haben zwei Eigenschaften: Länge (len) und Kapazität (cap). Die Länge ist die Anzahl der Elemente im Slice und die Kapazität ist die Anzahl der Elemente vom ersten Element des Slice bis zum Ende seines zugrunde liegenden Arrays.

slice := []int{10, 20, 30, 40}
// Ausgabe der Länge und Kapazität des Slices
fmt.Println(len(slice), cap(slice))

2.4.3 Hinzufügen von Elementen

Die Funktion append wird verwendet, um Elemente an einen Slice anzuhängen. Wenn die Kapazität des Slices nicht ausreicht, um die neuen Elemente aufzunehmen, erweitert die append-Funktion automatisch die Kapazität des Slices.

slice := []int{10, 20, 30}
// Anhängen eines einzelnen Elements
slice = append(slice, 40)
// Anhängen mehrerer Elemente
slice = append(slice, 50, 60)
fmt.Println(slice)

Es ist wichtig zu beachten, dass bei der Verwendung von append, um Elemente hinzuzufügen, möglicherweise ein neuer Slice zurückgegeben wird. Wenn die Kapazität des zugrunde liegenden Arrays nicht ausreicht, führt die append-Operation dazu, dass der Slice auf ein neues, größeres Array zeigt.

2.5 Erweiterung und Kopieren von Slices

Die Funktion copy kann verwendet werden, um die Elemente eines Slices in einen anderen Slice zu kopieren. Der Ziel-Slice muss bereits genügend Platz für die kopierten Elemente zugewiesen haben, und die Operation ändert nicht die Kapazität des Ziel-Slices.

2.5.1 Verwendung der `copy`-Funktion

Im folgenden Code wird gezeigt, wie copy verwendet wird:

src := []int{1, 2, 3}
dst := make([]int, 3)
// Kopieren der Elemente in den Ziel-Slice
kopiert := copy(dst, src)
fmt.Println(dst, kopiert)

Die copy-Funktion gibt die Anzahl der kopierten Elemente zurück und wird nicht über die Länge des Ziel-Slices oder die Länge des Quell-Slices hinausgehen, je nachdem, welche kleiner ist.

2.5.2 Überlegungen

Bei Verwendung der copy-Funktion, wenn neue Elemente zum Kopieren hinzugefügt werden, der Ziel-Slice jedoch nicht genügend Platz hat, werden nur die Elemente kopiert, die der Ziel-Slice aufnehmen kann.

2.6 Mehrdimensionale Slices

Ein mehrdimensionaler Slice ist ein Slice, der mehrere Slices enthält. Er ist ähnlich wie ein mehrdimensionales Array, aber aufgrund der variablen Länge der Slices sind mehrdimensionale Slices flexibler.

2.6.1 Erstellung von mehrdimensionalen Slices

Erstellen eines zweidimensionalen Slices (Slice von Slices):

twoD := make([][]int, 3)
for i := 0; i < 3; i++ {
    twoD[i] = make([]int, 3)
    for j := 0; j < 3; j++ {
        twoD[i][j] = i + j
    }
}
fmt.Println("Zweidimensionaler Slice: ", twoD)

2.6.2 Verwendung von mehrdimensionalen Slices

Die Verwendung eines mehrdimensionalen Slices ist ähnlich wie die Verwendung eines eindimensionalen Slices und erfolgt über den Index:

// Zugriff auf Elemente des zweidimensionalen Slices
val := twoD[1][2]
fmt.Println(val)

3 Vergleich von Anwendungen von Arrays und Slices

3.1 Vergleich der Anwendungsszenarien

Arrays und Slices in Go dienen beide dazu, Sammlungen desselben Datentyps zu speichern, weisen jedoch deutliche Unterschiede in den Anwendungsszenarien auf.

Arrays:

Die Länge eines Arrays ist bei der Deklaration festgelegt, wodurch es sich gut eignet, um eine bekannte, feste Anzahl von Elementen zu speichern.
Wenn ein Behälter mit fester Größe benötigt wird, beispielsweise zur Darstellung einer Matrix fester Größe, ist ein Array die beste Wahl.
Arrays können auf dem Stack allokiert werden, was eine höhere Leistung bietet, wenn die Arraygröße nicht groß ist.

Slices:

Ein Slice ist eine Abstraktion eines dynamischen Arrays mit variabler Länge und eignet sich zum Speichern einer unbekannten Menge oder einer Sammlung von Elementen, die sich dynamisch ändern können.
Wenn ein dynamisches Array benötigt wird, das je nach Bedarf wachsen oder schrumpfen kann, beispielsweise zum Speichern unsicherer Benutzereingaben, ist ein Slice die geeignetere Wahl.
Die Speicheranordnung eines Slices ermöglicht eine bequeme Referenzierung eines Teils oder aller Elemente eines Arrays und wird häufig zum Behandeln von Teilzeichenketten, Aufteilen von Dateiinhalten und anderen Szenarien verwendet.

Zusammenfassend sind Arrays für Szenarien mit festen Größenanforderungen geeignet und spiegeln die statischen Speicherverwaltungsmerkmale von Go wider, während Slices flexibler sind, sich als abstrakte Erweiterung von Arrays anbieten und zur bequemen Behandlung dynamischer Sammlungen dienen.

3.2 Leistungsüberlegungen

Bei der Wahl zwischen der Verwendung eines Arrays oder Slices sind Leistungsaspekte ein wichtiger Faktor.

Array:

Schneller Zugriff, da er kontinuierlichen Speicher und feste Indizierung aufweist.
Speicherzuweisung auf dem Stack (wenn die Arraygröße bekannt und nicht sehr groß ist), ohne zusätzlichen Overhead für den Heap-Speicher.
Kein zusätzlicher Speicher zum Speichern von Länge und Kapazität, was für speichersensitive Programme vorteilhaft sein kann.

Slice:

Dynamisches Wachstum oder Schrumpfung kann zu Leistungsüberkopf führen: Wachstum kann zur Allokierung neuen Speichers und Kopieren alter Elemente führen, während Schrumpfung eine Anpassung der Zeiger erfordern kann.
Slice-Operationen selbst sind schnell, aber häufige Elementhinzufügungen oder -entfernungen können zu Speicherfragmentierung führen.
Obwohl ein Slice-Zugriff einen kleinen indirekten Overhead mit sich bringt, hat dies in der Regel keinen signifikanten Einfluss auf die Leistung, es sei denn, es handelt sich um extrem leistungssensible Codes.

Daher ist bei Leistungsüberlegungen und bekannten Datenmengen die Verwendung eines Arrays geeigneter. Wenn jedoch Flexibilität und Bequemlichkeit erforderlich sind, wird die Verwendung eines Slices empfohlen, insbesondere für die Handhabung großer Datensätze.

4 Häufige Probleme und Lösungen

Im Prozess der Verwendung von Arrays und Slices in der Go-Sprache können Entwickler auf die folgenden häufigen Probleme stoßen.

Problem 1: Array außerhalb des Bereichs

Ein Array außerhalb des Bereichs bezieht sich auf den Zugriff auf einen Index, der die Länge des Arrays überschreitet. Dies führt zu einem Laufzeitfehler.
Lösung: Überprüfen Sie immer, ob der Indexwert innerhalb des gültigen Bereichs des Arrays liegt, bevor auf Arrayelemente zugegriffen wird. Dies kann erreicht werden, indem der Index mit der Länge des Arrays verglichen wird.

var arr [5]int
index := 10 // Angenommen, ein außerhalb des Bereichs liegender Index
if index < len(arr) {
    fmt.Println(arr[index])
} else {
    fmt.Println("Index liegt außerhalb des Array-Bereichs.")
}

Problem 2: Speicherlecks in Slices

Slices können unbeabsichtigt auf Teile oder das gesamte ursprüngliche Array verweisen, selbst wenn nur ein kleiner Teil benötigt wird. Dies kann zu Speicherlecks führen, wenn das ursprüngliche Array groß ist.
Lösung: Wenn ein temporärer Slice benötigt wird, sollte in Betracht gezogen werden, einen neuen Slice zu erstellen, indem der erforderliche Teil kopiert wird.

original := make([]int, 1000000)
smallSlice := make([]int, 10)
copy(smallSlice, original[:10]) // Nur den benötigten Teil kopieren
// Auf diese Weise verweist smallSlice nicht auf andere Teile von original, was dazu beiträgt, dass unnötiger Speicher vom Garbage Collector zurückgewonnen wird

Problem 3: Datenfehler durch die Wiederverwendung von Slices

Da Slices auf dieselbe zugrunde liegende Arrayreferenz zeigen, ist es möglich, die Auswirkungen von Datenänderungen in verschiedenen Slices zu sehen, was zu unvorhergesehenen Fehlern führen kann.
Lösung: Um diese Situation zu vermeiden, ist es am besten, eine neue Slice-Kopie zu erstellen.

sliceA := []int{1, 2, 3, 4, 5}
sliceB := make([]int, len(sliceA))
copy(sliceB, sliceA)
sliceB[0] = 100
fmt.Println(sliceA[0]) // Ausgabe: 1
fmt.Println(sliceB[0]) // Ausgabe: 100

Die oben genannten Punkte sind nur einige häufige Probleme und Lösungen, die bei der Verwendung von Arrays und Slices in der Go-Sprache auftreten können. In der tatsächlichen Entwicklung gibt es möglicherweise weitere Details, auf die geachtet werden muss. Das Befolgen dieser Grundprinzipien kann jedoch helfen, viele gängige Fehler zu vermeiden.