Conditions (if, else, switch)

Maîtrisez TOUS les aspects des conditions en Go ! Guide exhaustif sur `if`, `else`, `switch`, incluant le 'tagless switch' et les cas multiples, pour une prise de décision experte dans vos programmes.

Les instructions conditionnelles : aiguiller votre programme selon toutes les situations

Les instructions conditionnelles sont les outils de décision ultimes dans vos programmes Go. Elles ne se limitent pas à des choix simples, mais permettent de gérer des scénarios complexes et variés. Avec elles, votre programme peut réagir finement à toutes sortes de situations et de données.

En Go, if, else if, else et switch ne sont pas juste des instructions, ce sont de véritables couteaux suisses pour contrôler le flux de votre code. Vous pouvez tester des égalités, des inégalités, des plages de valeurs, des types, et même des combinaisons complexes de conditions.

Ce chapitre va bien au-delà des bases ! Nous allons explorer en profondeur toutes les facettes des instructions conditionnelles en Go, y compris les techniques avancées comme le "tagless switch" et la gestion de cas multiples. Après ce chapitre, vous serez capable de maîtriser la logique de décision dans vos programmes Go comme un véritable expert.

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

L'instruction if reste la base de toute décision conditionnelle. Elle permet d'exécuter du code si, et seulement si, une condition est vraie. Sa syntaxe, simple et élégante, est votre point de départ pour structurer la logique de vos programmes :

if condition {
    // Bloc de code exécuté si la condition est VRAIE
}

Points clés de la syntaxe `if` :

if : le mot-clé qui introduit la condition.

condition : une expression booléenne. Le coeur de la décision ! Elle doit toujours se résoudre à true ou false.

{ ... } : les accolades délimitent le bloc d'instructions. Ce bloc est exécuté uniquement si condition est évaluée à true.

Exemple concret : Vérifier l'âge pour l'accès à un site.

package main

import "fmt"

func main() {
    ageUtilisateur := 15

    if ageUtilisateur >= 18 { // Condition : Age supérieur ou égal à 18 ans ?
        fmt.Println("Accès autorisé au site") // Si VRAI, message d'accès
    }

    if ageUtilisateur < 18 { // Autre condition : Age inférieur à 18 ans ?
        fmt.Println("Accès refusé, âge minimum requis : 18 ans") // Si VRAI, message de refus
    }
}

Dans cet exemple, deux instructions if sont utilisées pour tester différentes conditions sur l'âge de l'utilisateur. Seul le code correspondant à la condition vraie sera exécuté. Pour gérer des alternatives (faire autre chose si la condition est fausse), entre en jeu l'instruction else.

Instructions `else` et `else if` : gérer les alternatives

Pour aller au-delà du simple test Vrai/Faux, Go propose else et else if. Ces instructions permettent de définir des alternatives à l'instruction if, pour exécuter du code différent selon que la condition initiale est vraie ou fausse, ou selon d'autres conditions :

Syntaxe complète avec `if`, `else if`, et `else` :

if condition1 {
    // Code si condition1 est VRAIE
} else if condition2 {
    // Code si condition1 est FAUSSE et condition2 est VRAIE
} else if condition3 {
    // Code si condition1 et condition2 sont FAUSSES et condition3 est VRAIE
} else {
    // Code si TOUTES les conditions précédentes sont FAUSSES
}

Fonctionnement détaillé :

if condition1 : La première condition testée. Si vraie, le bloc if est exécuté, et le reste (else if, else) est ignoré.

else if condition2, else if condition3, ... : Conditions alternatives, testées uniquement si les conditions précédentes sont fausses. Vous pouvez avoir autant de else if que nécessaire.

else : Le bloc "par défaut", exécuté si aucune des conditions if et else if n'a été vraie. Le else est optionnel.

Exemple : Catégorisation de l'âge avec `if`, `else if`, `else`.

package main

import "fmt"

func main() {
    age := 25
    categorie := ""

    if age < 13 {
        categorie = "Enfant"
    } else if age < 18 {
        categorie = "Adolescent"
    } else if age < 65 {
        categorie = "Adulte"
    } else {
        categorie = "Senior"
    }

    fmt.Printf("Age : %d, Catégorie : %s\n", age, categorie) // Output: Age : 25, Catégorie : Adulte
}

Cet exemple illustre la puissance de if-else if-else pour gérer différents cas de manière claire et structurée. Le programme teste les conditions d'âge dans l'ordre et affecte la catégorie appropriée à la variable categorie.

L'instruction `switch` : le choix multiple optimisé

