- 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 golangPour 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. Remplaceznomdumodulepar 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/errorsCette 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=patchPour 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 tidyPour voir tous les packages que vous avez installés, vous pouvez utiliser la commande
go list -m allPour 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 10Une 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/