TOC

Comment écrire des instructions conditionnelles dans Go

introduction

Les instructions conditionnelles font partie de tous les langages de programmation. Avec les instructions conditionnelles, nous pouvons avoir du code qui s’exécute parfois et d’autres fois, en fonction des conditions du programme à ce moment-là.

Lorsque nous exécutons complètement chaque déclaration d’un programme, nous ne demandons pas au programme d’évaluer des conditions spécifiques. En utilisant des instructions conditionnelles, les programmes peuvent déterminer si certaines conditions sont remplies, puis se faire dire quoi faire.

Voyons quelques exemples où nous utiliserions des instructions conditionnelles:

  • Si l’étudiante reçoit plus de 65% de son test, indiquez que sa note a réussi; sinon, signaler que sa note échoue.

  • S’il a de l’argent sur son compte, calculez les intérêts; s’il ne le fait pas, facturez une pénalité.

  • S’ils achètent 10 oranges ou plus, calculez un rabais de 5%; s’ils achètent moins, ne le faites pas.

En évaluant les conditions et en affectant le code à exécuter en fonction du respect de ces conditions, nous écrivons du code conditionnel.

Ce tutoriel vous guidera dans la rédaction d’instructions conditionnelles dans le langage de programmation Go.

Si les déclarations

Nous allons commencer par l’instruction + if +, qui évaluera si une instruction est vraie ou fausse, et n’exécuterons le code que dans le cas où elle serait vraie.

Dans un éditeur de texte brut, ouvrez un fichier et écrivez le code suivant:

grade.go

package main

import "fmt"

func main() {
   grade := 70

   if grade >= 65 {
       fmt.Println("Passing grade")
   }
}

Avec ce code, nous avons la variable + grade + et lui donnons la valeur entière de + 70 +. Nous utilisons ensuite l’instruction + if + pour évaluer si la note de la variable est supérieure ou égale (+> = +) à + ​​65 +. Si cette condition est remplie, nous demandons au programme d’imprimer la string `+ Note de passage + `.

Enregistrez le programme en tant que + grade.go + et exécutez-le dans un https://www.digitalocean.com/community/tutorial_series/how-to-install-and-set-up-a-local-programming-environment-for -go [environnement de programmation local depuis une fenêtre de terminal] avec la commande + go run grade.go +.

Dans ce cas, la note de 70 does satisfait à la condition d’être supérieure ou égale à 65. Vous recevrez donc le résultat suivant une fois que vous avez exécuté le programme:

OutputPassing grade

Modifions maintenant le résultat de ce programme en modifiant la valeur de la variable + grade + en + 60 +:

grade.go

package main

import "fmt"

func main() {
   grade :=

   if grade >= 65 {
       fmt.Println("Passing grade")
   }
}

Lorsque nous sauvegardons et exécutons this code, nous ne recevrons aucune sortie car la condition était not et nous n’avons pas indiqué au programme d’exécuter une autre instruction.

Pour donner un autre exemple, calculons si le solde d’un compte bancaire est inférieur à 0. Créons un fichier nommé + account.go + et écrivons le programme suivant:

compte.go

package main

import "fmt"

func main() {
   balance := -5

   if balance < 0 {
       fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
   }
}

Lorsque nous exécutons le programme avec + go run account.go +, nous recevrons le résultat suivant:

OutputBalance is below 0, add funds now or you will be charged a penalty.

Dans le programme, nous avons initialisé la variable + balance + avec la valeur + -5 +, qui est inférieure à 0. Etant donné que la balance remplissait les conditions de l’instruction + if + (+ balance <0 +), une fois que nous avons enregistré et exécuté le code, nous recevrons la sortie de chaîne. De nouveau, si nous modifions la balance en 0 ou en un nombre positif, nous ne recevrons aucune sortie.

Autres déclarations

Il est probable que nous voudrons que le programme fasse quelque chose même lorsqu’une instruction + if + est évaluée à false. Dans notre exemple de note, nous voudrons une sortie si la note est réussie ou non.

Pour ce faire, nous allons ajouter une instruction + else + à la condition de niveau ci-dessus construite comme suit:

grade.go

package main

import "fmt"

func main() {
   grade := 60

   if grade >= 65 {
       fmt.Println("Passing grade")
   } else {
       fmt.Println("Failing grade")
   }
}

Puisque la variable grade a la valeur + 60 +, l’instruction + if + est considérée comme fausse, de sorte que le programme n’imprimera pas + Passing grade +. L’instruction + else + qui suit indique au programme de faire quoi que ce soit.

Lorsque nous enregistrons et exécutons le programme, nous recevons le résultat suivant:

OutputFailing grade

Si nous réécrivons ensuite le programme pour attribuer à la note une valeur égale ou supérieure à + 65 , nous obtiendrons le résultat ` Note de passage +`.

Pour ajouter une instruction + else + à l’exemple de compte bancaire, nous réécrivons le code comme suit:

compte.go

package main

import "fmt"

func main() {
   balance := 522

   if balance < 0 {
       fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
   } else {
       fmt.Println("Your balance is 0 or above.")
   }
}
OutputYour balance is 0 or above.

