Aide-mémoire Golang

Comment utiliser les collections

Comment utiliser les slices


// Caractéristiques : mutable, passage par référence, allocation sur le tas
a := []int{1,2,3,4,5} // raccourci et initialisation
// On peut aussi spécifier un index comme placeholder
a := []int{0:1,4:3}
// Ajouter
a = append(a, 6)
// Supprimer
// Index de l'élément à supprimer
index := 2
// Supprimer l'élément
slice = append(slice[:index], slice[index+1:]...)  // C'est aussi une fusion de tableaux
// Modification et lecture identiques à un tableau

Longueur et capacité des slices


// Length (longueur) : nombre d'éléments actuellement contenus dans la slice.
// Capacity (capacité) : taille du tableau sous-jacent, c.-à-d. le nombre d'éléments que la slice peut accueillir, la limite supérieure.
a := make([]byte, 5, 10) // La slice a peut accueillir jusqu'à 10 éléments byte, mais n'en a actuellement que 5.
// On peut omettre la capacité
a := make([]byte, 5)
 
// Explication de la syntaxe a[b:c] => 
// b représente l'index courant, s'il est vide l'index est 0
// c représente l'index courant, s'il est vide l'index est len(a)
s := x[:] // la slice s pointe vers l'espace mémoire du tableau x ; changer s affecte aussi x

Comment itérer sur les slices


for k,v := range a {} 
for _,v := range a {} // l'index n'est pas nécessaire
for k := range a {} // seul l'index est nécessaire
for range time.Tick(time.Second) {} // ni l'un ni l'autre

Comment utiliser les tableaux


// Caractéristiques : taille fixe, passage par valeur, allocation sur la pile
a := [5]int{1,2,3,4,5}
// Impossible d'ajouter ou de supprimer
// Modifier
a[3] = 6
// Lire
a[3]

Comment utiliser switch


switch a {
case "a":
	// todo
case "b", "c":  // correspond à b ou c
	// todo
default:
	// todo
}
 
// On peut aussi préfixer une instruction
switch a:=1; a { ... }

Comment utiliser les boucles for


for {}  // équivalent à while true
for a < 19 {} // équivalent à while a < 19
for a := 10; a<99; a++ {} // usage normal
 
// Prend aussi en charge break et continue avec des labels externes
here:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if i == 0 {
                continue here
            }
            fmt.Println(j)
            if j == 2 {
                break
            }
        }
    }
 
there:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if j == 1 {
                continue
            }
            fmt.Println(j)
            if j == 2 {
                break there
            }
        }
    }

Comment utiliser la structure if


if a > 0 {}
 
// On peut ajouter une instruction supplémentaire et terminer par un point-virgule
if a := b+c; a > 0 {}

À propos des packages et des contraintes par défaut

Placez une déclaration package tout au début de chaque fichier source Go (hors commentaires). Les fichiers exécutables sont dans le package main. Convention : nom du package == dernier segment du chemin d’import (chemin math/rand => nom rand). Identifiants commençant par une majuscule : identifiants exportés, visibles des autres packages. Identifiants commençant par une minuscule : identifiants privés, invisibles des autres packages.

Comment déclarer des fonctions


func a() {}
func a(b int){}
func a(b, c int){} // plusieurs du même type
func a() string {}
// Valeur de retour
func a() (int,string){
  return 1, "1"
}
// Identifiant de retour, un simple return suffit
func a() (b int, c string){
	b = 1
	c = "1"
	return
}

Passage de fonctions et closures


// Utilisé comme paramètre
add := func(a,b)int{
	return a+b
}
 
// Utilisé comme valeur de retour
func wrapAdd() (add func() int) {
	c := 1
	add = func() int { return c }
	return
}

Fonctions variadiques


func a(args ...int) int {
	return 1
}

Comment déclarer des variables


var a int = 1
a := 1
const a = "1"

Astuces iota

Valeurs d’énumération auto-incrémentées


const (
	Red   = iota // 0
	Green        // 1
	Blue         // 2
)

Utiliser les opérations bit à bit pour des constantes de drapeau


const (
	FlagNone = 0      // 0
	FlagA    = 1 << iota // 1
	FlagB    = 1 << iota // 2
	FlagC    = 1 << iota // 4
)

Ignorer les valeurs inutiles


const (
	_  = iota             // ignorer la première valeur d'énumération
	January = 1 + iota    // 1
	February              // 2
	March                 // 3
)

Façons d’importer d’autres fichiers

Import par chemin relatif : utilisez des chemins relatifs pour importer d’autres fichiers. Convient pour référencer d’autres fichiers du même projet. Par exemple, import "./utils" importe le fichier utils du projet courant.
Import par chemin absolu : utilisez des chemins absolus pour importer d’autres fichiers. Convient pour des fichiers situés dans d’autres projets ou bibliothèques. Par exemple, import "github.com/example/package" importe les fichiers du package github.com/example/package.
Import de la bibliothèque standard : le langage Go fournit de nombreuses bibliothèques standard utilisables directement. Par exemple, import "fmt" importe le package fmt de la bibliothèque standard.
Import avec alias : vous pouvez définir des alias pour les packages ou fichiers importés afin d’utiliser des noms plus concis. Par exemple, import utils "github.com/example/package" définit l’alias utils pour github.com/example/package, puis vous accédez au contenu via utils.
Import avec identifiant blanc : parfois vous voulez seulement exécuter la fonction init d’un fichier sans utiliser le reste. Dans ce cas, importez avec l’identifiant blanc _. Par exemple, import _ "github.com/example/package" exécute init du package github.com/example/package sans utiliser le reste dans le code.
L’import avec l’opérateur point peut rendre le code plus concis, mais aussi en réduire la lisibilité.

Commandes CLI courantes

go build : compile le code Go et génère des exécutables. Par exemple, go build main.go compile main.go et produit un exécutable.
go run : compile et exécute le code Go. Par exemple, go run main.go compile et exécute directement main.go.
go test : exécute les tests unitaires Go. Avec go test, vous lancez automatiquement les fichiers de test du projet et affichez les résultats.
go get : récupère et installe des packages de dépendances tiers. Par exemple, go get github.com/example/package récupère et installe la dépendance github.com/example/package.
go mod init : initialise la gestion de modules du projet Go. En exécutant go mod init, vous créez un nouveau fichier go.mod pour gérer les dépendances.
go mod tidy : nettoie automatiquement les dépendances inutilisées. go mod tidy vérifie les dépendances du projet et retire celles qui ne sont plus nécessaires.
go mod vendor : copie les dépendances du projet dans le répertoire vendor. Avec go mod vendor, vous copiez toutes les dépendances dans le projet pour une compilation et un déploiement hors ligne.
go doc : affiche la documentation du code Go. Par exemple, go doc fmt.Println affiche la documentation de la fonction Println du package fmt.