Tableaux multidimensionnels en Golang

Introduction

Dans la section précédente, nous avons appris l'utilisation de base des tableaux (arrays).

Quels types d'éléments peuvent se trouver dans un tableau?

En Go, les éléments d'un tableau peuvent être de n'importe quel type primitif, comme les entiers, les chaînes de caractères ou des types personnalisés.

Que se passe-t-il si les éléments d'un tableau sont des tableaux?

Alors nous avons un tableau multidimensionnel :

Comme le montre la figure ci-dessus, la boîte violette est notre tableau original.

Chaque élément du tableau dans la boîte violette est un nouveau tableau (la boîte rouge).

Concepts clés :

• Définition d'un tableau à deux dimensions
• Initialisation d'un tableau à deux dimensions
• Parcours d'un tableau à deux dimensions
• Utilisation des tableaux multidimensionnels

Skills Graph

Définition d'un tableau à deux dimensions

Définition générale

Vous vous souvenez de la façon dont nous définissons un tableau (array) classique?

var variableName [elementCount]variableType

Alors, comment définissons-nous un tableau à deux dimensions en utilisant cette méthode la plus naïve?

var variableName [elementCount][elementCount]variableType

La seule différence est que nous ajoutons un autre [elementCount] avant le [elementCount] original pour former le format [elementCount][elementCount].

Par exemple, si nous voulons définir un tableau à deux dimensions nommé a avec une capacité de 10*10 de type int, nous pouvons utiliser la syntaxe suivante :

var a [10][10]int

Définition courte

Tout comme la déclaration de variable courte, nous pouvons utiliser une méthode de définition courte pour déclarer des tableaux, même des tableaux multidimensionnels.

Nous pouvons utiliser := pour déclarer un tableau, y compris des tableaux multidimensionnels.

Par exemple :

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

De cette façon, nous définissons un tableau à deux dimensions d'entiers de taille 10*10.

Initialisation d'un tableau à deux dimensions

De même que pour les tableaux (arrays) unidimensionnels, nous pouvons initialiser un tableau à deux dimensions de la manière suivante :

• Liste d'initialisation
• Initialisation avec longueur inférée
• Initialisation avec valeurs d'index spécifiées

Vous vous souvenez de la façon d'utiliser ces méthodes?

Nous avons appris à utiliser ces méthodes pour les tableaux unidimensionnels dans la section précédente. Si vous avez oublié, ce n'est pas grave.

La section suivante passera en revue ces trois méthodes d'initialisation et les étendra aux tableaux à deux dimensions.

Initialisation d'un tableau à deux dimensions à l'aide d'une liste d'initialisation

Continuons à utiliser le fichier array.go créé dans la section précédente. Si vous n'avez pas enregistré votre travail, vous pouvez créer le fichier comme suit :

touch ~/project/array.go

Écrivez le code suivant dans 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]]
}

Le code ci-dessus montre trois façons d'initialiser un tableau à deux dimensions à l'aide d'une liste d'initialisation.

Exécutez le code en utilisant la commande suivante :

go run ~/project/array.go

La sortie est la suivante :

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

Vous pouvez modifier les valeurs et revoir les méthodes d'initialisation des tableaux unidimensionnels.

Initialisation d'un tableau à deux dimensions avec longueur inférée

Dans un tableau (array) à deux dimensions, nous pouvons utiliser la méthode de longueur inférée pour l'initialiser, tout comme nous l'avons fait avec les tableaux unidimensionnels.

Écrivez le code suivant dans 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]]
}

Le code ci-dessus montre l'utilisation de la longueur inférée pour initialiser un tableau à deux dimensions.

go run ~/project/array.go

La sortie est la même que pour la méthode de liste d'initialisation.

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

Cependant, contrairement aux tableaux unidimensionnels, dans l'initialisation avec longueur inférée d'un tableau à deux dimensions, le symbole ... ne peut exister que dans les premières crochets.

Par exemple :

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

Ce code est valide, mais les deux variantes suivantes sont incorrectes :

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

De plus, comparons numArray et cityArray.

