Swift Language
Warunkowe

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


Wprowadzenie

Wyrażenia warunkowe, zawierające słowa kluczowe takie jak if, else if i else, zapewniają programom Swift możliwość wykonywania różnych akcji w zależności od warunku logicznego: True lub False. W tej sekcji opisano użycie warunków warunkowych Swift, logiki logicznej i instrukcji trójskładnikowych.

Uwagi

Aby uzyskać więcej informacji o instrukcjach warunkowych, zobacz Swift Programming Language .

Korzystanie ze Strażnika

2.0

Strażnik sprawdza warunek, a jeśli jest fałszywy, wchodzi do oddziału. Oddziały kontroli wartowników muszą opuścić swój otaczający blok albo przez return , break lub continue (jeśli dotyczy); niezastosowanie się do tego powoduje błąd kompilatora. Ma to tę zaletę, że po napisaniu guard nie można pozwolić, aby przepływ kontynuował się przypadkowo (jak byłoby to możliwe w przypadku if ).

Korzystanie ze strażników może pomóc utrzymać niskie poziomy zagnieżdżenia , co zwykle poprawia czytelność kodu. 

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

Strażnik może również sprawdzić, czy wartość jest opcjonalna , a następnie rozpakować ją w zakresie zewnętrznym: 

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

Strażnik może łączyć opcjonalne rozpakowywanie i sprawdzanie stanu za pomocą słowa kluczowego where : 

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

Podstawowe warunki: instrukcje if

Instrukcja if sprawdza, czy warunek Bool jest 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")
}

instrukcje if akceptują else if bloki else if i else , które mogą przetestować alternatywne warunki i zapewnić awarię: 

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

Podstawowe operatory, takie jak && i || może być stosowany w wielu warunkach:

Logiczny operator AND 

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

Jeśli num == 10 było fałszem, druga wartość nie byłaby oceniana. Jest to znane jako ocena zwarcia.

Logiczny operator OR 

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

Jeśli liczba num == 10 jest prawdą, druga wartość nie byłaby oceniana.

Logiczny operator NOT 

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

Opcjonalne klauzule wiążące i „gdzie”

Opcje muszą zostać rozpakowane, zanim będą mogły być użyte w większości wyrażeń. if let jest opcjonalnym wiązaniem , które kończy się powodzeniem, jeśli wartość opcjonalna nie była równa 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")
}

Możesz ponownie użyć tej samej nazwy dla nowo związanej zmiennej, zacieniując oryginał: 

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

Połącz wiele opcjonalnych powiązań z przecinkami ( , ): 

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
}

Zastosuj dalsze ograniczenia po opcjonalnym wiązaniu za pomocą klauzuli where : 

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

Jeśli masz ochotę na przygodę, przeplataj dowolną liczbę opcjonalnych wiązań i klauzule 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

W Swift 3, w where klauzule zostały zastąpione ( SE-0099 ): po prostu użyj innego , aby oddzielić opcjonalne wiązania i warunki boolowskie. 

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

Operator trójskładnikowy

Warunki można również oceniać w jednym wierszu za pomocą operatora trójskładnikowego:

Jeśli chcesz określić minimum i maksimum dwóch zmiennych, możesz użyć instrukcji if, takich jak: 

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 
}

Trójskładnikowy operator warunkowy przyjmuje warunek i zwraca jedną z dwóch wartości, w zależności od tego, czy warunek był prawdziwy, czy fałszywy. Składnia jest następująca: Jest to równoważne z wyrażeniem: 

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

Powyższy kod można przepisać za pomocą trójskładnikowego operatora warunkowego, jak poniżej: 

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

W pierwszym przykładzie warunkiem jest <b. Jeśli jest to prawda, wynik przypisany z powrotem do min będzie miał wartość; jeśli to fałsz, wynikiem będzie wartość b.

Uwaga: Ponieważ znalezienie większej lub mniejszej z dwóch liczb jest tak powszechną operacją, standardowa biblioteka Swift udostępnia w tym celu dwie funkcje: maks. I min.

Operator zerowo-koalescencyjny

Operator zerowo-koalescencyjny <OPTIONAL> ?? <DEFAULT VALUE> DOMYŚLNA <OPTIONAL> ?? <DEFAULT VALUE> rozpakowuje <OPTIONAL> jeśli zawiera wartość, lub zwraca <DEFAULT VALUE> <OPTIONAL> ?? <DEFAULT VALUE> DOMYŚLNA <DEFAULT VALUE> jeśli jest zerowa. <OPTIONAL> jest zawsze typu opcjonalnego. <DEFAULT VALUE> musi być zgodna z typem przechowywanym w <OPTIONAL> .

Operator zerowo-koalescencyjny jest skrótem dla poniższego kodu, który używa operatora trójskładnikowego: 

a != nil ? a! : b

można to zweryfikować za pomocą poniższego kodu: 

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

Czas na przykład 

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
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow