Programmation en Go/Les tableaux
Tableaux.
Un tableau de valeurs est une série consécutive de valeurs, accessibles par leur indice entier, 0, 1, 2 3...taille-1.
En Go, on déclare un tableau en faisant précéder le type des éléments par la taille entre crochets, comme dans [3]int.
Par exemple, pour déclarer un tableau de 3 réels :
var tab [4]float32
ou, en déclarant une valeur "littérale" d'un tableau :
On peut accéder à un élément d'un tableau en faisant suivre le nom de la variable de l'indice dans le tableau, entre crochets :
var un =tab[0]
tab[1] = 5.1
Attention, les indices d'un tableau démarrent à zéro et pas à un.
On ne peut pas accéder à un élément dont l'indice dépasse la taille du tableau, moins un, ou dont l'indice est négatif.
On peut obtenir la taille d'un tableau en utilisant la fonction codice_1 :
var taille = len(tab)
Fonction somme.
Voici un exemple de fonction : la somme de 3 réels.
Nous allons faire la somme en utilisant un tableau au lieu de passer chaque élément du tableau en paramètre :
func Somme(a [3]float32) (somme float32) {
 for _, v := range a {
 somme += v
 return
On déclare ici une fonction nommée Somme qui prend comme paramètre un tableau de 3 réels, et retourne un réel. La valeur de retour, en Go, vient après la liste des paramètres.
for _, v := range a {
Il s'agit d'une boucle d'itération sur chaque élément du tableau "a". Le mot-clé for définit une boucle d'itération, tandis que range définit l'intervalle d'un tableau (ici, "a")
_, v := range a
Deux variables, "_" et "v", prennent comme valeur d'itération l'indice et la valeur, respectivement, de chaque élément du tableau a.
Le caractère "_" utilisé comme variable signifie que la valeur de l'indice est ignorée durant l'itération.
return
Ici, nous retournons la valeur "somme" à la fonction qui nous appelle. Ce devrait être écrit "return somme", mais comme nous avions déclaré la valeur de retour avec un nom de variable, la valeur de cette variable est automatiquement retournée. De plus, la variable est initialisée automatiquement (à zéro) ce qui fait encore une opération qui n'est pas écrite.
Les 'tranches'.
Les "slices" (tranches en français), sont des tableaux au comportement différent. Disons que les tableaux 'classiques' ont une taille fixe tandis que les tranches n'ont pas de taille précise au moment de la compilation.
Les tableaux fixes sont passés par copie lors d'un appel de fonction.
Donc, si votre tableau occupe 4 Mégaoctets, tout le contenu du tableau sera copié à chaque appel de fonction !
Ce peut être une source de lenteur dans votre programme, et il y a deux solutions à ce problème :
Les tranches sont prévues pour ce cas, de plus elles sont plus pratiques que les tableaux du fait qu'elles ont une taille modifiable.
Le type tranche est défini par le type des éléments précédé par des crochets : "[]int" est une tranche d'entiers.
Pour créer une tranche il suffit de prendre un intervalle d'indices séparés par ":" entre crochets, d'une variable tableau ou d'une autre tranche :
var tranche []int = tab[0:3]
var autre []int = tab[:] // tab est pris en entier dans la tranche autre
Il est aussi possible de déclarer une tranche "littérale" :
La longueur d'une tranche s'obtient par la fonction codice_2, comme pour les tableaux. La longueur du tableau sous-jacent est appelée "capacité" et s'obtient par la fonction codice_3.
Si l'on ne précise pas le début d'une tranche, c'est le premier élément du tableau comme dans codice_4, si on ne précise pas la fin comme dans codice_5, c'est le dernier élément du tableau.
Fonction Somme sur une tranche.
Réécrivons à présent notre fonction Somme avec les tranches :
func Somme (a []int) (somme int) {
 for _,v := range a {
 somme += v
 return
Comme on peut le voir, la différence de syntaxe est minime, mais la différence sémantique est réelle.
La fonction append().
Cette fonction retourne la tranche formée en ajoutant après le dernier élément de la tranche argument, les autres arguments passés à la fonction.
x = append(x, 4, 5, 6)
fmt.Println(x)
Ce code affiche :
 [1 2 3 4 5 6]
Allocation.
On peut allouer de la mémoire pour une tranche en utilisant la fonction codice_6 :
var tranche = make([]int,10,100)

Programmation en Go/Initialisation
Constantes.
On peut initialiser une constante avec le mot-clé codice_1 :
const Pi := 3.14159
Variables globales.
Une variable globale est déclarée par le mot-clé var, avec au minimum un premier caractère en majuscule(exemple:bb est local alors que Bb est globale). Elle est initialisée par le symbole "=" ou ":=".
On peut affecter le résultat d'une fonction à une variable globale, comme ceci:
var (
 HOME = os.Getenv("HOME")
 USER = os.Getenv("USER")
 GOROOT = os.Getenv("GOROOT")
Variables locales.
On déclare une variable local avec "var" suivi du nom de la variable puis de son type :
var x float
On peut initialiser une variable avec le signe égal :
x = 2.17
Ou bien combiner les deux:
var x float = 2.17
On peut "inférer" le type tout en affectant la variable :
var x := 2.17 // automatiquement float
Enfin, on peut omettre "var"
y := 3.1415
La fonction init.
La fonction init() est une fonction spéciale. Chaque fonction portant ce nom dans chaque module sera appelée à l'initialisation du programme (une seule fois) et ce, dans l'ordre d'import des modules. Un seul thread est utilisé lors de cette phase d'initialisation pour l’exécution des goroutines. (qui feront l'objet d'un autre chapitre)

Programmation en Go/Pointeurs et structures

Pointeurs.
Les pointeurs sont un type important en Go. Nous les avons à peine évoqués dans un autre chapitre. Un pointeur est un peu comme l'adresse pointant sur une valeur, on peut retrouver cette valeur et la modifier à l'aide d'un pointeur.
Un pointeur est déclaré en faisant précéder le type de donnée pointée par une étoile (*int est un pointeur sur un entier).
On prend l'adresse pointant sur une donnée en la faisant précéder de &:
var i = 5
var j *int = &i // pointeur sur i
Ensuite on peut récupérer la valeur sur laquelle on pointe en précédant le pointeur par une étoile:
var k = *j // k vaut 5
On peut modifier la valeur pointée avec *p=v:
Mais, maintenant, i vaut également 6, car j correspond à l'adresse de i!
On peut également utiliser += pour ajouter une valeur:
k=*j // k vaut également 16 maintenant
Le pointeur 'nil'.
Le mot-clé nil représente un pointeur qui ne pointe sur aucune valeur licite. Cela peut représenter la valeur initiale d'un pointeur qui ne pointe vers 'rien'.
Les types structurés.
On peut déclarer un "alias" vers un type en Go en utilisant le mot-clé type suivi du type défini, par exemple:
type Vecteur3D [3]float32
var vec Vecteur3D
On peut déclarer un type structuré ou structure, en utilisant le mot-clé struct:
type Intervalle struct {
 debut int
 fin int
On peut déclarer une valeur littérale de structure comme ceci:
Mais en général on utilise un pointeur sur une structure, pour ne pas la passer par valeur mais par référence:
inter := new(Intervalle)
On accède ensuite à chaque champ d'une structure ou de son pointeur en faisant suivre la valeur d'un point suivi du nom du champ:
inter.fin += inter.debut

Programmation en Go/Les tableaux associatifs