- Installation de Go
- Création d'un projet Golang
- Installation et gestion des packages Go
- Exécution d'un programme Go
- Déclaration de variables et de constantes
- Fonctions
- Tableaux en Go
- Slices en Go
- Maps en Go
- Switches en Go
- Structs et méthodes en Go
- Boucles en Go
- Conditions en Go
- Goroutine et Canaux
- Pointeurs en 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
Pour créer un nouveau projet Go, suivez les étapes suivantes :
- Créez un nouveau répertoire pour votre projet. Par exemple,
mkdir monprojet
. - Naviguez dans ce répertoire avec
cd monprojet
. - Initialisez un nouveau module Go avec
go mod init nomdumodule
. Remplaceznomdumodule
par le nom de votre module.
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.
# 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
// 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
// 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
// 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)
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
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")
}
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)
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"
// 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
}
// 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)
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()
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"
- Documentation officielle de Go: https://golang.org/
- Tutoriels Go: https://golang.org/doc/tutorial/
- Articles de blog Go: https://golang.org/blog/