L'instruction switch est votre outil de choix pour simplifier la gestion de multiples cas basés sur la valeur d'une expression. Elle offre une alternative plus lisible et souvent plus efficace qu'une longue série de if-else if-else, surtout quand il s'agit de tester des égalités.

Syntaxe de base de `switch` (le "switch d'expression") :

switch expression { // L'expression à évaluer
case valeur1:
    // Code si expression == valeur1
case valeur2:
    // Code si expression == valeur2
case valeur3, valeur4, valeur5: // Cas multiples !
    // Code si expression == valeur3 OU valeur4 OU valeur5
default:
    // Code par défaut si aucune correspondance
}

Points clés de la syntaxe `switch` :

switch expression : Le mot-clé switch suivi de l'expression à évaluer. Go va comparer la valeur de cette expression avec les valeurs des case.

case valeurN: : Chaque case teste une valeur дискретная. Si l'expression est égale à valeurN, le code du case est exécuté.

case valeur3, valeur4, valeur5: : Un seul case peut gérer plusieurs valeurs séparées par des virgules, agissant comme un "OU logique".

default: : Le cas optionnel par défaut, exécuté si aucune des valeurs des case ne correspond à l'expression.

Pas de `break implicite ! Contrairement à d'autres langages, Go sort automatiquement du switch après avoir exécuté un case. Pas de "fallthrough" par défaut.

Exemple : Gestion des jours de la semaine avec `switch`.

package main

import "fmt"

func main() {
    jourSemaine := 3 // Mercredi
    nomJour := ""

    switch jourSemaine {
    case 1: nomJour = "Lundi"
    case 2: nomJour = "Mardi"
    case 3: nomJour = "Mercredi"
    case 4: nomJour = "Jeudi"
    case 5: nomJour = "Vendredi"
    case 6, 7: nomJour = "Week-end" // Cas multiples : Samedi OU Dimanche
    default: nomJour = "Jour invalide"
    }

    fmt.Println("Jour", jourSemaine, "est :", nomJour) // Output: Jour 3 est : Mercredi
}

Cet exemple illustre la clarté et la concision de switch pour gérer un ensemble de cas aux valeurs bien définies et séparées, que l'on appelle des valeurs discrètes. Le case 6, 7: illustre la gestion élégante de cas multiples, où un seul bloc de code répond à plusieurs valeurs possibles de l'expression switch.

Le "Tagless Switch" (switch sans expression) : la puissance des conditions complexes dans un `switch`

Pour aller encore plus loin, Go offre une forme avancée de switch : le "tagless switch" (switch sans expression), aussi appelé "switch true". Cette forme vous libère des tests d'égalité et vous permet d'utiliser le switch pour évaluer des conditions booléennes complexes, comme avec if-else if-else, mais avec la syntaxe plus structurée du switch.

Syntaxe du "Tagless Switch" :

switch { // PAS d'expression après 'switch' !
case condition1:
    // Code si condition1 est VRAIE
case condition2:
    // Code si condition2 est VRAIE
case condition3:
    // Code si condition3 est VRAIE
default:
    // Code par défaut si AUCUNE condition n'est vraie
}

Fonctionnement du "Tagless Switch" :

switch {} (ou switch true {}) : Le mot-clé switch est utilisé sans expression après lui (ou avec true, ce qui est équivalent). C'est ce qui distingue le "tagless switch".

case conditionN: : Chaque case contient directement une expression booléenne (une condition) à évaluer. Ce ne sont plus des valeurs à comparer à une expression externe.

Le switch évalue les case de haut en bas. Le bloc de code du premier case dont la condition est true est exécuté, et le reste du switch est ignoré.

default: : Fonctionne comme dans le switch d'expression : exécuté si aucune des conditions des case n'est vraie.

Exemple : Catégorisation de l'âge avec un "Tagless Switch".

package main

import "fmt"

func main() {
    age := 25
    categorie := ""

    switch { // Tagless switch !
    case age < 13:
        categorie = "Enfant"        // Condition booléenne directement dans le case
    case age < 18:
        categorie = "Adolescent"   // Condition booléenne directement dans le case
    case age < 65:
        categorie = "Adulte"     // Condition booléenne directement dans le case
    default:
        categorie = "Senior"     // Cas par défaut
    }

    fmt.Printf("Age : %d, Catégorie : %s\n", age, categorie) // Output: Age : 25, Catégorie : Adulte
}

Remarquez la similitude avec l'exemple if-else if-else de la section précédente ! Le "tagless switch" offre une alternative syntaxique souvent plus claire pour gérer des séries de conditions complexes, tout en conservant la structure du switch.

Choisir entre `if-else if-else` et `switch` : quel outil pour quelle situation ? (Récapitulatif)

Récapitulons le meilleur choix entre if-else if-else et switch :

if-else if-else : Le couteau suisse universel
- Conditions complexes : Idéal pour tester des conditions variées et complexes (plages, combinaisons logiques, etc.).
- Flexibilité maximale : S'adapte à presque toutes les situations de prise de décision.
- Lisibilité pour conditions complexes : Peut être plus clair pour des logiques conditionnelles imbriquées ou non linéaires.

switch (expression et tagless) : La précision chirurgicale pour les cas multiples
- Tests d'égalité (switch d'expression) : Excellent pour comparer une valeur à de nombreuses valeurs дискретные (cas multiples).
- Conditions booléennes complexes (tagless switch) : Permet de gérer des conditions complexes avec une syntaxe plus structurée que if-else if-else.
- Lisibilité pour cas дискретные et choix multiples : Rend le code plus concis et plus facile à lire dans ces situations.
- Potentiel de performance : Dans certains cas, peut être légèrement plus rapide pour les tests d'égalité.

Le Choix Final : Dans de nombreux cas, les deux approches peuvent fonctionner. Le choix final dépend souvent de la lisibilité et de la clarté du code. Privilégiez toujours la structure qui rend votre logique de décision la plus facile à comprendre et à maintenir pour vous et pour les autres développeurs.

Exercices pratiques : conditions (if, else, switch) - Maîtrisez la décision

Exercice 1 : Déterminer la saison avec `if-else if-else`

Ecrivez un programme go qui demande à l'utilisateur de saisir un mois (nombre entier de 1 à 12). Utilisez une instruction if-else if-else pour déterminer et afficher la saison correspondante (Printemps, Eté, Automne, Hiver). Définissez vous-même les plages de mois pour chaque saison.

Exercice 2 : Calculatrice étendue avec `switch` et `default`

Reprenez l'exercice de la calculatrice simple du chapitre précédent. Améliorez-la pour gérer les opérations suivantes : addition (+), soustraction (-), multiplication (*), division (/), et puissance (^). Utilisez un switch pour gérer les différents opérateurs, et ajoutez un cas default pour gérer les opérateurs invalides.

Exercice 3 : Catégorie de poids avec "Tagless Switch"

Ecrivez un programme go qui demande à l'utilisateur de saisir son poids (flottant) et sa taille (flottant). Calculez l'IMC (Indice de Masse Corporelle = poids / (taille * taille)). Utilisez un "tagless switch" pour déterminer et afficher la catégorie de poids selon les plages d'IMC suivantes (adaptées de l'OMS, à titre d'exemple) :

IMC < 18.5 : "Insuffisance pondérale"

18.5 <= IMC < 25 : "Poids normal"

25 <= IMC < 30 : "Surpoids"

IMC >= 30 : "Obésité"

Exercice 4 (Challenge) : Jeu de devinette amélioré avec `if`, `else if`, `else` et boucle

Reprenez l'exercice du jeu de devinette du chapitre sur les boucles. Améliorez le jeu en ajoutant les fonctionnalités suivantes :

Limitez le nombre de tentatives à 5. Utilisez une boucle for conditionnelle pour gérer les tentatives.

Après chaque tentative incorrecte, affichez non seulement si le nombre est plus grand ou plus petit, mais aussi le nombre de tentatives restantes.

Si l'utilisateur ne trouve pas le nombre après 5 tentatives, affichez un message de défaite et révélez le nombre mystère. Utilisez une instruction if-else pour gérer les cas de victoire et de défaite.

En résumé : les conditions `if`, `else if`, `else` et `switch` - la logique de décision à votre portée

Félicitations ! Vous êtes maintenant armé(e) jusqu'aux dents avec les instructions conditionnelles en Go ! Vous avez exploré en profondeur :

L'instruction if : le pilier de la décision conditionnelle.

Les instructions else et else if : pour gérer des alternatives et des cas multiples de manière linéaire.

L'instruction switch (expression et tagless) : pour optimiser le choix parmi de nombreux cas, qu'il s'agisse de tests d'égalité ou de conditions complexes.

Vous savez désormais quand et comment utiliser chaque instruction conditionnelle pour créer des programmes Go capables de prendre des décisions intelligentes et de s'adapter à une multitude de situations. La logique de décision n'a plus de secret pour vous ! Continuez sur votre lancée, entraînez-vous avec les exercices, et vous deviendrez un maître du contrôle de flux en Go !

◄ Précédent Suivant ►

く