Swift Language
Conditionnels

C Language firebase HTML iOS Java Language JavaScript Node.js Objective-C Language PHP Regular Expressions
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

2.0

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
}
1,2 3,0

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!
}
3.0

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