A differenza di C, Swift permette di utilizzare diverse volte “case” anche per gli stessi valori. Ad esempio, se parliamo di coordinate di un punto,  (0, 0) può rientrare in deversi “case”. In ogni modo, quando arriverà il punto (0,0) nell’iterazione, verrà preso in considerazione solo quello ed eventuali match successivi verranno ignorati.

Value Bindings

Un case switch può associare il valore o i valori che corrispondono a costanti o variabili temporanee, per l’uso nel corpo del case. Questo è noto come valore vincolante, in quanto i valori sono “legati” a costanti temporanee o variabili contenute esclusivamente all’interno del corpo del case.

L’esempio che segue prende un punto (x, y), espresso come una tupla di tipo (Int, Int) e lo inserisce in un grafico:

let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
println(“on the x-axis with an x value of \(x)”)
case (0, let y):
println(“on the y-axis with a y value of \(y)”)
case let (x, y):
println(“somewhere else at (\(x), \(y))”)
}
// prints “on the x-axis with an x value of 2

L’istruzione switch determina se il punto si trova sull’ asse x,  y o altrove (cioè su nessuno dei 2 assi cartesiani).

I tre case  dichiarano le costanti temporanee x e y, che assumono valori di una o entrambe le tuple da “anotherPoint”. Il primo caso, (sia x, 0), corrisponde a qualsiasi punto con valore y di 0 e assegna il valore x del punto alla costante x temporanea. Analogamente, il secondo caso, (0, sia y), corrisponde a qualsiasi punto con un valore di x 0 e assegna il valore y del punto alla costante y temporaneo.

Una volta che le costanti temporanee sono dichiarate, possono essere utilizzate unicamente entro il blocco di codice del case. Qui sono utilizzate come scorciatoia per la stampa dei valori con la funzione println.

Si noti che questa istruzione switch non ha un caso di default. L’ultimo caso, caso let (x, y), dichiara una tupla di due costanti segnaposto che possono abbinare qualsiasi valore. Di conseguenza, esso corrisponde a tutti i possibili valori rimanenti, e un caso di default non è necessario per rendere l’istruzione switch esaustivo.

Nell’esempio precedente, x ed y sono dichiarate come costanti con la parola chiave let, perché non vi è alcuna necessità di modificare i loro valori all’interno del corpo del case.

Where

Un case switch può utilizzare una clausola WHERE per verificare ulteriori condizioni.

L’esempio che segue suddivide un punto (x, y) sul grafico:

let yetAnotherPoint = (1, -1)

switch yetAnotherPoint {
case let (x, y) where x == y:
println(“(\(x), \(y)) is on the line x == y”)
case let (x, y) where x == -y:
println(“(\(x), \(y)) is on the line x == -y”)
case let (x, y):
println(“(\(x), \(y)) is just some arbitrary point”)
}
// prints “(1, -1) is on the line x == -y”

L’istruzione switch determina se il punto si trova sulla linea diagonale dove x == y, sulla linea diagonale viola dove x == y, o nessuno dei due.

I tre casi di commutazione dichiarano costanti x e y, che assumono temporaneamente i due valori del punto. Queste costanti sono utilizzate come parte di una clausola in cui, per creare un filtro dinamico, Il case switch corrisponde al valore corrente del punto solo se la condizione della clausola WHERE restituisce true per quel valore.

Come nell’esempio precedente, il case finale corrisponde a tutti i possibili valori restanti, e quindi  non è necessario l’impiego di un case di default per rendere l’istruzione switch esaustiva.

Dichiarazioni Transfer Control
Le Dichiarazioni “transfer control” cambiano l’ordine in cui viene eseguito il codice, trasferendo il controllo da un pezzo di codice ad un altro. Swift ha quattro dichiarazioni di trasferimento di controllo:

continue
break
fallthrough
return‌

Continue

L’istruzione continue indica un ciclo per fermare l’azione corrente e ricominciare all’inizio della prossima iterazione del ciclo, senza lasciare del tutto il ciclo stesso.

L’esempio seguente rimuove tutte le vocali e gli spazi da una stringa per creare una frase criptica:

let puzzleInput = “great minds think alike”

var puzzleOutput = “”
for character in puzzleInput {
switch character {
case “a”, “e”, “i”, “o”, “u”, ” “:
continue
default:
puzzleOutput += character
}
}
println(puzzleOutput)
// prints “grtmndsthnklk

Il codice qui sopra richiama la parola continue ogniqualvolta si imbatte in una vocale o uno spazio, saltando direttamente all’inizio della successiva iterazione. Questo comportamento consente il blocco dello switch in modo che corrisponda solo i caratteri vocali e di spazio,senza controllarli tutti.
Break
L’istruzione break termina immediatamente l’esecuzione di un intero flusso di controllo. L’istruzione break può essere utilizzata all’interno di un’istruzione switch quando si desidera terminare l’esecuzione dello stesso, prima che avvenga il controllo di tutti i case.
Break in una dichiarazione Loop
Quando viene utilizzato all’interno di un’istruzione ciclo, break termina l’esecuzione del ciclo immediatamente, e trasferisce il controllo alla prima riga di codice dopo la parentesi graffa di chiusura del loop (}). Nessun ulteriore codice della corrente iterazione del ciclo viene eseguito.
Break in un’istruzione switch
Quando viene utilizzato all’interno di un’istruzione switch, break provoca l’interruzione dell’esecuzione del ciclo,  per trasferire il controllo alla prima riga di codice dopo la parentesi graffa di chiusura della istruzione switch (}).

Questa funzione può essere utilizzata per abbinare e ignorare uno o più casi in un’istruzione switch. Perché un’istruzione switch di Swift sia esaustiva e non permetta  case vuoti,è necessario abbinare deliberatamente e ignorare un case. A tale scopo, si può scrivere l’istruzione break come l’intero corpo del case in cui si desidera ignorare. Quando questo case si trova insieme ad un’istruzione switch, l’istruzione break all’interno del case termina immediatamente l’esecuzione dell’istruzione switch.

L’esempio seguente inserisce un valore in caratteri e determina se esso rappresenta un simbolo numerico in una delle quattro lingue. I valori multipli sono coperti in un singolo case swutch per sintetizzare il tutto:

let numberSymbol: Carattere = “三” // cinese semplificato per il numero 3

var possibleIntegerValue: Int?
switch numberSymbol {
case “1”, “١”, “一”, “๑”:
possibleIntegerValue = 1
case “2”, “٢”, “二”, “๒”:
possibleIntegerValue = 2
case “3”, “٣”, “三”, “๓”:
possibleIntegerValue = 3
case “4”, “٤”, “四”, “๔”:
possibleIntegerValue = 4
default:
break
}
if let integerValue = possibleIntegerValue {
println(“The integer value of \(numberSymbol) is \(integerValue).”)
} else {
println(“An integer value could not be found for \(numberSymbol).”)
}
// prints “The integer value of 三 is 3.

 

VOLETE ESSERE AGGIORNATI TEMPESTIVAMENTE ALL’USCITA DI UN NUOVO CAPITOLO ? BASTA UN LIKE SULLA NOSTRA PAGINA FACEBOOK!