Array-Operationen in Golang

Einführung

In der modernen Softwareentwicklung müssen wir oft eine große Menge an Daten speichern.

Basierend auf unseren bisherigen Kenntnissen können wir leicht zahlreiche Variablen definieren.

Wenn wir jedoch Variablen verwenden müssen, um die Namen der Mitarbeiter in einem Unternehmen zu erfassen, und die Daten im Bereich von Hunderten oder Tausenden liegen, müssen wir sie dann einzeln definieren?

Natürlich nicht. Für Daten mit ähnlichen Attributen können wir Arrays (Felder) verwenden, um sie zu definieren und zu speichern.

Wir können uns Arrays als eine Sammlung von Variablen vorstellen, die wie ein Zug zusammenkommen. Und wenn wir eine bestimmte Variable finden möchten, müssen wir nur die Zugnummer (Array-Name) und die Sitznummer (Index) kennen. Dann können wir die Variable finden und manipulieren, ohne ihren Namen zu kennen.

In diesem Abschnitt werden wir verschiedene Grundoperationen von Arrays kennenlernen.

Wissenspunkte:

• Array-Definition
• Array-Initialisierung
• Array-Durchlauf (Traversal)
• Eigenschaften von Array-Elementen

Skills Graph

Array-Definition

Wie definieren wir ein Array (Feld)?

Lassen Sie uns an die Situation zurückdenken, als wir über Variablen gelernt haben. Wie haben wir eine int-Variable definiert?

var a int

Das heißt:

var variable_name variable_type

Ähnlich können wir ein int-Array wie folgt definieren:

var a [10]int

Das heißt:

var variable_name [number_of_elements]variable_type

Auf diese Weise haben wir ein einfaches int-Array namens a mit einer Kapazität von 10 definiert.

Initialisierungsliste

Nachdem wir verstanden haben, wie man ein Array (Feld) definiert, lernen wir nun, wie man ein Array initialisiert.

Beim Initialisieren eines Arrays können wir eine Initialisierungsliste verwenden, um die Anfangswerte der Array-Elemente festzulegen.

Erstellen Sie eine Datei namens array.go im Verzeichnis ~/project:

cd ~/project
touch array.go

Schreiben Sie den folgenden Code in die Datei array.go:

package main

import "fmt"

func main() {
    // Automatically initialized to the zero value of the element type
    var simpleArray [3]int
    // Initialize with specified initial values, and use the zero value to fill in the missing elements
    var numArray = [3]int{1, 2}
    // Initialize with specified initial values
    var cityArray = [2]string{"London", "Chengdu"}
    fmt.Println(simpleArray) // [0 0 0]
    fmt.Println(numArray)    // [1 2 0]
    fmt.Println(cityArray)   // [London Chengdu]
}

Führen Sie den Code aus:

go run ~/project/array.go

Erwartete Ausgabe:

[0 0 0]
[1 2 0]
[London Chengdu]

Der obige Code zeigt drei Möglichkeiten, Anfangswerte mithilfe einer Initialisierungsliste anzugeben:

• Ohne Übergabe einer Liste: Initialisierung auf den Nullwert des Elementtyps
• Übergabe einer Teilliste: Initialisierung der angegebenen Elemente mit den angegebenen Werten und Initialisierung der verbleibenden Elemente auf den Nullwert
• Übergabe einer vollständigen Liste: Initialisierung mit den angegebenen Werten

Beachten Sie, dass der Code nicht kompiliert wird, wenn die Länge der übergebenen Liste größer als die Anzahl der Elemente im Array ist.

Initialisierung mit abgeleiteter Länge

Beim Initialisieren eines Arrays (Feldes) mithilfe einer Initialisierungsliste müssen Sie sicherstellen, dass die Anzahl der bereitgestellten Anfangswerte kleiner oder gleich der Anzahl der Elemente ist.

Im Allgemeinen können Sie sich darauf verlassen, dass der Compiler die Array-Länge anhand der Anfangswerte ableitet.

Ändern Sie die Datei array.go wie folgt:

package main

import "fmt"

func main() {
    var simpleArray [3]int
    var numArray = [...]int{1, 2}
    var cityArray = [...]string{"London", "Chengdu"}
    fmt.Println(simpleArray)                      // [0 0 0]
    fmt.Println(numArray)                         // [1 2]
    fmt.Printf("The type of numArray is: %T\n", numArray)   // The type of numArray is: [2]int
    fmt.Println(cityArray)                        // [London Chengdu]
    fmt.Printf("The type of cityArray is: %T\n", cityArray) // The type of cityArray is: [2]string
}