Ici, nous avons changé la valeur de la variable + balance + en un nombre positif afin que l’instruction + else + soit imprimée. Pour obtenir la première instruction + if + à imprimer, nous pouvons réécrire la valeur en un nombre négatif.

En combinant une instruction + if + avec une instruction + else +, vous construisez une instruction conditionnelle en deux parties qui indiquera à l’ordinateur d’exécuter certains codes si la condition + if + est remplie ou non.

Autrement si les déclarations

Jusqu’à présent, nous avons présenté une option Boolean pour les instructions conditionnelles, chaque instruction + if + donnant la valeur true ou faux. Dans de nombreux cas, nous voudrons un programme qui évalue plus de deux résultats possibles. Pour cela, nous allons utiliser une instruction * else if *, qui est écrite dans Go comme + else if +. L’instruction + else if + 'ou bien if si ressemble à l’instruction + if + `et évaluera une autre condition.

Dans le programme de compte bancaire, nous pouvons souhaiter avoir trois sorties discrètes pour trois situations différentes:

  • Le solde est inférieur à 0

  • Le solde est égal à 0

  • Le solde est supérieur à 0

L’instruction + else if + sera placée entre l’instruction + if + et l’instruction + else + comme suit:

compte.go

package main

import "fmt"

func main() {
   balance := 522

   if balance < 0 {
       fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
   } else if balance == 0 {
       fmt.Println("Balance is equal to 0, add funds soon.")
   } else {
       fmt.Println("Your balance is 0 or above.")
   }
}

Maintenant, il y a trois sorties possibles qui peuvent se produire une fois que nous exécutons le programme:

  • Si la variable + balance + est égale à + ​​0 + nous recevrons le résultat de l’instruction + else if + (+ Balance est égal à 0, ajoutez des fonds bientôt. +)

  • Si la variable + balance + est définie sur un nombre positif, nous recevrons le résultat de l’instruction + else + (+ votre solde est égal à 0 ou supérieur. +).

  • Si la variable + balance + est définie sur un nombre négatif, le résultat sera la chaîne de l’instruction + if + (+ solde est inférieur à 0, ajoutez des fonds maintenant ou une pénalité + vous sera facturée).

Et si nous voulons avoir plus de trois possibilités, cependant? Nous pouvons le faire en écrivant plus d’une déclaration + else if + dans notre code.

Dans le programme + grade.go +, réécrivons le code de manière à ce qu’il existe quelques notes correspondant à des plages de notes numériques:

  • 90 ou plus est équivalent à une note

  • 80-89 équivaut à une note B

  • 70-79 équivaut à une note C

  • 65-69 équivaut à une note D

  • 64 ou moins équivaut à une note F

Pour exécuter ce code, nous aurons besoin d’une instruction + if +, de trois instructions + else if + et d’une instruction + else + qui gérera tous les cas d’échec.

Réécrivons le code de l’exemple précédent pour que les chaînes impriment chacune des notes. Nous pouvons garder notre déclaration + else + identique.

grade.go

package main

import "fmt"

func main() {
   grade := 60

   if grade >= 90 {
       fmt.Println("A grade")
   } else if grade >= 80 {
       fmt.Println("B grade")
   } else if grade >= 70 {
       fmt.Println("C grade")
   } else if grade >= 65 {
       fmt.Println("D grade")
   } else {
       fmt.Println("Failing grade")
   }
}

Etant donné que les déclarations `+ else if + 'seront évaluées dans l’ordre, nous pouvons garder nos déclarations assez basiques. Ce programme effectue les étapes suivantes:

  1. Si la note est supérieure à 90, le programme affichera + A note +, si la note est inférieure à 90, le programme continuera jusqu’au prochain énoncé…

  2. Si la note est supérieure ou égale à 80, le programme affichera `+ B + +, si la note est de 79 ou moins, le programme continuera jusqu’au prochain énoncé…

  3. Si la note est supérieure ou égale à 70, le programme affichera + C + +, si la note est égale ou inférieure à 69, le programme continuera jusqu’au prochain énoncé…

  4. Si la note est supérieure ou égale à 65, le programme affichera + D note +, si la note est de 64 ou moins, le programme continuera jusqu’au prochain énoncé…

  5. Le programme affichera + Niveau d’échec + car toutes les conditions ci-dessus n’ont pas été remplies.

Déclarations imbriquées

Une fois que vous vous sentez à l’aise avec les instructions + if,` + else if` et + else, vous pouvez passer aux instructions conditionnelles imbriquées. Nous pouvons utiliser des instructions if si imbriquées pour les situations dans lesquelles nous souhaitons rechercher une condition secondaire si la première condition est exécutée comme étant vraie. Pour cela, nous pouvons avoir une déclaration if-else à l’intérieur d’une autre déclaration if-else. Examinons la syntaxe d’une instruction imbriquée + if +:

if statement1 { // outer if statement
   fmt.Println("true")

   if nested_statement { // nested if statement
       fmt.Println("yes")
   } else { // nested else statement
       fmt.Println("no")
   }

} else { // outer else statement
   fmt.Println("false")
}

