Mehrdimensionale Arrays in Golang

Einführung

Im vorherigen Abschnitt haben wir die Grundlagen zur Verwendung von Arrays gelernt.

Welche Arten von Elementen können in einem Array enthalten sein?

In Go können die Elemente in einem Array von jedem primitiven Datentyp sein, wie z.B. Ganzzahlen, Strings oder benutzerdefinierten Typen.

Was passiert, wenn die Elemente in einem Array Arrays sind?

Dann haben wir ein mehrdimensionales Array:

Wie in der obigen Abbildung gezeigt, ist die lila Box unser ursprüngliches Array.

Jedes Element in dem Array der lila Box ist ein neues Array (die rote Box).

Wichtige Konzepte:

• Definition eines zweidimensionalen Arrays
• Initialisierung eines zweidimensionalen Arrays
• Traversierung eines zweidimensionalen Arrays
• Verwendung von mehrdimensionalen Arrays

Definition eines zweidimensionalen Arrays

Allgemeine Definition

Erinnern Sie sich, wie wir ein normales Array definieren?

var variableName [elementCount]variableType

Wie definieren wir also ein zweidimensionales Array mit dieser naivsten Methode?

var variableName [elementCount][elementCount]variableType

Der einzige Unterschied ist, dass wir vor dem ursprünglichen [elementCount] ein weiteres [elementCount] hinzufügen, um das Format [elementCount][elementCount] zu bilden.

Beispielsweise, wenn wir ein zweidimensionales Array namens a mit einer Kapazität von 10*10 vom Typ int definieren möchten, können wir die folgende Syntax verwenden:

var a [10][10]int

Kurze Definition

Genau wie bei der kurzen Variablendeklaration können wir eine kurze Definitionsmethode verwenden, um Arrays, sogar mehrdimensionale Arrays, zu deklarieren.

Wir können := verwenden, um ein Array, einschließlich mehrdimensionaler Arrays, zu deklarieren.

Beispielsweise:

a := [10][10]int{}

Auf diese Weise definieren wir ein ganzzahliges zweidimensionales Array der Größe 10*10.

Initialisierung eines zweidimensionalen Arrays

Ähnlich wie bei eindimensionalen Arrays können wir ein zweidimensionales Array auf folgende Weise initialisieren:

• Initialisierungsliste
• Initialisierung mit abgeleiteter Länge
• Initialisierung mit spezifiziertem Indexwert

Erinnern Sie sich, wie man diese Methoden verwendet?

Wir haben gelernt, wie man diese Methoden bei eindimensionalen Arrays verwendet, im vorherigen Abschnitt. Wenn Sie es vergessen haben, ist das in Ordnung.

Der folgende Abschnitt wird diese drei Initialisierungsmethoden wiederholen und auf zweidimensionale Arrays erweitern.

Initialisierung eines zweidimensionalen Arrays mit einer Initialisierungsliste

Lassen Sie uns weiterhin die im vorherigen Abschnitt erstellte Datei array.go verwenden. Wenn Sie Ihre Arbeit nicht gespeichert haben, können Sie die Datei wie folgt erstellen:

touch ~/project/array.go

Schreiben Sie folgenden Code in die Datei array.go:

package main

import "fmt"

func main() {
    // Automatically initialized to 0
    var simpleArray [3][3]int
    // Initialize using specified initial values, use default values for the missing elements
    var numArray = [3][3]int{{1, 2, 3}, {2, 3, 4}}
    // Initialize using specified initial values
    var cityArray = [2][2]string{{"London", "Chengdu"}, {"Paris", "Boston"}}
    fmt.Println(simpleArray) // [[0 0 0] [0 0 0] [0 0 0]]
    fmt.Println(numArray)    // [[1 2 3] [2 3 4] [0 0 0]]
    fmt.Println(cityArray)   // [[London Chengdu] [Paris Boston]]
}

Der obige Code zeigt drei Möglichkeiten, ein zweidimensionales Array mit einer Initialisierungsliste zu initialisieren.

Führen Sie den Code mit folgendem Befehl aus:

go run ~/project/array.go

Die Ausgabe ist wie folgt:

[[0 0 0] [0 0 0] [0 0 0]]
[[1 2 3] [2 3 4] [0 0 0]]
[[London Chengdu] [Paris Boston]]

Sie können die Werte ändern und die Initialisierungsmethoden für eindimensionale Arrays wiederholen.

Initialisierung eines zweidimensionalen Arrays mit abgeleiteter Länge

Bei einem zweidimensionalen Array können wir die Methode der abgeleiteten Länge verwenden, um es zu initialisieren, genau wie bei eindimensionalen Arrays.

Schreiben Sie folgenden Code in die Datei array.go:

