Cheat Sheet Go

Table des matières

1. Installation de Go
2. Création d'un projet Golang
3. Installation et gestion des packages Go
4. Exécution d'un programme Go
5. Déclaration de variables et de constantes
6. Fonctions
7. Tableaux en Go
8. Slices en Go
9. Maps en Go
10. Switches en Go
11. Structs et méthodes en Go
12. Boucles en Go
13. Conditions en Go
14. Goroutine et Canaux
15. Pointeurs en Go

Installation de Go

Pour installer Go, utilisez les commandes suivantes en fonction de votre système d'exploitation :

# Sur macOS, installez Go avec la commande suivante :
brew install go
# Sur Windows, installez Go avec la commande suivante :
choco install golang
# Sur Linux, installez Go avec la commande suivante :
sudo apt-get install golang

Création d'un projet Go

Pour créer un nouveau projet Go, suivez les étapes suivantes :

1. Créez un nouveau répertoire pour votre projet. Par exemple, mkdir monprojet.
2. Naviguez dans ce répertoire avec cd monprojet.
3. Initialisez un nouveau module Go avec go mod init nomdumodule. Remplacez nomdumodule par le nom de votre module.

Installation et gestion des packages Go

Go utilise un système de gestion de packages appelé modules. Pour installer un nouveau package, vous pouvez utiliser la commande go get. Par exemple, pour installer le package fmt, vous pouvez utiliser la commande suivante :

go get github.com/pkg/errors

Cette commande télécharge le package et ses dépendances, puis les installe.

Pour mettre à jour tous les packages de votre module à leur dernière version minor ou patch, vous pouvez utiliser la commande

go get -u 

Pour mettre à jour à la dernière version majeure, vous pouvez utiliser la commande

go get -u=patch

Pour supprimer un package, vous pouvez simplement le supprimer de votre code. Lorsque vous exécutez

# Go supprimera automatiquement les références au package de votre fichier go.mod
go mod tidy

Pour voir tous les packages que vous avez installés, vous pouvez utiliser la commande

go list -m all

Pour plus d'informations sur la gestion des packages Go, consultez la documentation officielle.

Exécution d'un programme Go

# Pour compiler et exécuter un programme Go, utilisez la commande suivante :
go build main.go
./main
# Pour exécuter un programme Go directement à partir du fichier source, utilisez la commande suivante :
go run main.go

Déclaration de variables et de constantes

// Pour déclarer une variable, utilisez la syntaxe suivante :
var name string = "Jean Dupont"
// Pour déclarer une constante, utilisez la syntaxe suivante :
const age int = 30
// Pour déclarer une variable avec inférence de type, utilisez la syntaxe suivante :
name := "jeanette Dupont"
age := 25

Fonctions

// Pour définir une fonction, utilisez la syntaxe suivante :
func add(a, b int) int {
  return a + b
}
// Pour appeler une fonction, utilisez la syntaxe suivante :
fmt.Println(add(1, 2)) // 3

Tableaux en Go

// Pour déclarer un tableau à taille fixe, utilisez la syntaxe suivante :
var numbers [5]int
// Pour accéder à un élément d'un tableau, utilisez la syntaxe suivante :
numbers[0] = 1
numbers[1] = 2
// Pour déclarer un tableau à taille dynamique, utilisez la syntaxe suivante :
numbers := []int{1, 2, 3}
// Pour ajouter un élément à un tableau, utilisez la fonction append() :
numbers = append(numbers, 4)

Slices en Go

Un slice est une structure de données flexible et plus puissante que les tableaux statiques.

// Voici comment déclarer un slice :
slice := []int{1, 2, 3}

// Pour accéder à un élément d'un slice, utilisez son index :
premierElement := slice[0] // premierElement vaut 1

// Pour ajouter un élément à un slice, utilisez la fonction append() :
slice = append(slice, 4) // slice vaut maintenant []int{1, 2, 3, 4}

// Il est également possible de créer un slice avec une capacité spécifique en utilisant la fonction make :
autreSlice := make([]int, 0, 10) // Crée un slice d'entiers de longueur 0 et de capacité 10

// Pour obtenir la longueur et la capacité d'un slice, utilisez les fonctions len() et cap() :
longueur := len(slice) // longueur vaut 4
capacite := cap(autreSlice) // capacite vaut 10

Maps en Go

Une map est une structure de données qui permet de stocker des paires clé-valeur.

// Voici comment déclarer une map :
mymap := map[string]int{"a": 1, "b": 2}

// Pour accéder à une valeur dans une map, utilisez la clé correspondante :
valeur := mymap["a"] // valeur vaut 1