Quelques sorties possibles peuvent résulter de ce code:

  • Si + statement1 + est évalué à true, le programme déterminera ensuite si le + nested_statement + est également évalué à true. Si les deux cas sont vrais, le résultat sera:

_ _

Outputtrue
yes

_ _

  • Si, toutefois, + statement1 + est évalué à true, mais que + + nested_statement + `est évalué à false, alors le résultat sera:

_ _

Outputtrue
no

_ _

  • Et si + statement1 + est évalué à false, l’instruction imbriquée if-else ne s’exécutera pas. Par conséquent, l’instruction + else + s’exécutera seule et le résultat sera le suivant:

_ _

Outputfalse

_ _

Nous pouvons également avoir plusieurs instructions + if + imbriquées dans notre code:

if statement1 { // outer if
   fmt.Println("hello world")

   if nested_statement1 { // first nested if
       fmt.Println("yes")

   } else if nested_statement2 { // first nested else if
       fmt.Println("maybe")

   } else { // first nested else
       fmt.Println("no")
   }

} else if statement2 { // outer else if
   fmt.Println("hello galaxy")

   if nested_statement3 { // second nested if
       fmt.Println("yes")
   } else if nested_statement4 { // second nested else if
       fmt.Println("maybe")
   } else { // second nested else
       fmt.Println("no")
   }

} else { // outer else
   statement("hello universe")
}

Dans ce code, il existe une instruction + if imbriquée dans chaque instruction` + if` en plus de l’instruction + else if +. Cela permettra plus d’options dans chaque condition.

Voyons un exemple d’instructions + if + imbriquées avec notre programme + grade.go +. Nous pouvons vérifier si une note passe en premier (supérieure ou égale à 65%), puis évaluer à quelle lettre correspond la note numérique. Si la note ne passe pas, cependant, nous n’avons pas besoin de parcourir les notes en lettres, nous pouvons plutôt demander au programme de signaler que la note échoue. Notre code modifié avec l’instruction + if + imbriquée ressemblera à ceci:

grade.go

package main

import "fmt"

func main() {
   grade := 92
   if grade >= 65 {
       fmt.Print("Passing grade of: ")

       if grade >= 90 {
           fmt.Println("A")

       } else if grade >= 80 {
           fmt.Println("B")

       } else if grade >= 70 {
           fmt.Println("C")

       } else if grade >= 65 {
           fmt.Println("D")
       }

   } else {
       fmt.Println("Failing grade")
   }
}

Si nous exécutons le code avec la variable + grade + définie sur la valeur entière + 92 +, la première condition est remplie et le programme affichera + Note de passage de: +. Ensuite, il vérifiera si la note est supérieure ou égale à 90 et, puisque cette condition est également remplie, il affichera + A +.

Si nous exécutons le code avec la variable + grade + définie sur + 60 +, alors la première condition n’est pas remplie, le programme ignorera donc les instructions if si + imbriquées et passera à l’instruction + else + , avec le programme imprimant + Failing grade +.

Nous pouvons bien sûr ajouter encore plus d’options à cela et utiliser une deuxième couche d’instructions if imbriquées. Peut-être voudrons-nous évaluer séparément les notes A +, A et A-. Nous pouvons le faire en vérifiant d’abord si la note est bonne, puis en vérifiant si la note est égale ou supérieure à 90, puis en vérifiant si la note est supérieure à 96 pour un A +:

grade.go

...
if grade >= 65 {
   fmt.Print("Passing grade of: ")

   if grade >= 90 {
       if grade > 96 {
           fmt.Println("A+")

       } else if grade > 93 && grade <= 96 {
           fmt.Println("A")

       } else {
           fmt.Println("A-")
       }
...

Dans ce code, pour une variable + grade + définie sur + 96 +, le programme s’exécutera comme suit:

  1. Vérifier si la note est supérieure ou égale à 65 (vrai)

  2. Imprimer + note de passage de: +

  3. Vérifiez si la note est supérieure ou égale à 90 (vrai)

  4. Vérifier si la note est supérieure à 96 (faux)

  5. Vérifiez si la note est supérieure à 93 et ​​également inférieure ou égale à 96 (vrai)

  6. Imprimer + A +

  7. Laissez ces instructions conditionnelles imbriquées et continuez avec le code restant

Le résultat du programme pour une note de 96 ressemble donc à ceci:

OutputPassing grade of: A

Les instructions + if + imbriquées peuvent fournir la possibilité d’ajouter plusieurs niveaux de conditions spécifiques à votre code.

Conclusion

En utilisant des instructions conditionnelles telles que + if +, vous aurez un meilleur contrôle sur ce que votre programme exécute. Les instructions conditionnelles indiquent au programme d’évaluer si une condition donnée est remplie. Si la condition est remplie, il exécutera un code spécifique, mais s’il ne l’est pas, le programme continuera à descendre vers un autre code.

Pour continuer à pratiquer les instructions conditionnelles, essayez d’utiliser différents opérateurs afin de vous familiariser davantage avec les instructions conditionnelles.

Related