TUPLE
Le tuple raggruppano diversi valori in uno unico.

Nel seguente esempio, (404, “Not Found”) è una tupla che descrive un codice di stato HTTP. Un codice di stato HTTP è un valore restituito da un server web ogni volta che si richiede una pagina web. Un codice di stato 404 Not Found viene restituito se si richiede una pagina web che non esiste.

let http404Error = (404, “Not Found”)
// http404Error is of type (Int, String), and equals (404, “Not Found”)

 

La tupla (404, “Not Found”)  raggruppa un valore Int e uno String per far si che il codice HTTP abbia due valori distinti: un codice sotto forma di numero e una stringa leggibile e comprensibile all’utente.

Come abbiamo visto, una tupla può contenere qualsiasi tipo di dato, anche infiniti dati di tipo diverso tra di loro. niente può impedirti di costruire una tupla con diversi valori dello stesso tipo, ad esempio (Int, Int, Int), oppure una tupla con valori di tipo discordante (String, Bool).

È possibile scomporre il contenuto delle tuple in costanti o variabili indipendenti, per poi accedervi come di consueto:

let (statusCode, statusMessage) = http404Error
println(“The status code is \(statusCode)”)
// prints “The status code is 404”
println(“The status message is \(statusMessage)”)
// prints “The status message is Not Found

Se hai bisogno solamente di alcune parti della tupla, puoi farlo utilizzando un underscore(_):

let (justTheStatusCode, _) = http404Error
println(“The status code is \(justTheStatusCode)”)
// prints “The status code is 404

In alternativa, si può accedere ai diversi elementi presenti in una tupla utilizzando la loro numerazione di posizione, partendo da zero:

println(“The status code is \(http404Error.0)”)
// prints “The status code is 404”
println(“The status message is \(http404Error.1)”)
// prints “The status message is Not Found

Puoi rinominare i singoli elementi di una tupla al momento della creazione della stessa:

let http200Status = (statusCode: 200, description: “OK”)

Se rinomini gli elementi in una tupla,  puoi utilizzare questi nomi per accedere ai singoli elementi:

println(“The status code is \(http200Status.statusCode)”)
// prints “The status code is 200”
println(“The status message is \(http200Status.description)”)
// prints “The status message is OK

 

Le tuple sono particolarmente utili da utilizzare come risultato di una funzione. Ad esempio, una funziona che cerca di recuperare una pagina web, può restituire una tupla (Int, String) che contiene il risultato della riuscita di questa operazione. Restituendo una tupla con due tipi diversi di valore, la funzione fornisce più informazioni (in questo caso il codice di errore e il messaggio di errore) rispetto ad una tupla che restituisce, ad esempio, il solo codice di errore.

OPTIONALS

Puoi usare optionals in situazioni in cui manca un valore. Ad esempio:

Il valore è presente ed è uguale a x

oppure

Il valore è assente.

Ecco un esempio. In Swift, le stringhe possono avere il metodo toInt, che cerca di convertire un valore string in un int. Ad ogni modo, non tutte le stringhe possono essere convertite in int. La stringa “123” può essere convertita nel valore numerico 123, ma la stringa “hello, world” non può essere convertita in un int per ovvi motivi.

In questo esempio vediamo al conversione di una stringa in un valore int, utilizzando il metodo toInt:

let possibleNumber = “123”
let convertedNumber = possibleNumber.toInt()
// convertedNumber is inferred to be of type “Int?”, or “optional Int

Siccome il metodo toInt potrebbe essere facilmente tratto in inganno, restituisce optional Int, invece di un normale Int. Un optional int è indicato come Int?, e non semplicemente Int. Il punto interrogativo sta infatti ad indicare che il valore contiene un “optional value”, che sta ad indicare che può contenere valori int come può non contenere valori. (è da notare che non può contenere valori diversi da int, come ad esempio un valore booleano. Può contenere un int oppure essere vuoto).

 

IF
È possibile utilizzare un’istruzione if per scoprire se un optional contiene un valore. Se un optional contiene un valore, restituisce true; se non ha alcun valore, restituisce false.

Una volta che avete appurato che il valore opzionale non è vuoto, è possibile accedervi apponendo un (!) punto esclamativo allo stesso. Il punto esclamativo dice , praticamente “ho appurato che questo optional contiene un valore, puoi utilizzarlo”.

if convertedNumber {
    println(“\(possibleNumber) has an integer value of \(convertedNumber!)”)
} else {
    println(“\(possibleNumber) could not be converted to an integer”)
}
// prints “123 has an integer value of 123

 

 OPTIONAL BINDING

Optional binding insieme agli if o while per ricercare un valore all’interno di un optional ed estrarlo  per essere utilizzato all’interno di una costanto o di una variabile, tutto in un’unica azione. Vedremo nel dettaglio l’utilizzo di if e while più avanti.

Un esempio di optional binding:

if let constantName = someOptional {
statements
}
You can rewrite the possibleNumber example from above to use optional binding rather than forced unwrapping:

if let actualNumber = possibleNumber.toInt() {
println(“\(possibleNumber) has an integer value of \(actualNumber)”)
} else {
println(“\(possibleNumber) could not be converted to an integer”)
}
// prints “123 has an integer value of 123

Può essere letto come:

“se l’optional Int contiene un valore, crea una nuova variabile chiamata actualNumber ed assegnale il valore trovato nell’optional.”

Se la conversione ha successo, la costante ActualNumber diventa disponibile e può essere utilizzata, essendo inizializzata con il valore contenuto nell’optional e, per accedervi, non è necessario apporre il suffisso (!).In questo esempio, actualNumber è utilizzato semplicemente per stampare il risultato della conversione.

L’optional binding può essere utilizzato sia in costanti che in variabili.

NIL
Puoi inizializzare una variabile optional senza valore, assegnandogli il valore speciale nil:

var serverResponseCode: Int? = 404
// serverResponseCode contains an actual Int value of 404
serverResponseCode = nil
// serverResponseCode now contains no value

Se inizializzi una variabile o una costante optional senza assegnargli un valore, il compilatore automaticamente le assegna il valore nil :

var surveyAnswer: String?
// surveyAnswer is automatically set to nil

Come spiegato in precedenza, gli optionals permettono ad una variabile di non avere valori assegnati.

Molte volte basta guardare la struttura del programma per avere chiaro che un optionals debba contenere sempre un valore, dopo che gli è stato assegnato la prima volta. In questi casi, per velocizzare l’esecuzione del programma, si può togliere la parte di codice che ha il compito di fare il “check”.

Questo tipo di optional è noto come “implicitly unwrapped optional” e si dichiara utilizzando il punto esclamativo (String!) invece del punto interrogativo (String?) dopo il tipo di dato che si desidera dichiarare come optional.

Gli Implicitly unwrapped optionals sono utili quando il valore dell’optional è definito immediatamente dopo la sua inizializzazione, ed è quindi sicuro che questo valore sia presente anche nelle successive fasi di esecuzione del programma.

L’uso primario degli implicitly unwrapped optionals in Swift è durante l’inizializzazione delle classi.

Un implicitly unwrapped optional appare a tutti gli effetti come un normale valore optional, ma può essere usato anche come un valore NON optional, senza bisogno di fare l’unwrapping del valore ogni volta […]

let possibleString: String? = “An optional string.”
println(possibleString!) // requires an exclamation mark to access its value
// prints “An optional string.”

let assumedString: String! = “An implicitly unwrapped optional string.”
println(assumedString) // no exclamation mark is needed to access its value
// prints “An implicitly unwrapped optional string.”

 

E’ comunque possibile trattare un optional unwrapped come un normale optional, quindi per verificare se contiene un valore si procede come segue:

if assumedString {
println(assumedString)
}
// prints “An implicitly unwrapped optional string.

E’ inoltre possibile utilizzare un unwrapped optional con optional binding, per cercare ed estrarre il suo valore in un’unica istruzione:

if let definiteString = assumedString {
println(definiteString)
}
// prints “An implicitly unwrapped optional string.

Gli Optionals ti permettono di verificare se in una data variabile esiste o meno un valore, quindi scrivere codice che funzioni anche in assenza dello stesso. In alcuni casi invece, per il tuo codice è impossibile continuare l’esecuzione senza la presenza di un valore oppure se un certo valore non rispetta alcuni requisiti. In queste situazioni, puoi attivare un’ “assertions” nel codice che interrompa l’esecuzione e ti permetta di fare il debug per scoprire la causa del valore assente o non valido.

FARE DEBUG ATTRAVERSO LE ASSERTIONS

L’assertion è un controllo di runtime atto ad appurare se una condizione logica restituisce true, quindi è vera.  Si utilizza un’asserzione per assicurarsi che una condizione essenziale sia soddisfatta prima di eseguire qualsiasi ulteriore istruzione contenuta nel codice. Se la condizione restituisce true, l’esecuzione del codice continua senza interruzioni; se la condizione restituisce false, l’esecuzione del codice termina e l’esecuzione della vostra applicazione viene fermata.

Se il codice “innesca” un’assertion durante l’esecuzione in un ambiente di debug, come ad esempio quando si crea e si esegue un’applicazione in Xcode, è possibile vedere esattamente dove si è verificato lo stato non valido e venire a conoscenza delle azioni che la vostra applicazione stava compiendo prima di essere bloccata. Un’assertion consente inoltre di fornire un messaggio di debug.Puoi scrivere un’assertion in questo modo:

let age = -3
assert(age >= 0, “A person’s age cannot be less than zero”)
// this causes the assertion to trigger, because age is not >= 0

In questo esempio,  l’esecuzione del codice continua solamente se l’età è >= 0 comunque è appurata come true, quando il valore dell’età è positivo. Se l’età è negativa, l’assertion viene richiamata e il codice termina la sua esecuzione.

 

Abbiamo finito con questo capitolo della guida al linguaggio swift!

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