var a[5]int

[5] annonce que a n'est pas un entier mais un tableau de 5 entiers.

Comme en C, la taille du tableau doit être connue lors de la compilation (c'est à dire avant même l'exécution)

On ne peut pas, par exemple, faire ceci :

var a[n]int

où n serait un entier qui pourrait être définit dans le programme. On peut le faire uniquement si n est déclaré comme const. Par exemple, ceci est possible :

package main
import "fmt"

const N int = 10

func main(){
   var p [N]int
   p[2] = 3
   fmt.Println("tableau p : ", p)
}

Donc, comme en C, quand on a besoin d'un tableau dont la taille est a priori inconnue, on définit dans le programme un tableau assez grand, en estimant une taille que l'on pense suffisante pour tous les cas.

Pour initialiser un tableau

b := [6]int{10, 32, 27, 14, 61, 4}
fmt.Println("tout le tableau : ", b)
fmt.Println("l'item de rang 2 : ", b[2])

L'utilisation de {} dans ce cas est courante : C, Java…

La syntaxe pour accéder à un élément est habituelle.

La fonction len renvoie la longueur d'un tableau

len(b)

Comme en C, on pourra créer des tableaux à 2 dimensions (ou plus) de la façon suivante

var tab_2D [4][5]int
tab_2D[2][1] = 17

Tableau à 4 lignes et 5 colonnes.

L'élément en ligne 2 et colonne 1 est initialisé à 17.

Les Slices sont des sortes de tableaux dynamiques, c'est à dire à taille variable, comme les tableaux Python.

s := make([]int, 3)
s[0] = 5
s[1] = 7
s[2] = 13

permet d'initialiser un slice s de 3 entiers.

On accède aux éléments de s de la même façon que pour un tableau.

Mais contrairement au tableau, on peut ajouter des éléments au slice

s = append(s, 14)

Notez la différence avec Python : En Python, l'équivalent de slice est obtenu par le type list qui est une classe. Cette classe possède la méthode append. On utilise alors la notation objet.methode

s.append(14)

En Go, le slice n'est pas un objet. La fonction append est une fonction ordinaire, pas une méthode de classe d'où l'écriture

s = append(s, 14)

Important : On pourrait distinguer les deux s apparaissant dans le code précédent

nouveau_slice = append(ancien_slice, 14)

L'ancien slice n'est pas modifié par append. La fonction append crée une copie de l'ancien slice en lui ajoutant l'élément 14. C'est une approche fonctionnelle.

Remarque : la fonction append est variadique, ce qui veut dire que l'on peut lui fournir un nombre d'arguments variable

append(s, 14, 18, 96)

Crée une copie de s avec 3 items ajoutés au bout.

Donc, pour résumer, les slices sont des tableaux auxquels on peut ajouter des éléments. On peut notamment utiliser len(s) pour la longueur d'un slice.

On peut d'ailleurs créer une copie d'un slice dans un autre slice :

c := make([]int, len(s))
copy(c, s)

Les slices permettent un découpage comme en Python :

t := s[2:4]

qui crée un slice t qui contiendra t[2], t[3] mais pas t[4].