Swift Language
Condizionali

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


introduzione

Le espressioni condizionali, che includono parole chiave come if, else if e else, forniscono ai programmi Swift la possibilità di eseguire azioni diverse a seconda della condizione booleana: True o False. Questa sezione copre l'uso di condizionali Swift, logica booleana e dichiarazioni ternarie.

Osservazioni

Per ulteriori informazioni sulle istruzioni condizionali, vedere The Swift Programming Language .

Usando Guard

2.0

La guardia verifica una condizione e, se è falsa, entra nel ramo. Le filiali di controllo delle guardie devono lasciare il loro blocco di chiusura tramite return , break o continue (se applicabile); non riuscendo a farlo risulta un errore del compilatore. Questo ha il vantaggio che quando una guard è scritta non è possibile lasciare che il flusso continui accidentalmente (come sarebbe possibile con un if ).

L'uso delle protezioni può aiutare a mantenere bassi i livelli di annidamento , il che di solito migliora la leggibilità del codice. 

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

Guard può anche controllare se c'è un valore in un opzionale , e quindi scartarlo nello scope esterno: 

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

Guard può combinare lo unwrapping opzionale e il controllo delle condizioni utilizzando la parola chiave where : 

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

Condizioni condizionali di base: dichiarazioni if

Un'istruzione if controlla se una condizione di 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 istruzioni accettano else if e else blocchi, che possono testare condizioni alternative e fornire una riserva: 

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

Operatori di base come && e || può essere utilizzato per più condizioni:

L'operatore logico AND 

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

Se num == 10 era falso, il secondo valore non sarebbe stato valutato. Questo è noto come valutazione di cortocircuito.

L'operatore logico OR 

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

Se num == 10 è true, il secondo valore non verrà valutato.

L'operatore logico NOT 

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

Vincolo facoltativo e clausole "dove"

Gli optionals devono essere scartati prima di poter essere utilizzati nella maggior parte delle espressioni. if let è un collegamento facoltativo , che ha esito positivo se il valore facoltativo non era 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")
}

È possibile riutilizzare lo stesso nome per la variabile appena associata, ombreggiato all'originale: 

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

Combina più associazioni opzionali con virgole ( , ): 

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
}

Applicare ulteriori vincoli dopo il legame opzionale utilizzando un where clausola: 

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

Se ti senti avventuroso, interleave un numero qualsiasi di associazioni opzionali e clausole 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

In Swift 3, where clausole sono state sostituite ( SE-0099 ): basta usare un altro , per separare le associazioni opzionali e le condizioni booleane. 

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

Operatore ternario

Le condizioni possono anche essere valutate in una singola riga usando l'operatore ternario:

Se si desidera determinare il minimo e il massimo di due variabili, è possibile utilizzare le istruzioni if, in questo modo: 

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 
}

L'operatore condizionale ternario accetta una condizione e restituisce uno dei due valori, a seconda che la condizione fosse vera o falsa. La sintassi è la seguente: equivale ad avere l'espressione: 

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

Il codice sopra riportato può essere riscritto usando l'operatore condizionale ternario come di seguito: 

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

Nel primo esempio, la condizione è a <b. Se questo è vero, il risultato assegnato a min sarà di a; se è falso, il risultato sarà il valore di b.

Nota: poiché trovare i due numeri più grandi o più piccoli è un'operazione così comune, la libreria standard Swift fornisce due funzioni a questo scopo: max e min.

Nil-Coalescing Operator

L'operatore a coalescenza nulla <OPTIONAL> ?? <DEFAULT VALUE> scava il <OPTIONAL> se contiene un valore o restituisce <DEFAULT VALUE> se è nullo. <OPTIONAL> è sempre di tipo facoltativo. <DEFAULT VALUE> deve corrispondere al tipo archiviato in <OPTIONAL> .

L'operatore a coalescenza nulla è abbreviato per il codice seguente che utilizza un operatore ternario: 

a != nil ? a! : b

questo può essere verificato dal codice qui sotto: 

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

Tempo per un esempio 

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
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow