Control Flow

Swift offre tutti i classici controlli di flusso utilizzati nei linguaggi C-like. Questi includono “for” “and” “while” che servono per eseguire un’istruzione più volte; “if” e “switch” per eseguire diversi rami di codice in base a determinate condizioni; “break” e “continue” per trasferire il flusso in esecuzione in un altro punto del codice.

Oltre al tradizionale ciclo for che si trova in C, Swift aggiunge un ciclo for-in che rende più semplice scorrere gli array, dizionari, intervalli, stringhe e altre sequenze di dati.

“Switch” in Swift è anche molto più potente rispetto al suo omologo in C. I casi di un’istruzione switch non continuano attraverso il prossimo “case”, evitando gli errori più comuni in C causati dalla mancanza di istruzioni “break”. I valori che corrispondono in un “case” possono essere associati a costanti o variabili temporanee per essere utilizzati all’interno del corpo del case.


For Loops
Un loop “for” compie una serie di istruzioni un certo numero di volte. Swift permette di utilizzare due tipi di loop:

for-in compie una serie di azioni per ogni valore in un range, sequenza o progressione.
for-condition-increment compie una serie di azioni finchè non si arriva ad una precisa condizione, tipicamente incrementando un contatore ogni volta che termina un ciclo, finchè il contatore corrisponderà ad un dato valore.

For-In
Si utilizza il for-in loop per iterare in un “insieme di dati”, come può essere un range di numeri, valori in una lista o caratteri in una stringa.

In questo esempio vengono stampati i primi 5 elementi di una lista:

for index in 1…5 {
println(“\(index) times 5 is \(index * 5)”)
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

Il numero di valori che vengono richiamati vanno dalla posizione 1 alla 5, come indicato dall’operatore range racchiuso tra parentesi (…). Il valore di indice è impostato sul primo numero nell’intervallo (1) e le istruzioni all’interno del ciclo vengono eseguite. In questo caso, il loop contiene una sola istruzione, che stampa una voce recuperandola dalla lista, per 5 volte (incrementando il numero dell’indice). Dopo l’esecuzione dell’istruzione, il valore dell’ indice viene aggiornato per contenere il secondo valore nell’intervallo (2), e la funzione println viene chiamata di nuovo. Questo processo continua fino a quando viene raggiunta la fine del range.

Nell’esempio precedente, l’indice è una costante il cui valore è impostato automaticamente all’inizio di ogni iterazione del ciclo. Come tale, essa non deve essere dichiarata prima di essere utilizzata. Si è implicitamente dichiarata la sua inclusione nella dichiarazione loop.

 

let names = [“Anna”, “Alex”, “Brian”, “Jack”]

for name in names {
println(“Hello, \(name)!”)
}
// Hello, Anna!
// Hello, Alex!
// Hello, Brian!
// Hello, Jack!

Si può iterare all’interno di un dizionario attraverso le sue chiavi, per accedere ai diversi valori. Ogni elemento del dizionario viene restituito con la tupla (key, value) e, se necessario, si possono scomporre queste tuple per utilizzarle come costanti nel corpo del loop “for-in”. In questo esempio, le tuple vengono decomposte in questo modo: la costante animalName e il valore del dizionario vengono scomposti in una costante chiamata legCount:

let numberOfLegs = [“spider”: 8, “ant”: 6, “cat”: 4]
for (animalName, legCount) in numberOfLegs {
println(“\(animalName)s have \(legCount) legs”)
}
// spiders have 8 legs
// ants have 6 legs
// cats have 4 legs

I valori in un dizionario non devono necessariamente essere restituiti nello stesso ordine in cui sono stati inseriti. Il contenuto di un dizionario, infatti, non è mai ordinato quindi iterare nel dizionario non garantisce una restituzione ordinata dei valori.

In aggiunta alle liste o ai dizionari, si può utilizzare il for-in per iterare nei caratteri di una stringa:

for character in “Hello” {
println(character)
}
// H
// e
// l
// l
// o

For-Condition-Increment
Oltre ai loop for-in, Swift supporta (come in C) dei “condition and an incrementer”:

for var index = 0; index < 3; ++index {
println(“index is \(index)”)
}
// index is 0
// index is 1
// index is 2

Ecco la forma generica di questa forma di iterazione:

for initialization; condition; increment {
statements
}

Il punto e virgola separa le tre parti della definizione del ciclo, come in C. Tuttavia, a differenza di C, Swift non ha bisogno di parentesi intorno.

Il ciclo viene eseguito come segue:

Quando il ciclo è iniziato, l’espressione di inizializzazione viene valutata per la prima volta, per impostare eventuali costanti o variabili che sono necessarie per il ciclo.
Se, dopo esser stata valutata, la condizione restituisce false, il ciclo termina e l’esecuzione del codice continua dopo la parentesi graffa di chiusura del ciclo (}). Se l’espressione restituisce true, l’esecuzione del codice continua eseguendo le istruzioni all’interno delle parentesi graffe.

Dopo che tutte le istruzioni vengono eseguite, l’espressione di incremento viene controllata. Potrebbe aumentare o diminuire il valore di un contatore, o impostare una delle variabili inizializzate a un nuovo valore in base al risultato delle istruzioni. Dopo che l’espressione di incremento è stata valutata, l’esecuzione torna al punto 2, e l’espressione viene valutata di nuovo.
Il processo di formattazione ciclo e l’esecuzione sopra descritta rappresenta una scorciatoia :

initialization
while condition {
statements
increment
}

Costanti e variabili dichiarate all’interno dell’espressione di inizializzazione (ad esempio var index = 0) sono valide solo nell’ambito del ciclo for. Per recuperare il valore finale dell’indice dopo la fine del ciclo, è necessario dichiarare l’indice prima che inizi il loop:

var index: Int
for index = 0; index < 3; ++index {
println(“index is \(index)”)
}
// index is 0
// index is 1
// index is 2
println(“The loop statements were executed \(index) times”)
// prints “The loop statements were executed 3 times”

Si noti che il valore finale dell’indice, dopo il completamento di questo ciclo, è 3, non 2. Quando l’indice raggiunge valore 3, il ciclo si interrompe.
While Loops
Un ciclo while esegue un insieme di istruzioni fino a quando una condizione diventa falsa. Questi tipi di cicli sono usati quando il numero di iterazioni non è noto prima dell’inizio del ciclo stesso. Swift offre due tipi di cicli while:

while valuta la condizione all’inizio di ogni passaggio attraverso il ciclo.
do-while valuta la sua condizione alla fine di ogni passaggio attraverso il ciclo.
While
Un ciclo while inizia la valutazione di una singola condizione. Se la condizione è vera, un insieme di istruzioni viene ripetuto fino a quando la condizione diventa falsa.

Ecco la forma generale di un ciclo while:

while condition {
statements
}

 

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