Feuille de rappel de Golang

Commandes et constructions utiles en Go

Sommaire

Voici la structure de base d’un programme Go, les modèles de gestion des erreurs et la comparaison entre les canaux et les goroutines.

lapins autour du panneau golang

Cheatsheet de la langue Go

Syntaxe de base

Déclaration du package

package main

Importation des packages

import "fmt"
import (
    "fmt"
    "math"
)

Fonction principale

func main() {
    // Votre code ici
}

Variables et types

Déclaration de variable

var name string
var age int = 25
x := 10 // Déclaration courte

Types de base

bool
string
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
complex64, complex128

Structures de contrôle

Instruction if

if x > 0 {
    // code
} else if x < 0 {
    // code
} else {
    // code
}

Boucle for

for i := 0; i < 10; i++ {
    // code
}

Boucle range

for index, value := range collection {
    // code
}

Instruction switch

switch variable {
case value1:
    // code
case value2:
    // code
default:
    // code
}

Fonctions

Déclaration de fonction

func functionName(param1 type1, param2 type2) returnType {
    // code
    return value
}

Retour multiple

func divideAndRemainder(x, y int) (int, int) {
    return x / y, x % y
}

Structures de données

Tableaux

var numbers int
numbers := int{1, 2, 3, 4, 5}

Tranches

slice := []int{1, 2, 3}
slice := make([]int, 3, 5)

Maps

m := make(map[string]int)
m["key"] = value

Structs

type Person struct {
    Name string
    Age  int
}
p := Person{Name: "Alice", Age: 30}

Méthodes

Déclaration de méthode

func (r Rectangle) Area() float64 {
    return r.width * r.height
}

Interfaces

Déclaration d’interface

type Shape interface {
    Area() float64
}

Concurrency

Goroutines

go functionName()

Canaux

ch := make(chan int)
ch <- value  // Envoi
value := <-ch  // Réception

Gestion des erreurs

Vérification des erreurs

if err != nil {
    // Gérer l'erreur
}

Utilisation de defer

defer file.Close()

Tests

Fonction de test

func TestFunction(t *testing.T) {
    // Code de test
}

Ce cheatsheet couvre les constructions et commandes essentielles de la langue Go. Il inclut la syntaxe de base, les structures de contrôle, les fonctions, les structures de données, les méthodes, les interfaces, les primitives de concurrence et la gestion des erreurs. Souvenez-vous que Go met l’accent sur la simplicité et la lisibilité, donc ces constructions forment la base pour écrire du code Go efficace et clair.

Gestion des erreurs en Go

La gestion des erreurs en Go est simple et explicite, mettant l’accent sur la clarté et la robustesse. Voici les techniques clés pour gérer les erreurs en Go :

Retourner les erreurs comme valeurs : Les fonctions qui peuvent échouer doivent retourner une erreur comme leur dernière valeur de retour. Par exemple :

func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("nom vide")
    }
    message := fmt.Sprintf("Bonjour, %v. Bienvenue !", name)
    return message, nil
}

Vérifier toujours les erreurs : Après avoir appelé une fonction qui retourne une erreur, vérifiez immédiatement si l’erreur n’est pas nulle. Par exemple :

result, err := SomeFunction()
if err != nil {
    // Gérer l'erreur
    log.Fatal(err)
}

Utiliser l’enveloppement d’erreurs : Lorsque vous propagez des erreurs vers le haut de la pile d’appel, enveloppez-les pour ajouter un contexte en utilisant fmt.Errorf() avec le verbe %w. Par exemple :

f, err := os.Open(path)
if err != nil {
    return nil, fmt.Errorf("ouverture échouée : %w", err)
}

