Les conditions dans le langage de programmation Go

Les prérequis

Maintenant que vous savez comment déclarer vos variables, il est temps de les tester avec des conditions !

Entrée utilisateur

Avant de vous montrer comment créer des conditions, je vais d'abord vous indiquer comment enregistrer une entrée utilisateur dans une variable (nous utiliserons les entrées utilisateur plus tard dans la suite de ce chapitre et dans les prochains chapitres)

Pour cela, on va utiliser la fonction NewScanner() de la bibliothèque bufio. Cette fonction permet de créer un nouveau scanner qui nous permettra de capturer l'entrée utilisateur.

Voici comment elle s'utilise :

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin) // création du scanner capturant une entrée utilisateur
    fmt.Print("Entrez quelque chose : ")
    scanner.Scan()                      // lancement du scanner
    entreeUtilisateur := scanner.Text() // stockage du résultat du scanner dans une variable
    fmt.Println(entreeUtilisateur)
}

Résultat :

Entrez quelque chose : quelque chose
quelque chose

Convertir une string en entier

J'ai une autre chose à vous montrer avant de passer à la suite. Pour le moment nous sommes capables de capturer que des chaines de caractères, dans certains cas vous aurez besoin de capturer un type int à la place d'un type string pour faire par exemple des calculs.

Pour ce faire, il suffit de convertir le résultat de votre scanner en int, une fonction nommée Atoi() de la bibliothèque strconv est disponible pour répondre à ce besoin.

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    fmt.Print("Entrez un nombre entier : ")
    scanner.Scan()

    nbr, _ := strconv.Atoi(scanner.Text()) // conversion du type string en int

    fmt.Printf("res : %d\n", (nbr + 6))
}

Résultat :

Entrez un nombre entier : 6
res : 12

Les conditions

Maintenant promis on s'attaque aux conditions 😅.

if, else

Imaginons le scénario suivant : "un videur de boîte de nuit fainéant décide d'automatiser l'entrée des clients avec le langage de programmation Go."

Pour répondre à l'envie du videur, on va utiliser les conditions.

Pour créer une condition il suffit d'utiliser le mot-clé if (qui se traduit en français par "si") suivit de votre condition. Ensuite vous ouvrez une accolade { et fermez-la un peu plus loin }. Tout ce qui se trouve à l'intérieur de vos accolades sera exécuté uniquement si la condition est bonne.

Pour revenir à notre scénario, on va d'abords commencer par respecter la loi en refusant les mineurs.

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    fmt.Print("Entrez votre age : ")
    scanner.Scan()                   
    age, err := strconv.Atoi(scanner.Text())
    if err != nil {
        // Si la conversion n'a pas fonctionné alors on affiche un message d'erreur et on quitte le programme
        fmt.Println("On essaie de m'arnaquer ? allé Dehors ! Et la prochaine entrez un entier !")
        os.Exit(2) // on quitte le programmation
    }

    if age < 17 { // vérifier si l'utilisateur à au moins 18 ans
        fmt.Println("Sortez !")
    } else { // si ce n'est pas le cas alors on l'accepte pas
        fmt.Println("Entrez :)")
    }
}

Résultat :

Entrez votre age : 16
Sortez !

Entrez votre age : 25
Entrez :)

La dernière partie avec le mot-clé else (qui se traduit en français par "autre") traite le cas où aucune des conditions n'a été remplie (elle est optionnelle).

Les opérateurs de comparaison

Dans notre ancien exemple nous avons utilisé l'opérateur de comparaison <. En effet il existe d'autres types d'opérateurs que je vais décrire à travers le tableau ci-dessous

Les opérateurs logiques

Les opérateurs logiques vont nous permettre de vérifier si plusieurs conditions sont bonnes. Il existe trois types d'opérateurs logiques :

else if

Suite du scénario : "Le videur a laissé sa place à un nouveau videur très fainéant aussi (on ne change pas une équipe qui gagne 😉) mais bon il est un peu spécial ..."

Tant mieux car au moins avec lui on va pouvoir utiliser les opérateurs logiques vu précédemment !

Voici les caractéristiques du nouveau videur :

• Le nouveau videur n'aime pas le prénom Hatim ou hatim (je ne me sens pas visé 😢)
• Le nouveau videur a tendance à changer d'humeur de temps en temps et quand il n'est pas content il décide alors de virer les personnes ayant 18 ans

Les opérateurs de comparaison ne vont pas nous suffire, il nous faut un moyen pour tester d'autres conditions quand la première condition n'est pas vrai. Ce cas est gérable avec le mot-clé else if (qui se traduit en français par "sinon si"). La syntaxe ressemble à celle du mot-clé if.

Dans cet exemple je vais utiliser la bibliothèque math/rand pour apporter de l'aléatoire à notre code