package main

import "fmt"

func main() {
    // Automatically initialized to 0
    var simpleArray [3][3]int
    // Initialize using specified initial values, use default values for the missing elements
    var numArray = [...][]int{{1, 2, 3, 3}, {2, 3, 4, 3}, {0}}
    // Initialize using specified initial values
    var cityArray = [...][2]string{{"London", "Chengdu"}, {"Paris", "Boston"}}
    fmt.Println(simpleArray) // [[0 0 0] [0 0 0] [0 0 0]]
    fmt.Println(numArray)    // [[1 2 3 3] [2 3 4 3] [0]]
    fmt.Println(cityArray)   // [[London Chengdu] [Paris Boston]]
}

Der obige Code zeigt die Verwendung der abgeleiteten Länge zur Initialisierung eines zweidimensionalen Arrays.

go run ~/project/array.go

Die Ausgabe ist die gleiche wie bei der Methode der Initialisierungsliste.

[[0 0 0] [0 0 0] [0 0 0]]
[[1 2 3 3] [2 3 4 3] [0]]
[[London Chengdu] [Paris Boston]]

Im Gegensatz zu eindimensionalen Arrays kann das Symbol ... bei der Initialisierung eines zweidimensionalen Arrays mit abgeleiteter Länge nur in den ersten eckigen Klammern stehen.

Beispielsweise:

var numArray = [...][]int{{1, 2, 3, 3}, {2, 3, 4, 3}}

Dieser Code ist gültig, aber die folgenden beiden Variationen sind falsch:

var numArray = [][...]int{{1, 2, 3, 3}, {2, 3, 4, 3}}
var numArray = [...][...]int{{1, 2, 3, 3}, {2, 3, 4, 3}}

Darüber hinaus vergleichen wir numArray und cityArray.

Wir können sehen, dass in cityArray wir den zweiten Parameter der Größe des zweidimensionalen Arrays angeben, wie unten gezeigt:

var cityArray = [...][2]string{{"London", "Chengdu"}, {"Paris", "Boston"}}

Das bedeutet, dass wir die Größe jedes Unter-Arrays während der Initialisierung auf 2 festlegen.

Wenn während der Initialisierung nicht genug Werte angegeben werden, werden die Standardwerte des Datentyps verwendet, um die fehlenden Elemente aufzufüllen.

Wenn die Anzahl der angegebenen Werte die festgelegte Größe überschreitet, tritt ein Fehler auf.

Initialisierung eines zweidimensionalen Arrays mit spezifizierten Indexwerten

Ähnlich wie bei eindimensionalen Arrays können Sie auch bei einem zweidimensionalen Array spezifizierte Indexwerte zur Initialisierung verwenden. Der Vorgang ist ähnlich.

Schreiben Sie folgenden Code in die Datei array.go:

package main

import "fmt"

func main() {
    a := [...][]int{1: {1, 2, 3}, 3: {4, 7, 9}}
    fmt.Println(a)                  // [[] [1 2 3] [] [4 7 9]]
    fmt.Printf("Type of array a: %T\n", a) // Type of array a: [4][]int
}

go run ~/project/array.go

Die Ausgabe ist:

[[] [1 2 3] [] [4 7 9]]
Type of array a: [4][]int

Der obige Code definiert das Array a als ein zweidimensionales Array mit unbestimmter Länge. Er weist den Wert [1 2 3] dem Array am Index 1 und den Wert [4 7 9] dem Array am Index 3 zu.

Bei automatisch abgeleiteter Länge ist der Typ des Arrays a [4][]int.

Durchlaufen eines zweidimensionalen Arrays

Wie durchlaufen wir ein zweidimensionales Array?

Als wir uns mit eindimensionalen Arrays beschäftigten, haben wir zwei Methoden zum Durchlaufen von Arrays verwendet: die Verwendung des Schlüsselworts range und die Verwendung von Indexnummern.

Lassen Sie uns nun diese beiden Methoden anwenden, um ein zweidimensionales Array zu durchlaufen.

Schreiben Sie folgenden Code in die Datei array.go:

package main

import "fmt"

func main() {
    a := [...][]int{{123, 321, 222}, {404, 501, 503}, {857, 419, 857}}
    // Method 1: using the range keyword
    fmt.Println("Traversing the Two-Dimensional Array Using the range Keyword")
    for index, value := range a {
        for i, j := range value {
            fmt.Println(index, i, j)
        }
    }
    // Method 2: using index numbers
    fmt.Println("\nTraversing the Two-Dimensional Array Using Index Numbers")
    for i := 0; i < len(a); i++ {
        for j := 0; j < len(a[i]); j++ {
            fmt.Println(i, j, a[i][j])
        }
    }
}

Der obige Code zeigt zwei Möglichkeiten, ein zweidimensionales Array zu durchlaufen.

go run ~/project/array.go

Die Ausgabe ist:

Traversing the Two-Dimensional Array Using the range Keyword
0 0 123
0 1 321
0 2 222
1 0 404
1 1 501
1 2 503
2 0 857
2 1 419
2 2 857

Traversing the Two-Dimensional Array Using Index Numbers
0 0 123
0 1 321
0 2 222
1 0 404
1 1 501
1 2 503
2 0 857
2 1 419
2 2 857

Obwohl beide Methoden die gleichen Ergebnisse liefern, unterscheiden sie sich grundlegend. Diese Unterschiede werden sich insbesondere bei der praktischen Verwendung von Arrays deutlich machen.

Praktische Anwendungen von Arrays

Im vorherigen Abschnitt haben wir erwähnt, dass die beiden Methoden zum Durchlaufen von Arrays grundlegend unterschiedlich sind.

Lassen Sie uns ein kleines Beispiel verwenden, um dies zu erklären.

Schreiben Sie folgenden Code in die Datei array.go:

package main

import "fmt"

func main() {
    a := [...][]int{{123, 321, 222}, {404, 501, 503}, {857, 419, 857}}
    // Method 1: using the range keyword
    fmt.Println("Traversing the Two-Dimensional Array Using the range Keyword")
    for _, value := range a {
        for _, j := range value {
            fmt.Println(j)
        }
    }
    fmt.Println(a)
    // Method 2: using index numbers
    fmt.Println("\nTraversing the Two-Dimensional Array Using Index Numbers")
    for i := 0; i < len(a); i++ {
        for j := 0; j < len(a[i]); j++ {
            fmt.Println(a[i][j])
            a[i][j] = 0
        }
    }
    fmt.Println(a)
}

Der obige Code zeigt die Verwendung der beiden verschiedenen Methoden, um alle Werte im zweidimensionalen Array auf 0 zu setzen.

go run ~/project/array.go

Die Programmausgabe ist:

Traversing the Two-Dimensional Array Using the range Keyword
123
321
222
404
501
503
857
419
857
[[123 321 222] [404 501 503] [857 419 857]]

Traversing the Two-Dimensional Array Using Index Numbers
123
321
222
404
501
503
857
419
857
[[0 0 0] [0 0 0] [0 0 0]]

Wir stellen fest, dass beim Verwenden des Schlüsselworts range zum Durchlaufen des Arrays die Modifikation seines Werts keine Auswirkungen hat. Wenn wir jedoch Indexnummern verwenden, um das Array zu durchlaufen, ist die Modifikation seines Werts wirksam. Dies liegt daran, dass beim Verwenden des Schlüsselworts range zum Durchlaufen des Arrays die Schleifenvariable j tatsächlich eine Kopie des Arraywerts ist. Das Ändern des Werts der Kopie hat keine Auswirkungen auf das ursprüngliche Array a. Wenn wir jedoch Indexnummern verwenden, um das Array zu durchlaufen, ist die Modifikation des Werts des ursprünglichen Arrays gültig.

Erweiterung auf ein zweidimensionales Array

Manchmal müssen wir ein dreidimensionales oder sogar ein vierdimensionales Array verwenden.

Das Erweitern auf höherdimensionale Arrays unterscheidet sich nicht viel von der Erweiterung eines eindimensionalen Arrays auf ein zweidimensionales Array.

Lassen Sie uns ein einfaches Beispiel betrachten:

package main

import "fmt"

func main() {
    a := [2][2][2]int{}
    for i := 0; i < 2; i++ {
        for j := 0; j < 2; j++ {
            for k := 0; k < 2; k++ {
                a[i][j][k] = 1
            }
        }
    }
    fmt.Println(a)
}

Der obige Code zeigt, wie man ein dreidimensionales Array definiert und verwendet. Der Vorgang ist für vierdimensionale oder höherdimensionale Arrays derselbe.

go run ~/project/array.go

Die Ausgabe ist:

[[[1 1] [1 1]] [[1 1] [1 1]]]

Allerdings werden höherdimensionale Arrays nicht häufig verwendet. Daher reicht es, das Konzept zu verstehen.

Zusammenfassung

In diesem Lab haben wir Folgendes gelernt:

• Zwei Methoden zur Definition eines zweidimensionalen Arrays
• Drei Methoden zur Initialisierung eines zweidimensionalen Arrays
• Zwei Methoden zum Durchlaufen eines zweidimensionalen Arrays
• Der Unterschied zwischen den beiden Durchlaufmethoden in der praktischen Anwendung
• Eine Übersicht über die Verwendung von mehrdimensionalen Arrays