// Il est également possible de vérifier si une clé est présente dans la map :
valeur, existe := mymap["c"] // valeur vaut 0 (valeur zéro pour int) et existe vaut false
if existe {
    fmt.Println("La clé 'c' existe dans la map et sa valeur est", valeur)
} else {
    fmt.Println("La clé 'c' n'existe pas dans la map")
}

Switches en Go

Un switch est une structure de contrôle qui permet d'exécuter différents blocs de code en fonction d'une valeur.

// Déclaration et initialisation de la variable number
number := 3

// Fonction qui utilise un switch pour afficher un message en fonction du nombre passé en paramètre
func printNumberMessage(number int) {
  switch number {
  case 1:
    fmt.Println("Number is equal to 1")
  case 2:
    fmt.Println("Number is equal to 2")
  default:
    fmt.Println("Number is not equal to 1 or 2")
  }
}

// Appel de la fonction avec la variable number
printNumberMessage(number)

Structs et méthodes en Go

Une struct est une collection de champs. Elle est utile pour regrouper des données.

// Voici comment déclarer une struct :
type Person struct {
  name string
  age  int
}

// On peut définir des méthodes sur les structs. Voici comment :
func (p Person) SayHello() {
  fmt.Println("Bonjour, je m'appelle", p.name)
}

// Pour créer une nouvelle instance d'une struct, faites comme ceci :
p := Person{name: "Jean Dupont", age: 30}

// On peut appeler des méthodes sur les instances de structs. Voici comment :
p.SayHello() // "Bonjour, je m'appelle Jean Dupont"

Boucles en Go

// Pour parcourir un tableau, on utilise la boucle for de cette manière :
for i := 0; i < len(numbers); i++ {
  fmt.Println(numbers[i]) // Affiche chaque élément du tableau
}

// Pour parcourir un slice, on peut aussi utiliser la boucle for, mais de cette façon :
for i := range numbers {
  fmt.Println(numbers[i]) // Affiche chaque élément du slice
}

// Pour parcourir une map, la boucle for est utilisée en conjonction avec range :
for key, value := range mymap {
  fmt.Println(key, value) // Affiche chaque clé et sa valeur correspondante dans la map
}

Conditions en Go

// Déclaration et initialisation de la variable i
i := 3

// Fonction qui utilise une condition pour afficher un message en fonction du nombre passé en paramètre
func printIfMessage(i int) {
  if i == 10 {
    fmt.Println("i is equal to 10")
  } else {
    fmt.Println("i is not equal to 10")
  }
}

// Appel de la fonction avec la variable i
printIfMessage(i)

// Fonction qui utilise un switch pour afficher un message en fonction du nombre passé en paramètre
func printSwitchMessage(i int) {
  switch i {
  case 1:
    fmt.Println("i is equal to 1")
  case 2:
    fmt.Println("i is equal to 2")
  default:
    fmt.Println("i is not equal to 1 or 2")
  }
}

// Appel de la fonction avec la variable i
printSwitchMessage(i)

Goroutines et canaux

Go utilise les goroutines et les canaux pour implémenter la concurrence.

// Une goroutine est un thread léger géré par le runtime de Go
// Un canal permet de communiquer entre les goroutines.

// Création d'un canal de string
ch := make(chan string)

// Création d'une goroutine qui envoie des données dans le canal
go func() {
  ch <- "Hello"
}()

// Création d'une goroutine qui reçoit des données du canal
go func() {
  message := <-ch
  fmt.Println(message) // Affiche "Hello"
}()

// Utilisation d'un WaitGroup pour attendre que toutes les goroutines se terminent
var wg sync.WaitGroup

wg.Add(2)
go func() {
  // Code de la première goroutine
  defer wg.Done()
}()
go func() {
  // Code de la deuxième goroutine
  defer wg.Done()
}()
wg.Wait()

Pointeurs

Un pointeur est une variable qui stocke l'adresse d'une autre variable.

// Déclaration d'une variable entière
var i int

// Déclaration d'un pointeur sur un entier
var pi *int

// Assignation de l'adresse de la variable i au pointeur pi
pi = &i

// Modification de la valeur de la variable i via le pointeur pi
*pi = 10

// Affichage de la valeur de la variable i via le pointeur pi
fmt.Println("Valeur de i :", i) // Affiche "10"

Ressources externes

• Documentation officielle de Go: https://golang.org/
• Tutoriels Go: https://golang.org/doc/tutorial/
• Articles de blog Go: https://golang.org/blog/

---

by @[email protected] 👉️ Github