Conditions (`if`/`else`)

La base de la décision : L'instruction `if`

Pour qu'un programme soit plus qu'une simple suite d'instructions exécutées séquentiellement, il doit pouvoir prendre des décisions. L'outil fondamental pour cela en Go, comme dans de nombreux langages, est l'instruction `if`. Elle permet d'exécuter un bloc de code uniquement si une condition donnée est vraie (évaluée à `true`).

La syntaxe la plus simple est la suivante :

if condition {
    // Bloc de code à exécuter si la condition est true
}

Considérons un exemple simple. Supposons que nous ayons une variable `age` et que nous voulions afficher un message uniquement si l'âge est supérieur ou égal à 18 :

package main

import "fmt"

func main() {
    age := 25

    if age >= 18 {
        fmt.Println("Vous êtes majeur.")
    }

    fmt.Println("Fin du programme.")
}

Offrir une alternative : L'instruction `else`

Souvent, nous voulons non seulement faire quelque chose si une condition est vraie, mais aussi faire autre chose si elle est fausse. C'est là qu'intervient le mot-clé `else`. Il permet de spécifier un bloc de code alternatif qui sera exécuté uniquement lorsque la condition du `if` est évaluée à `false`.

La syntaxe devient :

if condition {
    // Bloc exécuté si condition est true
} else {
    // Bloc exécuté si condition est false
}

Reprenons notre exemple précédent et ajoutons un message pour les mineurs :

package main

import "fmt"

func main() {
    age := 15

    if age >= 18 {
        fmt.Println("Vous êtes majeur.")
    } else {
        fmt.Println("Vous êtes mineur.")
    }

    fmt.Println("Vérification de l'âge terminée.")
}

Enchaîner les conditions : La structure `else if`

Parfois, nous devons vérifier plusieurs conditions successives. Si la première est fausse, nous voulons en tester une deuxième, puis une troisième, etc., avant d'éventuellement exécuter un bloc `else` final si aucune des conditions précédentes n'était vraie. Go permet cela avec la structure `else if`.

La syntaxe s'étend comme suit :

if condition1 {
    // Bloc exécuté si condition1 est true
} else if condition2 {
    // Bloc exécuté si condition1 est false ET condition2 est true
} else if condition3 {
    // Bloc exécuté si condition1 et condition2 sont false ET condition3 est true
} else {
    // Bloc exécuté si toutes les conditions précédentes sont false
}

Imaginons un système de notation simple :

package main

import "fmt"

func main() {
    note := 75

    if note >= 90 {
        fmt.Println("Mention Très Bien")
    } else if note >= 80 {
        fmt.Println("Mention Bien")
    } else if note >= 60 {
        fmt.Println("Mention Assez Bien")
    } else if note >= 50 {
        fmt.Println("Passable")
    } else {
        fmt.Println("Echec")
    }
}

Particularité Go : L'instruction courte dans le `if`

Go propose une syntaxe concise et puissante qui permet d'exécuter une instruction courte (typiquement une déclaration de variable avec `:=` ou une affectation simple) juste avant l'évaluation de la condition du `if`. Les variables déclarées dans cette instruction courte sont disponibles uniquement dans la portée des blocs `if`, `else if` et `else` associés.

La syntaxe est :

if instructionCourte; condition {
    // Accès aux variables de l'instruction courte possible ici
} else {
    // Accès aux variables de l'instruction courte possible ici aussi
}

Voici un exemple typique illustrant ce pattern avec une fonction hypothétique `calculer()` qui retourne un résultat et une erreur :

package main

import (
    "fmt"
    "errors"
)

// Fonction d'exemple
func calculer(valeur int) (int, error) {
    if valeur < 0 {
        return 0, errors.New("la valeur ne peut pas être négative")
    }
    return valeur * 2, nil // nil signifie pas d'erreur
}

func main() {
    valeurInitiale := 10

    if resultat, err := calculer(valeurInitiale); err != nil {
        // Erreur détectée : on la traite
        fmt.Printf("Erreur lors du calcul : %v\n", err)
        // resultat et err sont disponibles ici
    } else {
        // Pas d'erreur : on utilise le résultat
        fmt.Printf("Le résultat est : %d\n", resultat)
        // resultat et err (qui est nil) sont disponibles ici aussi
    }

    // fmt.Println(resultat) // Erreur ici : resultat n'est pas défini en dehors du if/else
}

Ce pattern peut aussi être utilisé pour vérifier l'existence d'une clé dans une map :

params := map[string]string{"user": "admin"}

if role, ok := params["role"]; ok {
    fmt.Printf("Le rôle est : %s\n", role)
} else {
    fmt.Println("Le rôle n'est pas défini.")
    // ok est false ici, role a sa valeur zéro (chaîne vide)
}

Bonnes pratiques et points clés

L'utilisation efficace des structures `if`/`else` est essentielle pour écrire du code clair et fonctionnel. Gardez à l'esprit quelques principes pour améliorer la qualité de vos conditions.

Privilégiez la clarté. Des conditions trop complexes ou imbriquées sur de nombreux niveaux peuvent rapidement rendre le code difficile à lire et à déboguer. Si une condition devient trop longue, envisagez de la décomposer en utilisant des variables intermédiaires ou en extrayant une partie de la logique dans une fonction booléenne distincte.

Utilisez l'instruction courte du `if` à bon escient, notamment pour la gestion des erreurs retournées par les fonctions et pour limiter la portée des variables temporaires. C'est un idiome puissant en Go qui améliore la localité et la lisibilité lorsqu'il est utilisé correctement.

Soyez conscient de l'ordre dans les chaînes `if`/`else if`. Placez les conditions les plus spécifiques ou les plus probables en premier si cela a du sens pour la logique ou potentiellement pour l'optimisation (bien que le compilateur puisse parfois réorganiser). Assurez-vous que l'ordre choisi correspond bien à la logique métier que vous souhaitez implémenter.

En résumé, les instructions `if`, `else if`, et `else` sont les outils de base pour introduire de la logique décisionnelle dans vos programmes Go. Leur syntaxe simple, combinée à la fonctionnalité d'instruction courte, permet d'écrire du code conditionnel de manière efficace et idiomatique.