Swift Language
Conditionals

C Language firebase HTML iOS Java Language JavaScript Node.js Objective-C Language PHP Regular Expressions
Поиск…


Вступление

Условные выражения, включающие ключевые слова, такие как if, else if и else, предоставляют программам Swift возможность выполнять разные действия в зависимости от логического условия: True или False. В этом разделе рассматриваются использование условий Swift, логической логики и трехмерных выражений.

замечания

Дополнительные сведения об условных операторах см. В разделе Быстрый язык программирования .

Использование гвардии

2,0

Guard проверяет состояние, и если оно ложно, оно входит в ветвь. Отделения проверки проверки должны оставить свой закрывающий блок либо через return , break или continue (если применимо); неспособность сделать это приводит к ошибке компилятора. Это имеет то преимущество, что, когда guard написан, невозможно, чтобы поток продолжался случайно (как это возможно при использовании if ).

Использование охранников может помочь снизить уровень гнездования , что обычно улучшает читаемость кода. 

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

Guard также может проверить, есть ли значение в опции , а затем разворачивать его во внешней области: 

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

Guard может объединить дополнительный развёрток и проверить состояние , используя , where ключевое слово: 

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

Основные условные обозначения: if-statements

Оператор if проверяет, является ли условие Bool 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 утверждения принимают else if и else блоки, которые могут проверять альтернативные условия и предоставлять резервную копию: 

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

Основные операторы типа && и || может использоваться для нескольких условий:

Логический оператор И 

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

Если num == 10 было ложным, второе значение не будет оцениваться. Это называется оценкой короткого замыкания.

Логический оператор OR 

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

Если num == 10 истинно, второе значение не будет оцениваться.

Логический оператор NOT 

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

Необязательные обязательства и предложения «где»

Опционы должны быть развернуты, прежде чем их можно будет использовать в большинстве выражений. if let является необязательной привязкой , которая преуспевает, если необязательное значение не равно 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")
}

Вы можете повторно использовать одно и то же имя для новой связанной переменной, затеняя оригинал: 

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

Объедините несколько необязательных привязок с запятыми ( , ): 

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
}

Примените дополнительные ограничения после необязательного связывания с помощью предложения where : 

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

Если вы чувствуете себя авантюрно, чередуйте любое количество необязательных привязок и 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

В Swift 3, where были заменены предложения ( SE-0099 ): просто используйте другое , чтобы отделить дополнительные привязки и логические условия. 

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

Тернарный оператор

Условия могут также оцениваться в одной строке с использованием тернарного оператора:

Если вы хотите определить минимум и максимум две переменные, вы можете использовать операторы if, например: 

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 
}

Тернарный условный оператор принимает условие и возвращает одно из двух значений, в зависимости от того, было ли условие истинным или ложным. Синтаксис выглядит следующим образом: это эквивалентно выражению: 

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

Вышеприведенный код можно переписать с помощью тернарного условного оператора, как показано ниже: 

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

В первом примере условие равно <b. Если это верно, результат, назначенный обратно в мин, будет равным; если оно ложно, результатом будет значение b.

Примечание. Поскольку поиск большего или меньшего из двух чисел является такой общей операцией, стандартная библиотека Swift предоставляет для этой цели две функции: max и min.

Nil-Coalescing Operator

Оператор nil-coalescing <OPTIONAL> ?? <DEFAULT VALUE> разворачивает <OPTIONAL> OPTIONAL <OPTIONAL> если оно содержит значение, или возвращает <DEFAULT VALUE> если nil. <OPTIONAL> всегда имеет необязательный тип. <DEFAULT VALUE> должен соответствовать типу, который хранится внутри <OPTIONAL> .

Оператор nil-coalescing является сокращением для кода ниже, который использует тернарный оператор: 

a != nil ? a! : b

это можно проверить по приведенному ниже коду: 

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

Время для примера 

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
Лицензировано согласно CC BY-SA 3.0
Не связан с Stack Overflow