1 Aperçu des Instructions Conditionnelles
Les instructions conditionnelles sont des outils importants pour contrôler le flux logique des programmes en programmation. En Golang, les instructions conditionnelles sont similaires à celles d'autres langages de programmation, mais elles ont leurs propres caractéristiques. Elles nous permettent de décider quel code exécuter en fonction des conditions vraies ou fausses, augmentant ainsi considérablement la flexibilité et la maintenabilité du code.
2 Instruction if
2.1 Utilisation de base de l'instruction if
L'instruction if est l'instruction conditionnelle la plus fondamentale dans le langage Go. Sa syntaxe est la suivante:
if condition {
// Code à exécuter lorsque la condition est vraie
}
Voici un exemple simple:
package main
import "fmt"
func main() {
x := 10
if x > 5 {
fmt.Println("x est supérieur à 5")
}
}
Ce code vérifiera si x est supérieur à 5, et si c'est le cas, il effectuera l'opération d'affichage.
2.2 Expressions Conditionnelles
Les expressions conditionnelles se composent d'opérateurs de comparaison (tels que ==, !=, <, >, <=, >=) et d'opérateurs logiques (tels que && (ET), || (OU), ! (NON)).
Par exemple, pour vérifier si une variable est dans une certaine plage :
y := 20
if y >= 10 && y <= 30 {
fmt.Println("y est entre 10 et 30")
}
L'expression conditionnelle ci-dessus utilise l'opérateur logique && pour s'assurer que la valeur de y est comprise entre 10 et 30.
2.3 Structure if...else et else if
Lorsque la condition if n'est pas remplie, nous pouvons utiliser else pour exécuter un bloc de code alternatif. Le else if nous permet de vérifier plusieurs conditions. Voici un exemple :
score := 88
if score >= 90 {
fmt.Println("Excellent")
} else if score >= 80 {
fmt.Println("Bien")
} else if score >= 70 {
fmt.Println("Moyen")
} else {
fmt.Println("Sous la moyenne")
}
Ce code affichera différentes évaluations en fonction de la valeur de score.
3 Instruction switch
3.1 Syntaxe de base du switch
L'instruction switch est une instruction de branchement conditionnel plus concise, particulièrement adaptée aux situations où plusieurs valeurs doivent être évaluées. La syntaxe de base de l'instruction switch est la suivante :
switch expression {
case valeur1:
// Code à exécuter lors de la correspondance avec valeur1
case valeur2:
// Code à exécuter lors de la correspondance avec valeur2
default:
// Code à exécuter par défaut
}
Si la valeur de expression correspond à la valeur suivant case, le bloc de code respectif sera exécuté.
3.2 Chute à travers du switch
Dans l'instruction switch de Go, chaque branche ne passe pas automatiquement au cas suivant à moins que le mot-clé fallthrough ne soit utilisé.
switch num {
case 1:
fmt.Println("Un")
fallthrough
case 2:
fmt.Println("Deux")
default:
fmt.Println("Ni Un ni Deux")
}
Dans le code ci-dessus, si num vaut 1, même s'il correspond à case 1, en raison de la présence du mot-clé fallthrough, le programme continuera à exécuter le code dans case 2 et affichera "Deux".
3.3 Branchement de Type et Branchement Personnalisé
L'instruction switch prend également en charge le branchement basé sur les types de variables, appelé branchement de type. De plus, nous pouvons créer des conditions de branchement personnalisées plus complexes.
Exemple de branchement de type :
var i interface{} = 1
switch i.(type) {
case int:
fmt.Println("i est un entier")
case float64:
fmt.Println("i est un float64")
default:
fmt.Println("i est un autre type")
}
Des conditions de branchement personnalisées peuvent être écrites pour effectuer des jugements conditionnels plus complexes au besoin.
4 Exercice Pratique
Dans cette section, nous approfondirons notre compréhension et notre application des instructions conditionnelles en Golang à travers des exemples concrets. À travers des défis de programmation pratiques, vous deviendrez plus compétent dans l'utilisation des instructions if et switch pour résoudre des problèmes du monde réel.
Calculateur de notes
Écrivons un calculateur de notes simple. Ce programme déterminera et affichera la note correspondante en fonction du score saisi par l'utilisateur. Les critères de notation sont les suivants :
- A pour les scores de 90 et plus
- B pour les scores entre 80 et 89
- C pour les scores entre 70 et 79
- D pour les scores entre 60 et 69
- F pour les scores inférieurs à 60
Nous pouvons utiliser une déclaration if ou une instruction switch pour mettre en œuvre cette fonctionnalité. Tout d'abord, examinons un exemple en utilisant une déclaration if :
package main
import (
"fmt"
)
func main() {
var score int
fmt.Print("Veuillez saisir le score : ")
fmt.Scan(&score)
if score >= 90 {
fmt.Println("Note : A")
} else if score >= 80 {
fmt.Println("Note : B")
} else if score >= 70 {
fmt.Println("Note : C")
} else if score >= 60 {
fmt.Println("Note : D")
} else {
fmt.Println("Note : F")
}
}
Dans ce code, nous déclarons d'abord une variable score pour stocker le score saisi par l'utilisateur. Nous utilisons la fonction fmt.Scan pour obtenir la saisie de l'utilisateur. Ensuite, nous utilisons plusieurs déclarations if et else if pour déterminer la note correspondante au score et utilisons la fonction fmt.Println pour afficher la note.
Ensuite, regardons un exemple en utilisant une instruction switch :
package main
import (
"fmt"
)
func main() {
var score int
fmt.Print("Veuillez saisir le score : ")
fmt.Scan(&score)
switch {
case score >= 90:
fmt.Println("Note : A")
case score >= 80:
fmt.Println("Note : B")
case score >= 70:
fmt.Println("Note : C")
case score >= 60:
fmt.Println("Note : D")
default:
fmt.Println("Note : F")
}
}
Dans l'exemple utilisant l'instruction switch, la structure du code est plus concise et claire. Nous n'avons pas besoin d'utiliser de nombreuses déclarations if et else if consécutives ; au lieu de cela, nous spécifions directement les conditions dans chaque case après le switch. Le score qui ne correspond pas à la condition du case précédent se déplacera automatiquement vers le case suivant jusqu'à ce qu'il corresponde à la branche conditionnelle correspondante ou atteigne le default, qui affiche la note F.
Maintenant que vous avez appris à utiliser les if et les switch pour les jugements conditionnels, essayez d'écrire votre propre programme et pratiquez pour approfondir votre compréhension.
Dans la section suivante, nous continuerons à présenter des problèmes plus pratiques pour vous aider à consolider votre maîtrise des instructions conditionnelles en Golang.
Veuillez noter que le code ci-dessus est à des fins pédagogiques. Lorsqu'il est utilisé dans des applications pratiques, des facteurs tels que l'interaction utilisateur et la gestion des erreurs devraient être pris en compte pour le rendre plus robuste.