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
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 spezifizierten 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
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]
Werttyp 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.
