Top des erreurs des développeurs Go débutants : comment les éviter

Top des erreurs des développeurs Go débutants : comment les éviter

Go (ou Golang) est un langage de programmation compilé, typé statiquement, créé chez Google. Il a gagné en popularité grâce à sa simplicité, ses performances et son support intégré de la concurrence. Cependant, même avec une syntaxe aussi concise, les débutants commettent souvent les mêmes erreurs. Dans cet article, nous allons analyser le top 4 des erreurs typiques des développeurs Go débutants et montrer comment les éviter.

1. Ignorer les erreurs retournées

L'une des erreurs les plus courantes est d'ignorer les erreurs retournées par les fonctions. En Go, il n'y a pas d'exceptions (try-catch), et les erreurs sont des valeurs ordinaires qui doivent être traitées explicitement. De nombreux débutants, habitués à d'autres langages, assignent simplement le résultat à une variable en oubliant de vérifier err.

Incorrect :

package main

import (    "fmt"    "os")

func main() {    file, _ := os.Open("config.txt") // On ignore l'erreur    fmt.Println(file.Name())}

Si le fichier n'existe pas, le programme paniquera (provoquera une panic) ou fonctionnera avec un pointeur nil, ce qui entraînera un comportement inattendu.

Correct :

package main

import (    "fmt"    "log"    "os")

func main() {    file, err := os.Open("config.txt")    if err != nil {        log.Fatalf("Impossible d'ouvrir le fichier : %v", err)    }    defer file.Close()    fmt.Println(file.Name())}

Conseil : Vérifiez toujours err immédiatement après l'appel de la fonction. Utilisez log.Fatal ou retournez l'erreur plus haut dans la pile, mais ne l'ignorez jamais.

2. Mauvaise gestion des goroutines et des courses de données

Les goroutines sont des threads légers en Go. Cependant, les débutants lancent souvent des goroutines sans se soucier de la synchronisation de l'accès aux données partagées. Cela entraîne des courses de données (data race), lorsque plusieurs goroutines lisent et écrivent simultanément dans une même variable.

Incorrect :

package main

import (    "fmt"    "sync")

func main() {    counter := 0    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {        wg.Add(1)        go func() {            defer wg.Done()            counter++ // Course de données !        }()    }    wg.Wait()    fmt.Println(counter) // Le résultat peut être n'importe quoi (pas 1000)}

Correct (avec utilisation d'un mutex) :

package main

import (    "fmt"    "sync")

type Counter struct {    mu sync.Mutex    value int}

func (c *Counter) Increment() {    c.mu.Lock()    defer c.mu.Unlock()    c.value++}

func (c *Counter) Value() int {    c.mu.Lock()    defer c.mu.Unlock()    return c.value}

func main() {    counter := &Counter{}    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {        wg.Add(1)        go func() {            defer wg.Done()            counter.Increment()        }()    }    wg.Wait()    fmt.Println(counter.Value()) // Toujours 1000}

Conseil : Utilisez des mutex (sync.Mutex) ou des canaux pour la synchronisation. Lancez les tests avec le flag -race : go test -race.

3. Confusion entre slice nil et slice vide

En Go, les slices peuvent être nil ou vides. Les débutants ne comprennent souvent pas la différence, ce qui entraîne des erreurs lors de la sérialisation (JSON) ou du passage de slices à des fonctions.

• Slice nil : déclaré comme var s []int. Il n'a pas de tableau sous-jacent.
• Slice vide : créé comme s := []int{} ou make([]int, 0). Il a un tableau sous-jacent, mais sa longueur est 0.

Exemple de confusion :

package main

import (    "e