Swift Language
Conditionals

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


Einführung

Bedingte Ausdrücke mit Schlüsselwörtern wie if, else if und else ermöglichen es Swift-Programmen, abhängig von einer booleschen Bedingung verschiedene Aktionen auszuführen: True oder False. In diesem Abschnitt wird die Verwendung von Swift-Bedingungen, Booleschen Logik und ternären Anweisungen beschrieben.

Bemerkungen

Weitere Informationen zu Bedingungsanweisungen finden Sie unter Die Programmiersprache Swift .

Guard verwenden

2,0

Der Guard prüft, ob eine Bedingung vorliegt, und wenn sie falsch ist, tritt sie in den Zweig ein. Guard-Check-Zweige müssen ihren Umschließungsblock entweder durch return , break oder continue (falls zutreffend) verlassen; Andernfalls führt dies zu einem Compiler-Fehler. Dies hat den Vorteil, dass es beim Schreiben einer guard nicht möglich ist, den Fluss unbeabsichtigt weiterlaufen zu lassen (wie dies bei einem if möglich if ).

Durch die Verwendung von Wachen können die Verschachtelungsstufen niedrig gehalten werden , was in der Regel die Lesbarkeit des Codes verbessert. 

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

Der Guard kann auch prüfen, ob ein optionaler Wert vorhanden ist, und ihn dann im äußeren Bereich auspacken: 

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

Guard kann kombinieren optional Abwickeln und Zustandsüberprüfung mit where Stichwort: 

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

Grundlegende Bedingungen: If-Anweisungen

Ein , if Anweisung prüft , ob eine Bool Bedingung ist 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 Anweisungen akzeptieren else if und else Blöcke, die alternative Bedingungen testen und einen Fallback bereitstellen können: 

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

Grundoperatoren wie && und || kann für mehrere Bedingungen verwendet werden:

Der logische AND-Operator 

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

Wenn num == 10 falsch ist, wird der zweite Wert nicht ausgewertet. Dies wird als Kurzschlussauswertung bezeichnet.

Der logische ODER-Operator 

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

Wenn num == 10 wahr ist, wird der zweite Wert nicht ausgewertet.

Der logische NOT-Operator 

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

Optionale Bindungs- und "Wo" -Klauseln

Optionals müssen entpackt werden, bevor sie in den meisten Ausdrücken verwendet werden können. if let eine optionale Bindung ist , die erfolgreich ist, wenn der optionale Wert nicht 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")
}

Sie können denselben Namen für die neu gebundene Variable wiederverwenden, wobei das Original gespiegelt wird: 

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

Kombinieren Sie mehrere optionale Bindungen mit Kommas ( , ): 

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
}

Wenden Sie nach der optionalen Bindung weitere Einschränkungen mit einer where Klausel an: 

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

Wenn Sie abenteuerlustig sind, verschachteln Sie eine beliebige Anzahl optionaler Bindungen und where Klauseln: 

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 Klauseln ersetzt wurden ( SE-0099 ): Verwenden Sie einfach eine andere , um optionale Bindungen und boolesche Bedingungen zu trennen. 

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

Ternärer Operator

Die Bedingungen können auch in einer Zeile mit dem ternären Operator ausgewertet werden:

Wenn Sie das Minimum und Maximum von zwei Variablen ermitteln möchten, können Sie if -Anweisungen verwenden: 

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 
}

Der ternäre bedingte Operator nimmt eine Bedingung an und gibt einen von zwei Werten zurück, je nachdem, ob die Bedingung wahr oder falsch war. Die Syntax lautet wie folgt: Dies entspricht dem Ausdruck: 

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

Der obige Code kann mit einem ternären bedingten Operator wie folgt umgeschrieben werden: 

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

Im ersten Beispiel ist die Bedingung a <b. Ist dies der Fall, wird das Ergebnis, das min zugewiesen wurde, von a sein; Wenn es falsch ist, ist das Ergebnis der Wert von b.

Hinweis: Da das Finden der größeren oder kleineren von zwei Zahlen eine solche häufige Operation ist, bietet die Swift-Standardbibliothek zwei Funktionen für diesen Zweck: max und min.

Kein Koaleszenzoperator

Der Null-Koaleszenz-Operator <OPTIONAL> ?? <DEFAULT VALUE> entpackt das <OPTIONAL> wenn es einen Wert enthält, oder gibt <DEFAULT VALUE> wenn es null ist. <OPTIONAL> ist immer ein optionaler Typ. <DEFAULT VALUE> muss dem Typ entsprechen, der in <OPTIONAL> gespeichert ist.

Der nullkoaleszierende Operator ist eine Abkürzung für den folgenden Code, der einen ternären Operator verwendet: 

a != nil ? a! : b

Dies kann durch den folgenden Code überprüft werden: 

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

Zeit für ein Beispiel 

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
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow