Maîtriser les instructions conditionnelles en Go

En langage Go, les instructions conditionnelles utilisent principalement le mot-clé « if » pour exécuter des blocs de code en fonction de conditions spécifiques. La syntaxe de base de la déclaration « if » en Go est assez simple et intuitive. Voici une explication détaillée sur la manière d’écrire des instructions conditionnelles « if » en Go :

Syntaxe de base :

La syntaxe générale d’une instruction « if » en Go est la suivante :

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

Exemple simple :

Voici un exemple simple d’utilisation de l’instruction « if » en Go :

go
package main

import "fmt"

func main() {
    x := 10

    if x > 5 {
        fmt.Println("x est supérieur à 5")
    }
}

Dans cet exemple, si la valeur de la variable x est supérieure à 5, alors le message « x est supérieur à 5 » sera imprimé.

Utilisation de l’opérateur logique « && » :

Vous pouvez également utiliser l’opérateur logique « && » pour combiner plusieurs conditions dans une seule instruction « if ». Par exemple :

go
package main

import "fmt"

func main() {
    x := 10
    y := 7

    if x > 5 && y > 5 {
        fmt.Println("x et y sont tous deux supérieurs à 5")
    }
}

Dans cet exemple, le bloc de code à l’intérieur de l’instruction « if » ne sera exécuté que si à la fois x et y sont supérieurs à 5.

Utilisation de l’instruction « else » :

Vous pouvez également utiliser l’instruction « else » pour exécuter un bloc de code alternatif si la condition dans l’instruction « if » n’est pas vraie. Voici un exemple :

go
package main

import "fmt"

func main() {
    x := 3

    if x > 5 {
        fmt.Println("x est supérieur à 5")
    } else {
        fmt.Println("x n'est pas supérieur à 5")
    }
}

Dans cet exemple, si la valeur de x n’est pas supérieure à 5, alors le message « x n’est pas supérieur à 5 » sera imprimé.

Utilisation de l’instruction « else if » :

Pour évaluer plusieurs conditions de manière séquentielle, vous pouvez utiliser l’instruction « else if ». Par exemple :

go
package main

import "fmt"

func main() {
    x := 3

    if x > 5 {
        fmt.Println("x est supérieur à 5")
    } else if x == 5 {
        fmt.Println("x est égal à 5")
    } else {
        fmt.Println("x est inférieur à 5")
    }
}

Dans cet exemple, si la valeur de x n’est pas supérieure à 5 et n’est pas égale à 5, alors le message « x est inférieur à 5 » sera imprimé.

Utilisation de l’instruction « if » avec une initialisation de variable :

Il est également possible d’initialiser une variable dans l’instruction « if » et de l’utiliser ensuite dans le bloc de code. Par exemple :

go
package main

import "fmt"

func main() {
    if x := 10; x > 5 {
        fmt.Println("x est supérieur à 5")
    }
}

Dans cet exemple, la variable x est initialisée avec la valeur 10 dans l’instruction « if », et ensuite la condition x > 5 est évaluée.

En résumé, les instructions conditionnelles « if » en Go offrent une grande flexibilité pour contrôler le flux d’exécution du programme en fonction de différentes conditions. Vous pouvez les utiliser pour exécuter des blocs de code en fonction de conditions spécifiques, et les combiner avec les instructions « else » et « else if » pour gérer des cas alternatifs.

Plus de connaissances

Bien sûr, continuons à explorer davantage les fonctionnalités des instructions conditionnelles « if » en Go.

Opérateurs de comparaison :

En Go, vous pouvez utiliser plusieurs opérateurs de comparaison dans les conditions « if » pour évaluer différentes expressions. Voici les principaux opérateurs de comparaison que vous pouvez utiliser :

== : égal à
!= : différent de
< : inférieur à
> : supérieur à
<= : inférieur ou égal à
>= : supérieur ou égal à

Par exemple :

go
package main

import "fmt"

func main() {
    x := 10

    if x == 10 {
        fmt.Println("x est égal à 10")
    }

    if x != 5 {
        fmt.Println("x n'est pas égal à 5")
    }

    if x < 20 {
        fmt.Println("x est inférieur à 20")
    }

    if x > 5 {
        fmt.Println("x est supérieur à 5")
    }

    if x <= 10 {
        fmt.Println("x est inférieur ou égal à 10")
    }

    if x >= 10 {
        fmt.Println("x est supérieur ou égal à 10")
    }
}

Utilisation de l'instruction "if" sans condition :

En Go, vous pouvez également utiliser l'instruction "if" sans condition pour créer une boucle infinie ou une boucle basée sur une autre condition. Voici un exemple :

go
package main

import "fmt"

func main() {
    x := 0

    if {
        fmt.Println("Ceci est une boucle infinie")
    }

    for x < 5 {
        fmt.Println("Ceci est une boucle basée sur une condition")
        x++
    }
}

Dans cet exemple, la première instruction "if" crée une boucle infinie car elle n'a pas de condition spécifiée. La deuxième instruction "if" est suivie d'une boucle "for" qui continue tant que la condition x < 5 est vraie.

Utilisation de l'instruction "switch" :

En plus de l'instruction "if", Go fournit également l'instruction "switch" qui peut être utilisée pour évaluer une expression avec plusieurs cas possibles. Voici un exemple d'utilisation de l'instruction "switch" :

go
package main

import "fmt"

func main() {
    day := "lundi"

    switch day {
    case "lundi":
        fmt.Println("C'est lundi.")
    case "mardi":
        fmt.Println("C'est mardi.")
    case "mercredi":
        fmt.Println("C'est mercredi.")
    default:
        fmt.Println("C'est un autre jour de la semaine.")
    }
}

Dans cet exemple, l'instruction "switch" évalue la valeur de la variable day et exécute le bloc de code correspondant au cas correspondant. Si aucun des cas ne correspond, le bloc de code dans la clause "default" est exécuté.

Utilisation de l'instruction "defer" avec "if" :

L'instruction "defer" en Go est utilisée pour reporter l'exécution d'une fonction jusqu'à ce que la fonction appelante soit terminée. Vous pouvez également l'utiliser avec une instruction "if" pour reporter l'exécution d'une fonction jusqu'à ce qu'une condition soit remplie. Voici un exemple :

go
package main

import "fmt"

func main() {
    x := 10
    y := 5

    if x > y {
        defer fmt.Println("Ceci est exécuté après la fin de la fonction main.")
    }

    fmt.Println("Fin de la fonction main.")
}

Dans cet exemple, la fonction passée à l'instruction "defer" sera exécutée après que la fonction main soit terminée, car la condition dans l'instruction "if" est vraie.

En résumé, en plus des fonctionnalités de base des instructions conditionnelles "if", Go offre également des fonctionnalités avancées telles que l'utilisation d'opérateurs de comparaison, l'instruction "switch" pour gérer plusieurs cas, et l'instruction "defer" pour reporter l'exécution de fonctions. Ces fonctionnalités permettent aux développeurs d'écrire un code flexible et concis pour contrôler le flux d'exécution dans leurs programmes.