Opérations sur les tableaux en Golang

Introduction

Dans le développement logiciel moderne, nous avons souvent besoin de stocker une grande quantité de données.

D'après ce que nous avons appris, nous pouvons facilement définir de nombreuses variables.

Cependant, si nous devons utiliser des variables pour enregistrer les noms des employés d'une entreprise, avec des données à l'échelle de centaines voire de milliers, devons-nous les définir une par une?

Bien sûr que non. Pour les données ayant des attributs similaires, nous pouvons utiliser des tableaux (arrays) pour les définir et les stocker.

Nous pouvons considérer les tableaux comme une collection de variables qui se rassemblent comme un train. Et lorsque nous voulons trouver une variable spécifique, nous n'avons qu'à connaître le numéro de train (nom du tableau) et le numéro de siège (index). Ensuite, nous pouvons trouver et manipuler la variable sans connaître son nom.

Dans cette section, nous allons apprendre diverses opérations de base sur les tableaux.

Points clés de connaissance :

• Définition d'un tableau (Array definition)
• Initialisation d'un tableau (Array initialization)
• Parcours d'un tableau (Array traversal)
• Caractéristiques des éléments du tableau (Characteristics of array elements)

Skills Graph

Définition d'un tableau (Array Definition)

Comment définissons-nous un tableau?

Rappelons la situation lorsque nous avons appris les variables. Comment avons-nous défini une variable int?

var a int

C'est-à-dire :

var variable_name variable_type

De même, nous pouvons définir un tableau int comme ceci :

var a [10]int

C'est-à-dire :

var variable_name [number_of_elements]variable_type

De cette façon, nous avons défini un tableau int de base appelé a avec une capacité de 10.

Liste d'initialisation (Initialization List)

Après avoir compris comment définir un tableau, apprenons à l'initialiser.

Lors de l'initialisation d'un tableau, nous pouvons utiliser une liste d'initialisation pour définir les valeurs initiales des éléments du tableau.

Créez un fichier array.go dans le répertoire ~/project :

cd ~/project
touch array.go

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

Exécutez le code :

go run ~/project/array.go

Sortie attendue :

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

Le code ci-dessus montre trois façons de spécifier des valeurs initiales à l'aide d'une liste d'initialisation :

• Sans passer de liste : Initialisation à la valeur nulle du type d'élément
• En passant une liste partielle : Initialisation des éléments spécifiés avec les valeurs spécifiées, et initialisation des éléments restants à la valeur nulle
• En passant une liste complète : Initialisation avec les valeurs spécifiées

Notez que si la longueur de la liste passée est supérieure au nombre d'éléments du tableau, le code ne sera pas compilé.

Initialisation avec longueur inférée (Inferred Length Initialization)

Lors de l'initialisation d'un tableau à l'aide d'une liste d'initialisation, vous devez vous assurer que le nombre de valeurs initiales fournies est inférieur ou égal au nombre d'éléments.

En général, vous pouvez compter sur le compilateur pour inférer la longueur du tableau en fonction des valeurs initiales.

Modifiez le fichier array.go comme suit :

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
}

Exécutez le code :

go run ~/project/array.go

Sortie attendue :

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

Initialisation avec indices spécifiés (Initialization with Specified Indices)

Parfois, nous pouvons vouloir assigner des valeurs initiales spécifiques à certaines positions dans un tableau, que nous utilisions une liste d'initialisation ou que nous inférions la longueur.

Modifiez le fichier array.go comme suit :

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
}

Exécutez le code :

go run ~/project/array.go

Sortie attendue :

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

Le code ci-dessus spécifie les valeurs initiales des éléments d'indices 1 et 3 respectivement à 1 et 5. Il utilise également la méthode d'initialisation avec inférence de longueur, que vous devriez apprendre.

Note : En informatique, l'index commence à 0.

Parcours d'un tableau (Array Traversal)

Parfois, nous devons accéder à chaque élément d'un tableau et effectuer des opérations sur chacun d'eux.

Voici deux méthodes pour parcourir des tableaux :

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

Exécutez le code :

go run ~/project/array.go

Sortie attendue :

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

Traversing the array using indices
123
321
456
777

Les deux méthodes ci-dessus peuvent être utilisées pour parcourir l'ensemble du tableau.

Accès aux éléments d'un tableau (Accessing Array Elements)

Pour accéder à un élément spécifique dans un tableau, qui est essentiellement une variable, nous utilisons l'index.

Comme dans la plupart des langages de programmation, l'index d'un tableau commence à 0, et l'index du dernier élément est len - 1.

Si un index supérieur à cette limite est utilisé dans le code, cela entraînera une erreur de dépassement de limite (out-of-bounds error).

Pour accéder au i-ème élément du tableau a, vous pouvez utiliser la notation suivante :

a[i]

C'est-à-dire :

array_name[index_of_element]

Type valeur des tableaux (Value Type of Arrays)

Les tableaux sont des types valeur ; assigner un tableau ou passer un tableau en tant que paramètre copiera l'intégralité du tableau. En d'autres termes, vous modifierez les valeurs de la copie, pas le tableau original.

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

Exécutez le code :

go run ~/project/array.go

La sortie sera :

[10 20 30]

On peut voir à partir du code ci-dessus que lorsque le tableau a est passé à la fonction modifyArray, seule une copie de son tableau original est en fait passée.

Changer la valeur du tableau x dans la fonction n'affecte pas le tableau original a.

Résumé

Dans ce laboratoire, nous avons appris :

• Comment définir un tableau
• Trois méthodes d'initialisation de tableau
• Les caractéristiques des tableaux et comment accéder à leurs éléments

Les tableaux ne sont pas couramment utilisés dans le développement réel, mais ils constituent la base pour apprendre les structures de données couramment utilisées en Go.

J'espère que tous les Gophers (développeurs Go) pratiqueront diligemment et apprendront à appliquer ce qu'ils ont appris.