Swift Language
Voorwaardelijke

C Language firebase HTML iOS Java Language JavaScript Node.js Objective-C Language PHP Regular Expressions
Zoeken…


Invoering

Voorwaardelijke uitdrukkingen, met trefwoorden zoals if, else if en else, bieden Swift-programma's de mogelijkheid om verschillende acties uit te voeren, afhankelijk van een Booleaanse conditie: waar of niet waar. In deze sectie wordt het gebruik van Swift-conditionals, Booleaanse logica en ternaire verklaringen behandeld.

Opmerkingen

Zie De snelle programmeertaal voor meer informatie over voorwaardelijke uitspraken.

Guard gebruiken

2.0

Bewaker controleert op een voorwaarde en als deze onwaar is, komt deze de vertakking binnen. Bewakingscontroletakken moeten het omringende blok verlaten via return , break of continue (indien van toepassing); Als u dit niet doet, resulteert dit in een compilerfout. Dit heeft het voordeel dat wanneer een guard wordt geschreven, het niet mogelijk is om de stroom per ongeluk te laten doorgaan (zoals mogelijk zou zijn met een if ).

Het gebruik van bewakers kan het nestniveau laag houden , wat meestal de leesbaarheid van de code verbetert. 

func printNum(num: Int) {
    guard num == 10 else {
        print("num is not 10")
        return
    }
    print("num is 10")
}

Guard kan ook controleren of er een waarde in een optioneel is en deze vervolgens uitpakken in de buitenste scope: 

func printOptionalNum(num: Int?) {
    guard let unwrappedNum = num else {
        print("num does not exist")
        return
    }
    print(unwrappedNum)
}

Guard kan combineren optionele uitpakken en conditie check gebruik where trefwoord: 

func printOptionalNum(num: Int?) {
guard let unwrappedNum = num, unwrappedNum == 10 else {
    print("num does not exist or is not 10")
    return
}
print(unwrappedNum)
}

Basisvoorwaarden: if-statements

Een if instructie controleert of een Bool- voorwaarde 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 instructies else if en else blokken accepteren, die alternatieve omstandigheden kunnen testen en een fallback kunnen bieden: 

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")
}

Basisoperatoren zoals && en || kan worden gebruikt voor meerdere voorwaarden:

De logische AND-operator 

let num = 10
let str = "Hi"
if num == 10 && str == "Hi" {
    print("num is 10, AND str is \"Hi\"")
}

Als num == 10 onwaar was, zou de tweede waarde niet worden geëvalueerd. Dit staat bekend als kortsluitevaluatie.

De logische OK-operator 

if num == 10 || str == "Hi" {
    print("num is 10, or str is \"Hi\")
}

Als num == 10 waar is, wordt de tweede waarde niet geëvalueerd.

De logische NIET-operator 

if !str.isEmpty {
    print("str is not empty")
}

Optionele binding en "waar" -clausules

Optionals moeten worden uitgepakt voordat ze in de meeste expressies kunnen worden gebruikt. if let een optionele binding is , wat lukt als de optionele waarde niet 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")
}

U kunt dezelfde naam opnieuw gebruiken voor de nieuw gebonden variabele en het origineel overschaduwen: 

// num originally has type Int?
if let num = num {
    // num has type Int inside this block
}
1.2 3.0

Combineer meerdere optionele bindingen met komma's ( , ): 

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
}

Pas verdere beperkingen toe na de optionele binding met een where clausule: 

if let unwrappedNum = num where unwrappedNum % 2 == 0 {
    print("num is non-nil, and it's an even number")
}

Als je je avontuurlijk voelt, gebruik dan een willekeurig aantal optionele bindingen en where clausules: 

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

In Swift 3, where clausules zijn vervangen ( SE-0099 ): gewoon gebruik maken van een andere , optionele bindingen en boolean omstandigheden te scheiden. 

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

Ternary operator

Voorwaarden kunnen ook worden geëvalueerd in een enkele regel met behulp van de ternaire operator:

Als u het minimum en maximum van twee variabelen wilt bepalen, kunt u if-statements als volgt gebruiken: 

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 
}

De ternaire voorwaardelijke operator neemt een voorwaarde aan en retourneert een van twee waarden, afhankelijk van of de voorwaarde waar of onwaar was. De syntaxis is als volgt: Dit komt overeen met de uitdrukking: 

(<CONDITION>) ? <TRUE VALUE> : <FALSE VALUE>

De bovenstaande code kan worden herschreven met de ternaire voorwaardelijke operator zoals hieronder: 

let a = 5
let b = 10
let min = a < b ? a : b
let max = a > b ? a : b

In het eerste voorbeeld is de voorwaarde a <b. Als dit waar is, is het resultaat dat terug is toegewezen aan min van a; als het onwaar is, is het resultaat de waarde van b.

Opmerking: Omdat het vinden van de grotere of kleinere van twee getallen zo'n veel voorkomende bewerking is, biedt de standaard Swift-bibliotheek twee functies voor dit doel: max en min.

Nul-coalescerende operator

De nul-coalescerende operator <OPTIONAL> ?? <DEFAULT VALUE> haalt het <OPTIONAL> als het een waarde bevat of retourneert <DEFAULT VALUE> als nul is. <OPTIONAL> is altijd van een optioneel type. <DEFAULT VALUE> moet overeenkomen met het type dat is opgeslagen in <OPTIONAL> .

De nul-coalescerende operator is steno voor de onderstaande code die een ternaire operator gebruikt: 

a != nil ? a! : b

dit kan worden geverifieerd door de onderstaande code: 

(a ?? b) == (a != nil ? a! : b) // ouputs true

Tijd voor een voorbeeld 

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
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow