Swift Language
villkors

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


Introduktion

Villkorliga uttryck, som involverar nyckelord som om, annars om och annat, ger Swift-program möjlighet att utföra olika åtgärder beroende på ett booleskt tillstånd: Sant eller falskt. Detta avsnitt behandlar användningen av snabba konditionstjänster, booleska logik och ternära uttalanden.

Anmärkningar

Mer information om villkorade uttalanden finns i The Swift Programming Language .

Med hjälp av Guard

2,0

Vakten kontrollerar om ett tillstånd är, och om det är falskt kommer det in i grenen. Vaktkontrollfilialer måste lämna sitt slutna block antingen via return , break eller continue (om tillämpligt); om du inte gör det resulterar det i ett kompileringsfel. Detta har fördelen att när en guard skrivs är det inte möjligt att låta flödet fortsätta av misstag (som skulle vara möjligt med en if ).

Att använda vakter kan hjälpa till att hålla häckningsnivåerna låga , vilket vanligtvis förbättrar kodens läsbarhet. 

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

Guard kan också kontrollera om det finns ett värde i ett valfritt och sedan ta bort det i det yttre omfånget: 

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

Guard kan kombinera valfri uppackning och tillstånd kontroll med hjälp av where sökord: 

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

Grundläggande villkor: if-uttalanden

Ett if uttalande kontrollerar om ett Bool- tillstånd är 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 uttalanden accepterar else if och else blockerar, vilket kan testa alternativa förhållanden och ge en återgång: 

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

Grundläggande operatörer som && och || kan användas för flera villkor:

Den logiska OCH operatören 

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

Om num == 10 var falskt skulle det andra värdet inte utvärderas. Detta kallas kortslutningsutvärdering.

Den logiska ELLER-operatören 

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

Om num == 10 är sant, skulle det andra värdet inte utvärderas.

Den logiska INTE operatören 

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

Valfri bindning och "var" -klausuler

Tillval måste packas upp innan de kan användas i de flesta uttryck. if let är en valfri bindning , som lyckas om valfritt värde inte var 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")
}

Du kan återanvända samma namn för den nyligen bundna variabeln och skugga originalet: 

// num originally has type Int?
if let num = num {
    // num has type Int inside this block
}
1,2 3,0

Kombinera flera valbara bindningar med komma ( , ): 

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
}

Tillämpa ytterligare begränsningar efter valfri bindning med en where klausul: 

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

Om du känner dig äventyrlig, läs in ett antal valfria bindningar och where avsnitt: 

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

I Swift 3, where klausuler har ersatts ( SE-0099 ): helt enkelt använda en annan , för att separera valfria bindningar och booleska förhållanden. 

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 operatör

Förhållandena kan också utvärderas på en enda rad med den ternära operatören:

Om du ville bestämma minsta och högsta av två variabler, kan du använda om uttalanden, som så: 

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 
}

Den ternära villkorade operatören tar ett villkor och returnerar ett av två värden, beroende på om villkoret var sant eller felaktigt. Syntaxen är som följer: Detta motsvarar uttrycket: 

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

Ovanstående kod kan skrivas om med hjälp av ternary villkorad operatör enligt nedan: 

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

I det första exemplet är villkoret a <b. Om detta är sant kommer resultatet som tilldelas tillbaka till min vara av; om det är falskt blir resultatet värdet på b.

Obs: Eftersom det är en så vanlig operation att hitta det större eller mindre av två siffror, tillhandahåller Swift-standardbiblioteket två funktioner för detta ändamål: max och min.

Nil-Coalescing-operatör

Den nollkoalescerande operatören <OPTIONAL> ?? <DEFAULT VALUE> avbryter <OPTIONAL> om det innehåller ett värde, eller returnerar <DEFAULT VALUE> om det är noll. <OPTIONAL> är alltid av valfri typ. <DEFAULT VALUE> måste matcha den typ som är lagrad i <OPTIONAL> .

Den nollkoalescerande operatören är kortfattad för koden nedan som använder en ternär operatör: 

a != nil ? a! : b

detta kan verifieras med koden nedan: 

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

Tid för ett exempel 

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
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow