====== Tableaux ======

<Code:go>
var a[5]int
</Code>

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

Comme en [[nsi:langages:c:tableaux|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 :

<Code:go>
var a[n]int
</Code>

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 :

<Code:go>
package main
import "fmt"

const N int = 10

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

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

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

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

<Code:go>
len(b)
</Code>

===== Tableau à 2 dimensions =====

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

<Code:go>
var tab_2D [4][5]int
tab_2D[2][1] = 17
</Code>

Tableau à 4 lignes et 5 colonnes.

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

====== Slices ======

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

== initialisation ==

<Code:go>
s := make([]int, 3)
s[0] = 5
s[1] = 7
s[2] = 13
</Code>

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.

== ajout en fin de slice ==

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

<Code:go>
s = append(s, 14)
</Code>

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

<Code:python|code python>
s.append(14)
</Code>

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

<Code:go|code Go>
s = append(s, 14)
</Code>

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

<Code:go>
nouveau_slice = append(ancien_slice, 14)
</Code>

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

<Code:go>
append(s, 14, 18, 96)
</Code>

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.

== copie ==

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

<Code:go>
c := make([]int, len(s))
copy(c, s)
</Code>

== tranches ==

Les slices permettent un découpage comme en Python :

<Code:go>
t := s[2:4]
</Code>

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