Exercice - Utiliser des tableaux
Dans le langage Go, les tableaux sont une structure de données de longueur fixe d’un type particulier. Ils peuvent contenir zéro, un ou plusieurs éléments, et vous devez définir leur taille lorsque vous les déclarez ou les initialisez. De plus, vous ne pouvez pas les redimensionner après leur création. Pour ces raisons, les tableaux ne sont pas couramment utilisés dans les programmes Go, mais ils constituent la base des coupes et des mappages.
Déclarer des tableaux
Pour déclarer un tableau en Go, vous devez définir le type de données de ses éléments, ainsi que le nombre d’éléments qu’il peut contenir. Vous pouvez ensuite accéder à chaque élément du tableau à l’aide de la notation d’indice, où le premier élément est 0 et où le dernier élément est inférieur de 1 à la longueur du tableau (longueur -1).
Par exemple, utilisons le code suivant :
package main
import "fmt"
func main() {
var a [3]int
a[1] = 10
fmt.Println(a[0])
fmt.Println(a[1])
fmt.Println(a[len(a)-1])
}
Quand vous exécutez le code précédent, vous obtenez la sortie suivante :
0
10
0
Même si vous avez déclaré un tableau, vous ne recevez pas d’erreur quand vous accédez à ses éléments. Par défaut, Go initialise chaque élément avec le type de données par défaut. Dans ce cas, la valeur par défaut de int est 0. Toutefois, vous pouvez affecter une valeur à une position spécifique, comme nous l’avons fait avec a[1] = 10. Vous pouvez accéder à cet élément en utilisant la même notation. Notez également que pour référencer le premier élément, nous avons utilisé a[0]. Pour référencer le dernier élément, nous avons utilisé a[len(a)-1]. La fonction len est une fonction intégrée du langage Go qui permet d’obtenir le nombre d’éléments d’un tableau, d’une coupe ou d’un mappage.
Initialiser des tableaux
Lorsque vous déclarez un tableau, vous pouvez également l’initialiser avec d’autres valeurs que celles par défaut. Par exemple, vous pouvez utiliser le code suivant pour afficher et tester la syntaxe :
package main
import "fmt"
func main() {
cities := [5]string{"New York", "Paris", "Berlin", "Madrid"}
fmt.Println("Cities:", cities)
}
Exécutez le code précédent pour voir la sortie suivante :
Cities: [New York Paris Berlin Madrid ]
Même si le tableau doit comporter cinq éléments, nous n’avons pas besoin d’affecter une valeur à chacun des éléments. Comme nous l’avons vu précédemment, la dernière position comprend une chaîne vide, car il s’agit de la valeur par défaut d’un type de données String.
Points de suspension dans les tableaux
Une autre façon de déclarer et d’initialiser un tableau lorsque vous ne connaissez pas le nombre de positions dont vous avez besoin, mais que vous connaissez l’ensemble des éléments de données, est d’utiliser des points de suspension (...), comme dans cet exemple :
q := [...]int{1, 2, 3}
Nous allons modifier le programme que nous avons utilisé dans la section précédente pour utiliser des points de suspension. Ce code doit se présenter comme dans cet exemple :
package main
import "fmt"
func main() {
cities := [...]string{"New York", "Paris", "Berlin", "Madrid"}
fmt.Println("Cities:", cities)
}
Exécutez le code précédent pour voir une sortie similaire à celle de l’exemple suivant :
Cities: [New York Paris Berlin Madrid]
Voyez-vous la différence ? Il n’y a pas de chaîne vide à la fin. La longueur du tableau a été déterminée par les chaînes que vous y avez placées lors de son initialisation. Vous ne réservez pas de mémoire sans savoir si vous en aurez besoin.
Une autre façon intéressante d’initialiser un tableau consiste à utiliser des points de suspension et à spécifier uniquement une valeur pour la dernière position. Par exemple, utilisons le code suivant :
package main
import "fmt"
func main() {
numbers := [...]int{99: -1}
fmt.Println("First Position:", numbers[0])
fmt.Println("Last Position:", numbers[99])
fmt.Println("Length:", len(numbers))
}
Exécutez ce code pour obtenir la sortie suivante :
First Position: 0
Last Position: -1
Length: 100
Notez que la longueur du tableau est 100, car vous avez spécifié une valeur pour la 99e position. La première position affiche la valeur par défaut (zéro).
Tableaux multidimensionnels
Go prend en charge les tableaux multidimensionnels lorsque vous devez travailler avec des structures de données complexes. Nous allons créer un programme dans lequel nous allons déclarer et initialiser un tableau à deux dimensions. Utilisez le code suivant :
package main
import "fmt"
func main() {
var twoD [3][5]int
for i := 0; i < 3; i++ {
for j := 0; j < 5; j++ {
twoD[i][j] = (i + 1) * (j + 1)
}
fmt.Println("Row", i, twoD[i])
}
fmt.Println("\nAll at once:", twoD)
}
Exécutez le programme précédent pour voir une sortie similaire à celle de l’exemple suivant :
Row 0 [1 2 3 4 5]
Row 1 [2 4 6 8 10]
Row 2 [3 6 9 12 15]
All at once: [[1 2 3 4 5] [2 4 6 8 10] [3 6 9 12 15]]
Vous avez déclaré un tableau à deux dimensions qui spécifie le nombre de positions du tableau dans la deuxième dimension, comme ceci : var twoD [3][5]int. Ce tableau est similaire à une structure de données avec des colonnes et des lignes, comme une feuille de calcul ou une matrice. À ce stade, toutes les positions ont une valeur par défaut de 0. Dans la boucle for, nous initialisons chaque position avec un modèle de valeur différent à chaque ligne. Enfin, nous affichons toutes ses valeurs sur le terminal.
Que se passe-t-il si vous souhaitez déclarer un tableau à trois dimensions ? Vous devinez la syntaxe à utiliser, n’est-ce pas ? Vous pouvez procéder comme dans l’exemple suivant :
package main
import "fmt"
func main() {
var threeD [3][5][2]int
for i := 0; i < 3; i++ {
for j := 0; j < 5; j++ {
for k := 0; k < 2; k++ {
threeD[i][j][k] = (i + 1) * (j + 1) * (k + 1)
}
}
}
fmt.Println("\nAll at once:", threeD)
}
Exécutez le code précédent pour voir une sortie similaire à celle de l’exemple suivant :
All at once: [[[1 2] [2 4] [3 6] [4 8] [5 10]] [[2 4] [4 8] [6 12] [8 16] [10 20]] [[3 6] [6 12] [9 18] [12 24] [15 30]]]
Si nous mettons en forme la sortie dans un format plus lisible, nous pouvons obtenir une sortie similaire à celle de cet exemple :
All at once:
[
[
[1 2] [2 4] [3 6] [4 8] [5 10]
]
[
[2 4] [4 8] [6 12] [8 16] [10 20]
]
[
[3 6] [6 12] [9 18] [12 24] [15 30]
]
]
Remarquez comment la structure a changé par rapport à celle du tableau à deux dimensions. Nous pourrions utiliser davantage de dimensions, mais nous allons nous arrêter là pour l’instant, car nous avons d’autres types de données à explorer.