Nous pouvons voir que dans cityArray, nous spécifions le deuxième paramètre de la taille du tableau à deux dimensions, comme indiqué ci-dessous :

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

Cela signifie que nous spécifions la taille de chaque sous-tableau comme étant 2 lors de l'initialisation.

Si les valeurs données ne sont pas suffisantes lors de l'initialisation, les valeurs par défaut du type de données seront utilisées pour compléter les éléments manquants.

Si le nombre de valeurs données dépasse la taille spécifiée, une erreur se produira.

Initialisation d'un tableau à deux dimensions avec des valeurs d'index spécifiées

De même que pour les tableaux (arrays) unidimensionnels, vous pouvez également utiliser des valeurs d'index spécifiées pour l'initialisation dans un tableau à deux dimensions. Le processus est similaire.

Écrivez le code suivant dans 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

La sortie est la suivante :

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

Le code ci-dessus définit le tableau a comme un tableau à deux dimensions de longueur indéterminée. Il assigne la valeur [1 2 3] au tableau à l'index 1 et la valeur [4 7 9] au tableau à l'index 3.

Dans le cas d'une longueur automatiquement inférée, le type du tableau a est [4][]int.

Parcours d'un tableau à deux dimensions

Comment parcourons-nous un tableau (array) à deux dimensions?

Lorsque nous avons appris à manipuler les tableaux unidimensionnels, nous avons utilisé deux méthodes pour parcourir les tableaux : l'utilisation du mot-clé range et l'utilisation des numéros d'index.

Maintenant, appliquons ces deux méthodes pour parcourir un tableau à deux dimensions.

Écrivez le code suivant dans 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])
        }
    }
}

Le code ci-dessus montre deux façons de parcourir un tableau à deux dimensions.

go run ~/project/array.go

La sortie est la suivante :

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

Bien que les deux méthodes produisent les mêmes résultats, elles sont fondamentalement différentes. Ces différences seront particulièrement évidentes lors de notre utilisation réelle des tableaux.

Utilisations pratiques des tableaux

Dans la section précédente, nous avons mentionné que les deux méthodes de parcours de tableau (array) sont fondamentalement différentes.

Utilisons un petit exemple pour expliquer cela.

Écrivez le code suivant dans 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)
}

Le code ci-dessus montre l'utilisation des deux méthodes différentes pour définir toutes les valeurs du tableau à deux dimensions à 0.

go run ~/project/array.go

La sortie du programme est la suivante :

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]]

Nous constatons que lorsque nous utilisons le mot-clé range pour parcourir le tableau, modifier sa valeur n'a aucun effet. Cependant, après avoir utilisé les numéros d'index pour parcourir le tableau, modifier sa valeur est efficace. Cela s'explique par le fait que lorsque nous utilisons le mot-clé range pour parcourir le tableau, la variable de boucle j est en réalité une copie de la valeur du tableau. Modifier la valeur de la copie n'affecte pas le tableau original a. En revanche, modifier la valeur du tableau original est valide lorsque nous utilisons les numéros d'index pour parcourir le tableau.

Passage à une dimension supérieure pour un tableau à deux dimensions

Parfois, nous avons besoin d'utiliser un tableau (array) à trois dimensions ou même à quatre dimensions.

L'extension à des tableaux de dimensions supérieures n'est pas très différente de l'extension d'un tableau unidimensionnel à un tableau à deux dimensions.

Prenons un exemple simple :

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)
}

Le code ci-dessus montre comment définir et utiliser un tableau à trois dimensions. Le processus est le même pour les tableaux à quatre dimensions ou de dimensions supérieures.

go run ~/project/array.go

La sortie est la suivante :

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

Cependant, les tableaux de dimensions supérieures ne sont pas couramment utilisés. Il suffit donc de comprendre le concept.

Résumé

Dans ce laboratoire (lab), nous avons appris les points suivants :

• Deux méthodes pour définir un tableau (array) à deux dimensions
• Trois méthodes pour initialiser un tableau à deux dimensions
• Deux méthodes pour parcourir un tableau à deux dimensions
• La différence entre les deux méthodes de parcours dans une utilisation réelle
• Une vue d'ensemble de l'utilisation des tableaux multidimensionnels