Führen Sie den Code aus:

go run ~/project/array.go

Erwartete Ausgabe:

[0 0 0]
[1 2]
The type of numArray is: [2]int
[London Chengdu]
The type of cityArray is: [2]string

Initialisierung mit angegebenen Indizes

Manchmal möchten wir möglicherweise bestimmten Positionen in einem Array (Feld) spezifische Anfangswerte zuweisen, unabhängig davon, ob wir eine Initialisierungsliste verwenden oder die Länge ableiten.

Ändern Sie die Datei array.go wie folgt:

package main

import "fmt"

func main() {
    a := [...]int{1: 1, 3: 5}
    fmt.Println(a)                  // [0 1 0 5]
    fmt.Printf("The type of array a is: %T\n", a) // The type of array a is: [4]int
}

Führen Sie den Code aus:

go run ~/project/array.go

Erwartete Ausgabe:

[0 1 0 5]
The type of array a is: [4]int

Der obige Code gibt die Anfangswerte der Elemente mit den Indizes 1 und 3 jeweils als 1 und 5 an. Es wird auch die Methode der Initialisierung mit abgeleiteter Länge verwendet, die Sie kennenlernen sollten.

Hinweis: In der Informatik beginnt der Index bei 0.

Array-Durchlauf (Array Traversal)

Manchmal müssen wir jedes Element eines Arrays (Feldes) zugreifen und nacheinander Operationen darauf ausführen.

Hier stellen wir zwei Methoden vor, um Arrays zu durchlaufen:

Schreiben Sie den folgenden Code in die Datei array.go:

package main

import "fmt"

func main() {
    a := [...]int{123, 321, 456, 777}
    // Method 1: range
    fmt.Println("Traversing the array using range")
    for index, value := range a {
        fmt.Println(index, " ", value)
    }
    // Method 2: using indices
    fmt.Println("\nTraversing the array using indices")
    for i := 0; i < len(a); i++ {
        fmt.Println(a[i])
    }
}

Führen Sie den Code aus:

go run ~/project/array.go

Erwartete Ausgabe:

Traversing the array using range
0 123
1 321
2 456
3 777

Traversing the array using indices
123
321
456
777

Beide obigen Methoden können verwendet werden, um das gesamte Array zu durchlaufen.

Zugriff auf Array-Elemente

Um auf ein bestimmtes Element in einem Array (Feld), das im Wesentlichen eine Variable ist, zuzugreifen, verwenden wir den Index.

Ähnlich wie in den meisten Programmiersprachen beginnt der Index eines Arrays bei 0, und der Index des letzten Elements ist len-1.

Wenn im Code ein Index verwendet wird, der größer als diese Grenze ist, führt dies zu einem Out-of-Bounds-Fehler.

Um auf das i-te Element des Arrays a zuzugreifen, können Sie die folgende Notation verwenden:

a[i]

Das heißt:

array_name[index_of_element]

Wertetyp von Arrays

Arrays (Felder) sind Wertetypen; das Zuweisen eines Arrays oder das Übergeben eines Arrays als Parameter kopiert das gesamte Array. Mit anderen Worten, Sie ändern die Werte der Kopie, nicht das ursprüngliche Array.

Schreiben Sie den folgenden Code in die Datei array.go:

package main

import "fmt"

func modifyArray(x [3]int) {
    x[0] = 100
}

func main() {
    a := [3]int{10, 20, 30}
    modifyArray(a) // The variable `x` in `modifyArray` is a copy of `a`
    fmt.Println(a) // [10 20 30]
}

Führen Sie den Code aus:

go run ~/project/array.go

Die Ausgabe wird sein:

[10 20 30]

Aus dem obigen Code geht hervor, dass, wenn das Array a an die Funktion modifyArray übergeben wird, tatsächlich nur eine Kopie seines ursprünglichen Arrays übergeben wird.

Das Ändern des Werts des Arrays x in der Funktion wirkt sich nicht auf das ursprüngliche Array a aus.

Zusammenfassung

In diesem Lab (Praktikum) haben wir gelernt:

• Wie man ein Array (Feld) definiert
• Drei Methoden zur Array-Initialisierung
• Die Eigenschaften von Arrays und wie man auf deren Elemente zugreift

Arrays werden in der praktischen Entwicklung nicht häufig verwendet, aber sie sind die Grundlage für das Lernen von gängigen Datenstrukturen in Go.

Ich hoffe, dass alle Gophers fleißig üben und lernen, das Gelernte anzuwenden.