Les tableaux
Les tableaux sont une collection d'éléments qui appartiennent au même type, Par exemple une collection d'entiers 3, 5, 2, 6 d'un tableau. Les tableaux en Go ne tolèrent pas le mélange des types dans le même tableau.
Declaration
Un tableau n[T]. n indique le nombre d'éléments et T représente le type de chaque élément. Le nombre d'éléments n fait aussi partie du type.
Il y'a plusieurs façons possibles pour déclarer les tableaux. Voici un exemple:
package main
import (
"fmt"
)
func main() {
var a [3]int //tableau d'entiers de longueur 3
fmt.Println(a)
}
var a[3]int déclare un tableau d'entiers de longueur 4. La valeur zéro du type de tableau est affectée automatiquement à tous les éléments du tableau . Dans ce cas, le zéro du type int est 0. Si on exécute le programme ci-dessus, on va avoir comme sortie du programme [0 0 0].
L'indice d'un tableau commence de 0 et termine à length -1. On va attribuer quelques valeurs aux éléments du tableau comme suivant:
package main
import (
"fmt"
)
func main() {
var a [3]int //tableau d'entiers de longueur 3
a[0] = 23 // l'indice du tableau commence par 0
a[1] = 67
a[2] = 29
fmt.Println(a)
}
La sortie du programme est[23 67 29]
On va créer le même tableau en utilisant une déclaration plus concise:
package main
import (
"fmt"
)
func main() {
a := [3]int{23, 67, 29} //déclaration concise pour créer un tableau
fmt.Println(a)
}
Il n'est pas nécessaire d'affecter des valeurs à tous les éléments du tableau durant la déclaration concise.
package main
import (
"fmt"
)
func main() {
a := [3]int{12}
fmt.Println(a)
}
La longueur du tableau est déclarée mais uniquement une seule valeur est fournie, on affecte automatiquement zéro aux autres éléments du tableau.
On peut aussi ignorer la longueur d'un tableau dans la déclaration et remplacer la longueur par … afin que le compilateur trouve la longueur du tableau.
Exemple:
package main
import (
"fmt"
)
func main() {
a := [...]int{12, 78, 50} // ... indique au compilateur qu'il faut chercher la longueur du tableau
fmt.Println(a)
La taille du tableau fait partie du type. Par conséquent [3]int et [34] sont deux types différents. C'est la raison pour laquelle la taille d'un tableau ne peut pas être modifiée.
gpackage main
func main() {
a := [3]int{5, 78, 8}
var b [5]int
b = a // affectation impossible car [3]int et [5]int n'ont pas le même type
}
Une erreur de compilation serait lancée : main.go:6: cannot use a (type [3]int) as type [5]int in assignment.
Les tableaux sont des types de valeurs
Les tableaux en Go sont des types de valeur et non pas des types de référence. Cela veut dire que quand ils sont affectés à une nouvelle variable, une copie du tableau original est affectée à la nouvelle variable. Si des changements touchent la nouvelle variable, cela ne va pas être reflété dans le tableau original.
package main
import "fmt"
func main() {
a := [...]string{"USA", "China", "India", "Germany", "France"}
b := a // un copie de a est attribuée à b
b[0] = "Singapore"
fmt.Println("a is ", a)
fmt.Println("b is ", b)
}
La sortie du programme serait comme suivant:
a is [USA China India Germany France]
b is [Singapore China India Germany France]
Idem quand les tableaux sont passés à des fonctions comme paramètres , ils sont passés par valeur et le tableau original reste intacte.
package main
import "fmt"
func changeLocal(num [5]int) {
num[0] = 55
fmt.Println("dans la fonction ", num)
}
func main() {
num := [...]int{5, 6, 7, 8, 8}
fmt.Println("avant de passer le tableau à la fonction ", num)
changeLocal(num) //num is passed by value
fmt.Println(" après avoir passé la tableau à la fonction", num)
}
Dans le programme ci-dessus, le tableau num est passé par valeur à la fonction changeLocal, par conséquent, il ne va pas changer à cause de l'appel de la fonction. La sortie de ce programme est:
avant de passer le tableau à la fonction [5 6 7 8 8]
dans la fonction [55 6 7 8 8]
après avoir passé la tableau à la fonction [5 6 7 8 8]
La longueur d'un tableau
La longueur d'un tableau est trouvée en passant le tableau comme paramètre à la fonction len.
package main
import "fmt"
func main() {
a := [...]float64{67.7, 89.8, 21, 78}
fmt.Println("la longueur est",len(a))
}
La sortie du programme ci-dessus est longueur est 4.
Itération d'un tableau range
La boucle for peut être utilisée pour itérer sur tous les éléments d'un tableau.
package main
import "fmt"
func main() {
a := [...]float64{67.7, 89.8, 21, 78}
for i := 0; i < len(a); i++ { //bouclage de 0 à la longeur du tableau
fmt.Printf("%d ème element de a est %.2f\n", i, a[i])
}
}
le résultat du programme serait comme suivant:
0 ème element de a is 67.70
1 ème element de a is 89.80
2 ème element de a is 21.00
3 ème element de a is 78.00
On peut avoir le même résultat en utilisant range:
package main
import "fmt"
func main() {
a := [...]float64{67.7, 89.8, 21, 78}
sum := float64(0)
for i, v := range a {//range retourne l'indice et la valeur
fmt.Printf("%d ème element de a est %.2f\n", i, v)
sum += v
}
fmt.Println("\n somme de tous les éléments de a est ",sum)
}
Si vous voulez uniquement avoir la valeur du tableau sans son indice, on peut remplacer l'indice par _ comme suivant:
for _, v := range a { //ignore l'indice
}
Les tableaux multidimensionnels
On peut créer des tableaux multidimensionnels comme suivant:
package main
import (
"fmt"
)
func printarray(a [3][2]string) {
for _, v1 := range a {
for _, v2 := range v1 {
fmt.Printf("%s ", v2)
}
fmt.Printf("\n")
}
}
func main() {
a := [3][2]string{
{"jaune", "rouge"},
{"vert", "mauve"},
{"noir", "blanc"}, //la virgule est importante pour que le compilateur ne lance pas un message d'erreur
}
printarray(a)
var b [3][2]string
b[0][0] = "prada"
b[0][1] = "lacoste"
b[1][0] = "louboutin"
b[1][1] = "gucci"
b[2][0] = "dolce&gabanna"
b[2][1] = "louis vuiton"
fmt.Printf("\n")
printarray(b)
}
après l'exécution du programme, on aura comme sortie:
jaune rouge
vert mauve
noir blac
prada lacoste
louboutin gucci
dolce&gabanna louis vuiton
Posted on Utopian.io - Rewarding Open Source Contributors