Arrays der Go-Sprache
Die Go-Sprache bietet eine Datenstruktur vom Typ Array.
Ein Array ist eine Folge nummerierter Datenelemente fester Länge desselben eindeutigen Typs, der ein beliebiger primitiver Typ wie Ganzzahlen, Zeichenketten oder benutzerdefinierte Typen sein kann.
Im Vergleich zur Deklaration vonnumber0, number1, ..., number99Variablen ist die Verwendung der Array-Formnumbers[0], numbers[1] ..., numbers[99]bequemer und einfacher zu erweitern.
Array-Elemente können über den Index (die Position) gelesen (oder geändert) werden. Der Index beginnt bei 0, das erste Element hat den Index 0, das zweite hat den Index 1, und so weiter.
Arrays deklarieren
Um ein Array in der Go-Sprache zu deklarieren, müssen der Elementtyp und die Anzahl der Elemente angegeben werden. Die Syntax lautet wie folgt:
var arrayName [size]dataTypewobei,arrayNameder Name des Arrays ist,sizedie Größe des Arrays ist,dataTypeist der Datentyp der Elemente im Array.
Das Folgende definiert ein Array balance der Länge 10 und vom Typ float32:
var balance [10]float32
Arrays initialisieren
Das Folgende demonstriert die Array-Initialisierung:
Das folgende Beispiel deklariert ein Integer-Array namens numbers mit einer Größe von 5. Zum Zeitpunkt der Deklaration wird jedes Element im Array entsprechend seinem Datentyp standardmäßig initialisiert. Bei Ganzzahltypen ist der Anfangswert 0.
var numbers [5]int
Sie können auch eine Initialisierungsliste verwenden, um die Elemente eines Arrays zu initialisieren:
var numbers = [5]int{1, 2, 3, 4, 5}
Der obige Code deklariert ein Integer-Array der Größe 5 und initialisiert seine Elemente mit 1, 2, 3, 4 bzw. 5.
Darüber hinaus können Sie auch:=die Kurzdeklarationssyntax verwenden, um ein Array zu deklarieren und zu initialisieren:
numbers := [5]int{1, 2, 3, 4, 5}
Der obige Code erstellt ein Integer-Array namens numbers, legt seine Größe auf 5 fest und initialisiert die Werte seiner Elemente.
Hinweis:In der Sprache Go ist die Größe eines Arrays Teil seines Typs, daher sind Arrays unterschiedlicher Größe nicht kompatibel. Das heißt[5]intund[10]intsind unterschiedliche Typen.
Das Folgende definiert ein Array balance der Länge 5 und vom Typ float32 und initialisiert die Elemente des Arrays:
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Wir können ein Array auch bei der Deklaration schnell mit Literalen initialisieren:
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Wenn die Array-Länge ungewiss ist, können Sie...anstelle der Länge des Arrays verwenden; der Compiler leitet die Länge des Arrays anhand der Anzahl der Elemente selbst ab:
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
oder
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Wenn die Länge des Arrays festgelegt ist, können wir Elemente auch durch Angabe von Indizes initialisieren:
// 将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}
Initialisieren eines Arrays{}Die Anzahl der Elemente in kann nicht größer sein als[]die Anzahl in.
Wenn Sie ignorieren[]Wenn in den Zahlen keine Array-Größe festgelegt ist, legt die Sprache Go die Größe des Arrays basierend auf der Anzahl der Elemente fest:
balance[4] = 50.0
Das obige Beispiel liest das fünfte Element. Array-Elemente können über den Index (die Position) angesprochen (oder geändert) werden. Indizes beginnen bei 0, wobei das erste Element bei Index 0 liegt, das zweite bei Index 1 und so weiter.
Zugriff auf Array-Elemente
Array-Elemente können über den Index (die Position) gelesen werden. Das Format ist der Array-Name gefolgt von eckigen Klammern, wobei der Indexwert innerhalb der eckigen Klammern steht. Zum Beispiel:
var salary float32 = balance[9]
Das obige Beispiel liest den Wert des 10. Elements des Arrays balance.
Das folgende Beispiel zeigt vollständige Array-Operationen (Deklaration, Zuweisung, Zugriff):
Beispiel 1
import "fmt"
func main() {
var n [10]int /* n ist ein Array der Länge 10 */
var i,j int
/* Elemente für Array n initialisieren */
for i = 0; i < 10; i++ {
n[i] = i + 100 /* das Element auf i + 100 setzen */
}
/* den Wert jedes Array-Elements ausgeben */
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] = %d\n", j, n[j] )
}
}
Das Ausführungsergebnis des obigen Beispiels ist wie folgt:
Element[0] = 100 Element[1] = 101 Element[2] = 102 Element[3] = 103 Element[4] = 104 Element[5] = 105 Element[6] = 106 Element[7] = 107 Element[8] = 108 Element[9] = 109
Beispiel 2
import "fmt"
func main() {
var i,j,k int
// Das Array deklarieren und gleichzeitig schnell initialisieren
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* Array-Elemente ausgeben */ ...
for i = 0; i < 5; i++ {
fmt.Printf("balance[%d] = %f\n", i, balance[i] )
}
balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* den Wert jedes Array-Elements ausgeben */
for j = 0; j < 5; j++ {
fmt.Printf("balance2[%d] = %f\n", j, balance2[j] )
}
// Elemente mit den Indizes 1 und 3 initialisieren
balance3 := [5]float32{1:2.0,3:7.0}
for k = 0; k < 5; k++ {
fmt.Printf("balance3[%d] = %f\n", k, balance3[k] )
}
}
Das Ausführungsergebnis des obigen Beispiels ist wie folgt:
balance[0] = 1000.000000 balance[1] = 2.000000 balance[2] = 3.400000 balance[3] = 7.000000 balance[4] = 50.000000 balance2[0] = 1000.000000 balance2[1] = 2.000000 balance2[2] = 3.400000 balance2[3] = 7.000000 balance2[4] = 50.000000 balance3[0] = 0.000000 balance3[1] = 2.000000 balance3[2] = 0.000000 balance3[3] = 7.000000 balance3[4] = 0.000000
Mehr Inhalt
Arrays sind sehr wichtig für die Go-Sprache. Im Folgenden werden wir weitere Inhalte über Arrays vorstellen:
| content | Beschreibung |
|---|---|
| Mehrdimensionale Arrays | Die Go-Sprache unterstützt mehrdimensionale Arrays. Das einfachste mehrdimensionale Array ist ein zweidimensionales Array. |
| Übergabe von Arrays an Funktionen | Sie können Array-Argumente an Funktionen übergeben |