Utiliser defer pour le nettoyage : Utilisez defer pour vous assurer que les ressources sont correctement fermées ou nettoyées, même si une erreur se produit.
Créer des types d’erreurs personnalisés : Implémentez l’interface error pour des types d’erreurs personnalisés afin de fournir des informations d’erreur plus détaillées.
Utiliser le package errors : Profitez des fonctions comme errors.New() pour créer des messages d’erreur simples, et errors.Is() ou errors.As() pour la vérification et la conversion des types d’erreur.
Éviter d’utiliser panic : Réservez panic aux situations véritablement irrécupérables. La gestion normale des erreurs doit utiliser les valeurs de retour.
Fournir des informations d’erreur explicites : Rendez les messages d’erreur clairs et informatifs pour aider au débogage et à la résolution des problèmes.

En suivant ces pratiques, vous pouvez créer des programmes Go robustes qui gèrent efficacement les erreurs et maintiennent la clarté du code.

Bonnes pratiques pour les goroutines et les canaux en Go

Utilisation efficace des goroutines

Éviter la création excessive de goroutines : Créez des goroutines avec discernement, en tenant compte de la nature de la tâche et de savoir si elle bénéficiera d’une exécution parallèle.
Synchronisation appropriée : Utilisez des mécanismes de synchronisation comme les canaux ou les groupes d’attente pour gérer efficacement les goroutines et éviter le gaspillage de ressources.
Considérer la nature de la tâche : Évaluez si une tâche bénéficiera vraiment d’une exécution concourante avant d’utiliser des goroutines.

Utilisation efficace des canaux

Choisir le type de canal approprié : Utilisez des canaux non tamponnés pour la synchronisation et des canaux tamponnés lorsque vous avez besoin de découpler les opérations d’envoi et de réception.
Capacité du tampon : Lorsque vous utilisez des canaux tamponnés, considérez soigneusement la taille du tampon pour équilibrer les performances et l’utilisation des ressources.
Fermer correctement les canaux : Assurez-vous que les canaux sont fermés lorsqu’aucune donnée ne sera envoyée pour éviter les blocages et les fuites de ressources.

Modèles de concurrence

Modèle de pool de travailleurs : Implémentez des pools de travailleurs en utilisant des goroutines et des canaux pour une distribution efficace des tâches et une collecte des résultats.
Modèle producteur-consommateur : Utilisez des goroutines en tant que producteurs et consommateurs, avec des canaux facilitant le flux de données entre eux.

Gestion des erreurs et gestion des ressources

Utiliser defer pour le nettoyage : Utilisez des déclarations defer pour vous assurer d’un nettoyage correct des ressources, même en présence d’erreurs.
Gérer les panics : Implémentez recover() dans les goroutines longues pour empêcher tout le programme de tomber en panique à cause d’un panic dans une seule goroutine.

Communication et synchronisation

Préférer les canaux à la mémoire partagée : Utilisez des canaux pour la communication entre les goroutines afin d’éviter les conditions de course et de simplifier la synchronisation.
Utiliser select pour plusieurs canaux : Employez l’instruction select pour gérer plusieurs opérations de canal de manière concourante.

Considérations de performance

Limiter les opérations concourantes : Utilisez des sémaphores ou des pools de travailleurs pour limiter le nombre d’opérations concourantes et éviter l’épuisement des ressources.
Éviter l’optimisation prématurée : Profiliez votre code pour identifier les goulets d’étranglement avant d’appliquer des optimisations de concurrence.

Tests et débogage

Utiliser le détecteur de courses : Exécutez régulièrement vos tests avec le drapeau -race pour détecter les courses de données.
Écrire des tests concurrents : Créez des tests qui exercent spécifiquement vos chemins de code concurrents pour assurer leur fiabilité.

En suivant ces bonnes pratiques, vous pouvez efficacement utiliser le modèle de concurrence de Go, rendant vos programmes plus efficaces, maintenables et moins sujets aux problèmes courants liés à la concurrence.

Voir d’autres articles du blog technique.

Mise à jour de golang sur Linux

allez sur le site et téléchargez la nouvelle version : https://go.dev/doc/install
supprimez l’ancienne :

sudo rm -rf /usr/local/go

installez la nouvelle :

cd Downloads
sudo tar -C /usr/local -xzf go1.24.3.linux-amd64.tar.gz