Déclaration.
Le type tableau associatif représente un tableau dont on accède aux éléments par un indice. À la différence d'un tableau itératif, l'indice peut être autre chose qu'un entier, et les éléments peuvent être non-consécutifs.
 var Constantes = map[string] float {
 "Pi": 3.14159,
 "e": 2.71,
 "g": 9.81,
On accède ainsi à Pi en écrivant:
 var Pi := Constantes["Pi"]
Types supportés pour les indices.
On peut définir un indice comme étant un type numérique, une chaîne de caractères, un type pointeur ou une interface.
Les structures, tableaux et tranches ne peuvent être utilisés comme indices d'un tableau associatif.
Vérifier l'existence d'une entrée.
On peut vérifier l'existence d'une entrée en utilisant la syntaxe suivante:
 valeur, ok := Constantes["g"]
Dans ce cas, "ok" est de type booléen.
Supprimer une entrée.
 Constantes["kB"] = 0, false
permet de supprimer "kB" des entrées du tableau, même si cette entrée n'existe pas.

Programmation en Go/Formatage de texte
Formatage de types de base.
Nous allons utiliser le module "fmt" comme expliqué au chapitre Premier exemple.
fmt.Printf().
Cette fonction très simple prend un nombre variable d'arguments: le premier est une chaîne [de format] et les suivants sont les arguments à formater.
Dans la chaîne de format, le caractère "%" a une signification spéciale:
Enfin, la chaîne "%%" est remplacée par un seul "%" à la sortie.
La fonction fmt.Sprintf a le même type d'entrée mais retourne la chaîne formatée au lieu de l'afficher.
 fmt.Printf("Hello %d, %x\n", 123, 237)
 => Hello 123, ed
Exemple.
 type T struct {
 a int
 b float
 c string
 fmt.Printf("%v\n", t)
 fmt.Printf("%+v\n", t)
 fmt.Printf("%#v\n", t)
 fmt.Printf("%#v\n", Constantes)
affiche:
fmt.Println().
Cette fonction formate de manière automatique tout type passé comme paramètre. La contrepartie fmt.Sprintln() retourne la chaîne formatée au lieu de l'afficher. Cela revient au même que d'utiliser le formatage par défaut "%v".
String().
On peut définir la méthode "String()" pour un type quelconque et alors, Go l'utilisera pour formater la structure dans le formatage par défaut ("%v").

Programmation en Go/La boucle for
La forme 'tant que'.
 for {
 for condition {
Dans ces deux formes, la boucle se répète tant que la condition est évaluée vraie, ou de manière inconditionnelle.
Dans les deux cas, cela peut mener à une boucle infinie qui prend de plus en plus de ressources système.
En revanche, il est possible de couper l'exécution d'une boucle:
break.
Cette commande interrompt la boucle et en sort.
continue.
Cette commande interrompt la boucle et réitère. Si l'on parcourt un tableau, on réitère sur un nouvel élément, sinon on réévalue la condition de boucle.
return.
Return fait sortir de la fonction en cours; si une valeur est fournie à return, celle-ci est retournée à l'appelant.
Itérer sur les éléments d'un tableau.
 for index, value := range tableau {
Cette forme a déjà été étudiée dans le chapitre Les tableaux. Elle permet également d'itérer sur les éléments d'une chaîne de caractères Unicode (voir le chapitre Unicode et Go) et sur ceux d'un tableau associatif.
Itération plus générale.
Par exemple la ligne suivante compte de 0 à 9:

Droit des sociétés/Arrêt Guitou
L'Arrêt Guitou est un arrêt majeur en droit des sociétés rendu par le Conseil d'Etat le 30 juin 1934. Il consacre la loi Waldeck-Rousseau de 1901 portant sur les associations à but non lucratif. 
En l'espèce, le sieur Guitou avait formé une association ayant pour objet la commercialisation de poupées de bois. Le Conseil d'Etat dans son attendu principal signale sans équivoque qu'une association se doit d'être à but non lucratif sous peine de nullité. Or, la commercialisation de poupées dans l'objet de les revendre sur les marchés publics est contraire à la notion même d'association. Ainsi le CE rejette le pourvoi formé par le sieur Guitou et remet les parties en l'espèce devant le tribunal administratif de Paris. 
Cet arrêt rejoint en ce sens, l'arrêt Blanco du 8 février 1873 sur la notion de service public plus tard confirmé par l'arrêt Terrier de 1903.
Cet arrêt consacre l'idée selon laquelle une association à but non lucratif poursuit nécessairement un but d'intérêt général. Ce principe s'illustre notamment dans l'arrêt du Conseil d'Etat, Association Flute enchantée contre commune de Craponne, 12 mai 1993, publié au recueil Lebon. ( En l'espèce, une association à but non lucratif occupant un local de l'école de musique de Craponne, dépendance du domaine public, a été reconnu par le CE, comme poursuivant une mission d'intérêt général quand bien même elle assurait la promotion de la culture en général et non la musique en particulier. Le CE consacre ainsi la conformité de l'occupation du domaine public.)

Programmation en Go/If et switch
Alternatives: if/else.
La forme if/else permet de tester une condition, d'exécuter un bloc d'instructions si cette condition est vraie (le booléen 'true'), et un autre bloc si la condition est fausse.
 if condition {
 condition vraie
 } else {
 condition fausse
Par exemple, pour calculer une valeur absolue:
 func Abs (x int) int {
 if x < 0 {
 return -x
 return x
Switch.
 switch {
 case condition: instructions
 case condition: instructions
 default: instructions
On peut ainsi réaliser plusieurs alternatives.
On peut également réaliser un "switch" sur une valeur donnée:
 signe:="Bélier"
 switch signe {
 case "Bélier","Gémeaux": return "Vous allez être riche"
 case "Taureau","Sagittaire": return "Vous allez épouser une belle personne"
 default: return "Je ne sais pas trop"
Détecter un type.
Une variable de type interface {} peut contenir une valeur de type quelconque.
Il est possible de tester que le type de cette valeur est T en exécutant:
 v, ok = valeur.(T)
Il est aussi possible de le faire avec switch:
 switch t := valeur.(type) {
 default:
 fmt.Printf("type inattendu %T", t)
 case bool:
 fmt.Printf("booléen %T\n", t)
 case int:
 fmt.Printf("entier %T\n", t)
 case *bool:
 fmt.Printf("pointeur vers booléen %T\n", *t)
 case *int:
 fmt.Printf("pointeur vers entier %T\n", *t)
Alternative avec initialisation.
 if initialisation; condition {
 switch initialisation; condition {
Exemple:
 if err := file.Chmod("0664"); err {
 //erreur dans chmod

Programmation en Go/Fonctions
Nombre variable de paramètres.
Le dernier paramètre d'une fonction peut être suivi de ...type qui définit un nombre variable de paramètres.
 func Min(a ...int) int {
 if len(a)==0 {
 return 0
 min := a[0]
 for _, v := range a {
 if v < min {
 min = v
 return min
Ensuite, on peut appeler cette fonction de la manière suivante:
 x := Min(1, 3, 2, 0) // zéro
On peut également passer un tableau à la place des arguments avec la syntaxe t...:
 x := Min(tab...)
Valeur de retour nommée.
On peut omettre le nom de la variable de retour grâce à ce nom:
 func Somme(a []int) (somme int) {
 for _,v := range a {
 somme += v
 return
Valeurs de retour multiples.
On peut retourner deux valeurs ou plus avec la syntaxe suivante:
 func SommeEtMoyenne (a []float) (float,float) {
 somme := 0.0
 for _, x := range a {
 somme += x
 return somme,somme/len(a)
 somme, moyenne := SommeEtMoyenne(a)
Defer.
 defer fonction(...)
Entraîne l'exécution différée d'une commande à la sortie de la fonction courante. Par exemple, juste après avoir ouvert un fichier, on peut différer sa fermeture par:
 defer fichier.Close()
ce qui fait que le fichier sera fermé quoi qu'il arrive avant de quitter la fonction.
Les commandes enregistrées par 'defer' sont exécutées dans l'ordre inverse de leur déclaration: la dernière déclarée sera la première exécutée.
Fonctions anonymes.
Les fonctions anonymes sont un des types de base de Go. On peut donc stocker une fonction dans un tableau et dans n'importe quelle variable dont le type est défini comme étant:
 func (arguments, ...) retour
On déclare une fonction littérale par la syntaxe suivante :