package main

import (
    "bufio"
    "fmt"
    "math/rand"
    "os"
    "strconv"
    "time"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    fmt.Print("Entrez votre age : ")
    scanner.Scan()
    age, err := strconv.Atoi(scanner.Text())
    if err != nil {
        fmt.Println("On essaie de m'arnaquer ? allé Dehors ! Et la prochaine entrez un entier !")
        os.Exit(2)
    }

    fmt.Print("Entrez votre prenom : ")
    scanner.Scan()
    prenom := scanner.Text()

    /*
        On a besoin de changer la graine (générateur de nombres pseudo-aléatoires) à 
        chaque exécution de programmation sinon on obtiendra le même nombre aléatoire
    */
    rand.Seed(time.Now().UnixNano())
    radomInt := rand.Intn(2) // retourne aléatoirement soit 1 soit 0
    radomInt2 := rand.Intn(2)

    if age < 18 {
        fmt.Println("Sortez !")
    } else if prenom == "Hatim" || prenom == "hatim" {
        fmt.Println("Ah c'est toi Hatim, dehors !")
    } else if age == 18 && radomInt == 1 { // si le client est chanceux et qu'il a 18 ans
        fmt.Println("Hum vous avez de la chance je suis de bonne humeur, entrez !")
    } else if radomInt2 == 0 {
        fmt.Println("Vous n'avez vraiment pas de chance sortez !")
    } else {
        fmt.Println("Entrez :)")
    }

}

Résultat :

Entrez votre age : 16
Sortez !

Entrez votre age : 19
Entrez votre prenom : Hatim
Ah c'est toi Hatim, dehors !

Entrez votre age : 18
Entrez votre prenom : Fred
Hum vous avez de la chance je suis de bonne humeur, entrez !

Entrez votre age : 18
Entrez votre prenom : Alex
Vous n'avez vraiment pas de chance sortez !

switch, case

Une instruction switch permet de tester l'égalité d'une variable par rapport à une liste de valeurs (idéal pour le choix dans un menu !).

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    fmt.Print("Votre choix : ")
    scanner.Scan()
    choix, err := strconv.Atoi(scanner.Text())
    if err != nil {
        fmt.Println("Entrez un entier !")
        os.Exit(2)
    }

    switch choix { // la variable qu'on souhaite vérifier
        case 0, 1: // 1 ou 0
            println("George Boole !")
        case 7:
            println("William Van de Walle!")
        case 23:
            println("Pour certains, le nombre 23 est source de nombreux mystères, qu'en penses-tu Jim Carrey?")
        case 42:
            println("la réponse à la question ultime du sens de la vie!")
        case 666:
            println("Quand le diable veut une âme, le mal devient séduisant.")
        default:
            println("Mauvais choix !") // Valeur par défaut
    }
}

le mot-clé default correspond au choix par défaut comme le mot-clé else.

Résultat :

Votre choix : 666
Quand le diable veut une âme, le mal devient séduisant

Votre choix : 7
William Van de Walle!

Votre choix : 1
George Boole !

Votre choix : 0
George Boole !

Votre choix : 50
Mauvais choix !

Voici un autre exemple qui nous permet de savoir si on est en week-end ou pas, dans cet exemple nous utiliserons les fonctions Now().Weekday() de la bibliothèque time :

package main

import (
    "fmt"
    "time"
)

func main() {
    switch time.Now().Weekday() {
    case time.Saturday:
        fmt.Println("Il est samedi")
    case time.Sunday:
        fmt.Println("Il est dimanche")
    default:
        fmt.Println("au boulot ! Le week-end est fini")
    }
}

Le switch dur à cuire

Sur d'autres langages de programmation il n'est pas toujours toléré d'utiliser des opérateurs logiques ou des opérateurs de conditions dans votre instruction switch. Sur Go s'est toléré, mais dans ce cas il ne faut pas rajouter votre variable après votre mot-clé switch (d'ailleurs vous être libre de vérifier n'importe quoi vu que le switch ne se base plus sur une variable).

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "time"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    fmt.Print("Votre choix : ")
    scanner.Scan()
    choix, err := strconv.Atoi(scanner.Text())
    if err != nil {
        fmt.Println("Entrez un entier !")
        os.Exit(2)
    }

    switch {
    case choix >= 2000:
        println("Ah un 2000 !")
    case choix >= 1939 && choix <= 1945:
        println("Triste année")
    case time.Now().Weekday() == time.Sunday:
        println("Dimanche !")
    default:
        println("Mauvais choix !") // Valeur par défaut
    }
}

Votre choix : 2000
Ah un 2000 !

Votre choix : 1942
Triste année

Votre choix : 0
Mauvais choix !