Swift Language
Conditionnels
Recherche…
Introduction
Les expressions conditionnelles, impliquant des mots clés tels que if, else if et else, permettent aux programmes Swift d'effectuer différentes actions en fonction d'une condition booléenne: True ou False. Cette section traite de l'utilisation des conditionnels Swift, de la logique booléenne et des instructions ternaires.
Remarques
Pour plus d'informations sur les instructions conditionnelles, voir Le langage de programmation Swift .
Utiliser la garde
La garde vérifie une condition et si elle est fausse, elle pénètre dans la branche. Les agences de contrôle de garde doivent quitter leur bloc fermé soit par return , soit par break , soit par continue (le cas échéant); Si vous ne le faites pas, cela entraîne une erreur de compilation. Cela a l'avantage que lorsqu'un guard est écrit, il n'est pas possible de laisser le flux continuer accidentellement (comme cela serait possible avec un if ).
L'utilisation de gardes peut aider à réduire les niveaux d'imbrication , ce qui améliore généralement la lisibilité du code.
func printNum(num: Int) {
guard num == 10 else {
print("num is not 10")
return
}
print("num is 10")
}
Guard peut également vérifier s'il existe une valeur dans une option , puis la dérouler dans la portée externe:
func printOptionalNum(num: Int?) {
guard let unwrappedNum = num else {
print("num does not exist")
return
}
print(unwrappedNum)
}
Guard peut combiner un désemballage et une vérification de condition en utilisant where mot-clé:
func printOptionalNum(num: Int?) {
guard let unwrappedNum = num, unwrappedNum == 10 else {
print("num does not exist or is not 10")
return
}
print(unwrappedNum)
}
Conditions élémentaires: instructions if
Une instruction if vérifie si une condition Bool est true :
let num = 10
if num == 10 {
// Code inside this block only executes if the condition was true.
print("num is 10")
}
let condition = num == 10 // condition's type is Bool
if condition {
print("num is 10")
}
if instructions acceptent else if et else bloque, ce qui permet de tester des conditions alternatives et de fournir un repli:
let num = 10
if num < 10 { // Execute the following code if the first condition is true.
print("num is less than 10")
} else if num == 10 { // Or, if not, check the next condition...
print("num is 10")
} else { // If all else fails...
print("all other conditions were false, so num is greater than 10")
}
Opérateurs de base comme && et || peut être utilisé pour plusieurs conditions:
L'opérateur logique
let num = 10
let str = "Hi"
if num == 10 && str == "Hi" {
print("num is 10, AND str is \"Hi\"")
}
Si num == 10 était faux, la deuxième valeur ne serait pas évaluée. Cela s'appelle l'évaluation des courts-circuits.
L'opérateur logique OU
if num == 10 || str == "Hi" {
print("num is 10, or str is \"Hi\")
}
Si num == 10 est vrai, la seconde valeur ne sera pas évaluée.
L'opérateur logique NOT
if !str.isEmpty {
print("str is not empty")
}
Liaison facultative et clauses "where"
Les options doivent être déballées avant de pouvoir être utilisées dans la plupart des expressions. if let est une liaison facultative , qui réussit si la valeur facultative n'était pas nil :
let num: Int? = 10 // or: let num: Int? = nil
if let unwrappedNum = num {
// num has type Int?; unwrappedNum has type Int
print("num was not nil: \(unwrappedNum + 1)")
} else {
print("num was nil")
}
Vous pouvez réutiliser le même nom pour la variable nouvellement liée, en masquant l'original:
// num originally has type Int?
if let num = num {
// num has type Int inside this block
}
Combinez plusieurs liaisons facultatives avec des virgules ( , ):
if let unwrappedNum = num, let unwrappedStr = str {
// Do something with unwrappedNum & unwrappedStr
} else if let unwrappedNum = num {
// Do something with unwrappedNum
} else {
// num was nil
}
Appliquez d'autres contraintes après la liaison facultative en utilisant une clause where :
if let unwrappedNum = num where unwrappedNum % 2 == 0 {
print("num is non-nil, and it's an even number")
} Si vous vous sentez aventureux, entrelacez un nombre quelconque de liaisons optionnelles et de clauses where :
if let num = num // num must be non-nil
where num % 2 == 1, // num must be odd
let str = str, // str must be non-nil
let firstChar = str.characters.first // str must also be non-empty
where firstChar != "x" // the first character must not be "x"
{
// all bindings & conditions succeeded!
}
Dans Swift 3, where les clauses ont été remplacées ( SE-0099 ): il suffit d' utiliser une autre , pour séparer les liaisons optionnelles et des conditions booléennes.
if let unwrappedNum = num, unwrappedNum % 2 == 0 {
print("num is non-nil, and it's an even number")
}
if let num = num, // num must be non-nil
num % 2 == 1, // num must be odd
let str = str, // str must be non-nil
let firstChar = str.characters.first, // str must also be non-empty
firstChar != "x" // the first character must not be "x"
{
// all bindings & conditions succeeded!
} Opérateur ternaire
Les conditions peuvent également être évaluées sur une seule ligne à l'aide de l'opérateur ternaire:
Si vous souhaitez déterminer le minimum et le maximum de deux variables, vous pouvez utiliser des instructions if, comme ceci:
let a = 5
let b = 10
let min: Int
if a < b {
min = a
} else {
min = b
}
let max: Int
if a > b {
max = a
} else {
max = b
}
L'opérateur conditionnel ternaire prend une condition et renvoie l'une des deux valeurs, selon que la condition est vraie ou fausse. La syntaxe est la suivante: Cela équivaut à avoir l'expression:
(<CONDITION>) ? <TRUE VALUE> : <FALSE VALUE>
Le code ci-dessus peut être réécrit en utilisant un opérateur conditionnel ternaire comme ci-dessous:
let a = 5
let b = 10
let min = a < b ? a : b
let max = a > b ? a : b
Dans le premier exemple, la condition est un <b. Si cela est vrai, le résultat renvoyé à min sera de a; si c'est faux, le résultat sera la valeur de b.
Remarque: Comme il est courant de trouver le plus grand ou le plus petit des deux nombres, la bibliothèque standard Swift offre deux fonctions à cet effet: max et min.
Nil-Coalescing Operator
L'opérateur de coalescence nulle <OPTIONAL> ?? <DEFAULT VALUE> déballe <OPTIONAL> s'il contient une valeur ou renvoie <DEFAULT VALUE> si est nul. <OPTIONAL> est toujours d'un type facultatif. <DEFAULT VALUE> doit correspondre au type stocké dans <OPTIONAL> .
L'opérateur nuls-coalescing est un raccourci pour le code ci-dessous qui utilise un opérateur ternaire:
a != nil ? a! : b
ceci peut être vérifié par le code ci-dessous:
(a ?? b) == (a != nil ? a! : b) // ouputs true
Temps pour un exemple
let defaultSpeed:String = "Slow"
var userEnteredSpeed:String? = nil
print(userEnteredSpeed ?? defaultSpeed) // ouputs "Slow"
userEnteredSpeed = "Fast"
print(userEnteredSpeed ?? defaultSpeed) // ouputs "Fast"
Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow