Do-While

L’altra variante di while, cioè do-while, esegue prima un singolo passaggio attraverso il blocco, prima di considerare la condizione. Dopo aver preso in considerazione la condizione continua a ripetere il ciclo finché la condizione risulta falsa.

Ecco la forma generale di un ciclo do-while:

do {

statements

} while condition

istruzioni condizionali
Spesso sono utili per eseguire diversi pezzi di codice in base a determinate condizioni. Potrebbe essere utile eseguire un ulteriore porzione di codice quando si verifica un errore, o per visualizzare un messaggio quando un valore diventa troppo elevato o troppo basso. Per fare questo, si possono utilizzare le istruzioni condizionali.

Swift offre due modi per aggiungere rami condizionali al tuo codice, noti come istruzioni if e switch. In genere, si utilizza l’istruzione if per valutare le condizioni semplici con pochi risultati possibili. L’istruzione switch è più adatta alle condizioni più complesse con più permutazioni.

if
Nella sua forma più semplice, l’istruzione if ha una sola condizione. Si esegue un insieme di istruzioni solo se tale condizione è vera:

var temperatureInFahrenheit = 30
if temperatureInFahrenheit <= 32 {
println(“It’s very cold. Consider wearing a scarf.”)
}
// prints “It’s very cold. Consider wearing a scarf.”

L’esempio precedente controlla se la temperatura è inferiore o uguale a 32 gradi Fahrenheit (il punto di congelamento dell’acqua). Se lo è, viene stampato un messaggio. Altrimenti, nessun messaggio viene stampato, e l’esecuzione di codice continua dopo la chiusura.

L’istruzione if in grado di fornire un insieme alternativo di dichiarazioni, note come else, nel caso in cui la condizione dell’if sia falsa. Tali dichiarazioni sono indicate dalla parola chiave else:

temperatureInFahrenheit = 40
if temperatureInFahrenheit <= 32 {
println(“It’s very cold. Consider wearing a scarf.”)
} else {
println(“It’s not that cold. Wear a t-shirt.”)
}
// prints “It’s not that cold. Wear a t-shirt.”

Una di queste due porzioni di codice viene sempre eseguito. Poiché la temperatura è aumentata di 40 gradi Fahrenheit, non è più abbastanza freddo per avvisarlo di indossare una sciarpa, così scatta il ramo else.

È possibile concatenare più istruzioni if ​​insieme, che verranno considerate come clausole addizionali:

temperatureInFahrenheit = 90
if temperatureInFahrenheit <= 32 {
println(“It’s very cold. Consider wearing a scarf.”)
} else if temperatureInFahrenheit >= 86 {
println(“It’s really warm. Don’t forget to wear sunscreen.”)
} else {
println(“It’s not that cold. Wear a t-shirt.”)
}
// prints “It’s really warm. Don’t forget to wear sunscreen.”

Qui, un ulteriore if si aggiunge per restituire un messaggio quando si trattano temperature particolarmente calde. La clausola else finale rimane e stampa una risposta per tutte le temperature che non possono essere considerate né troppo calde né troppo fredde.

La clausola else finale è facoltativa e può essere quindi esclusa se l’insieme di condizioni non ha bisogno di essere completa:

temperatureInFahrenheit = 72
if temperatureInFahrenheit <= 32 {
println(“It’s very cold. Consider wearing a scarf.”)
} else if temperatureInFahrenheit >= 86 {
println(“It’s really warm. Don’t forget to wear sunscreen.”)
}

In questo esempio, la temperatura non è né troppo fredda né troppo calda, quindi non viene stampato nessun messaggio.

Switch
Un’istruzione switch considera un valore e lo confronta con diversi modelli corrispondenti possibili. Quindi, esegue un blocco di codice appropriato, in base al primo modello che corrisponde alla condizione data. Un’istruzione switch fornisce un’alternativa per l’istruzione if per rispondere a più stati possibili.

Nella sua forma semplice, un’istruzione switch confronta un valore con uno o più valori dello stesso tipo:

switch some value to consider {
case value 1:
respond to value 1
case value 2,
value 3:
respond to value 2 or 3
default:
otherwise, do something else
}

Ogni switch è costituito da più casi possibili, ognuno dei quali inizia con la parola chiave case. Oltre al confronto con i valori specifici, Swift fornisce diversi modi per ogni case di specificare i modelli corrispondenti più complessi.

Il corpo di ciascun switch-case rappresenta un ramo separato di codice, in modo simile a quelli di un if. L’istruzione switch determina quale ramo deve essere selezionato.

Ogni switch deve essere esaustivo. Cioè, ogni valore possibile del tipo in esame deve essere accompagnato da un case. Se non è opportuno prevedere un case per ogni valore possibile, si può definire un case di default per coprire eventuali valori che non vengono affrontati in modo esplicito.

Questo esempio utilizza un’istruzione switch per prendere in considerazione un singolo carattere minuscolo chiamato someCharacter:

let someCharacter: Character = “e”
switch someCharacter {
case “a”, “e”, “i”, “o”, “u”:
println(“\(someCharacter) is a vowel”)
case “b”, “c”, “d”, “f”, “g”, “h”, “j”, “k”, “l”, “m”,
“n”, “p”, “q”, “r”, “s”, “t”, “v”, “w”, “x”, “y”, “z”:
println(“\(someCharacter) is a consonant”)
default:
println(“\(someCharacter) is not a vowel or a consonant”)
}
// prints “e is a vowel”

Il primo caso di switch corrisponde a tutte e cinque le vocali minuscole in lingua inglese. Allo stesso modo, il suo secondo caso corrisponde a tutte le consonanti inglesi minuscole.

Non risulta pratico scrivere tutti gli altri caratteri possibili nell’ambito di uno switch-case, e così questa affermazione switch fornisce un caso predefinito per abbinare tutti gli altri caratteri che non sono vocali o consonanti. Questa fa si che l’istruzione switch sia esaustiva.

L’intera istruzione switch termina la sua esecuzione non appena il primo switch-case adatto è completato, senza richiedere un’istruzione break esplicita. Questo rende l’istruzione switch più sicura e facile da usare rispetto a C ed evita di dover ricorrere ad altri “case”.

Il corpo di ogni singolo case deve contenere almeno un’istruzione eseguibile. AND non è valida per scrivere il codice seguente, in quanto il primo case è vuoto:

let anotherCharacter: Character = “a”
switch anotherCharacter {
case “a”:
case “A”:
println(“The letter A”)
default:
println(“Not the letter A”)
}
// this will report a compile-time error

A Differenza di C, in un’istruzione switch non corrisponde sia “a” e “A”. Piuttosto, si segnala un errore di compilazione quel caso “a”: non contiene istruzioni eseguibili. Questo approccio rende il codice più sicuro e molto più chiaro e scorrevole.

Più corrispondenze per un singolo switch-case possono essere separate da virgole, e possono essere scritti su più righe se la lista è lunga:

switch some value to consider {
case value 1,
value 2:
statements
}


Nei case possono essere utilizzati anche dati contenuti in un intervallo:

let count = 3_000_000_000_000
let countedThings = “stars in the Milky Way”
var naturalCount: String
switch count {
case 0:
naturalCount = “no”
case 1…3:
naturalCount = “a few”
case 4…9:
naturalCount = “several”
case 10…99:
naturalCount = “tens of”
case 100…999:
naturalCount = “hundreds of”
case 1000…999_999:
naturalCount = “thousands of”
default:
naturalCount = “millions and millions of”
}
println(“There are \(naturalCount) \(countedThings).”)
// prints “There are millions and millions of stars in the Milky Way.

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