BASI Flashcards

Question 1

Q

TUPLE

Answer

A

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.

Question 2

Q

OPTIONALS

Answer

A

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).

Question 3

Q

IF

Answer

A

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

Question 4

Q

OPTIONAL BINDING

Answer

A

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.

Question 5

Q

NIL

Answer

A

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.

Question 6

Q

FARE DEBUG ATTRAVERSO LE ASSERTIONS

Answer

A

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.

Question 7

Q

Collection Types

Answer

A

Swift fornisce due tipi di raggruppamenti per i dati, noti come array e dizionari, per la memorizzazione di diversi valori. Gli Array memorizzano valori ordinati e dello stesso tipo; i dizionari memorizzano valori dello stesso tipo ma non ordinati, che possono essere consultati ed utilizzati attraverso un identificatore univoco (noto anche come chiave).

Matrici e dizionari in Swift sono sempre chiare sui tipi di valori e chiavi che possono memorizzare. Questo significa che non è possibile inserire un valore di tipo errato in un array o dizionario per errore. Significa, inoltre, si può essere fiduciosi circa i tipi di valori che recupera da un array o dizionario. L’utilizzo di Array o dizionari estremamente tipizzati permette di evitare errori nella stesura del codice.

Question 8

Q

Array

Answer

A

Un Array memorizza una serie di dati dello stesso tipo e in ordine. Uno stesso valore può apparire in un array più di una volta, in posizioni diverse.

In Swift è molto importante specificare il tipo di dato che un array può memorizzare. Si differenziano dalle classi NSArray e NSMutableArray in objective-C, che possono memorizzare qualunque tipo di dato e non forniscono informazioni sui tipi di dato restituiti. In Swift, il tipo di dati che un array può memorizzare è sempre esplicito: se ad esempio si crea un array di valori int, in quell’array non si possono inserire dati che non siano di tipo int.

Question 9

Q

Array Type Shorthand Syntax

Answer

A

Il tipo di un array in Swift è scritto in modo chiaro: Array<tipo>, dove TIPO è il tipo di dato che l’array potrà contenere (ad esempio int, string…). Esiste un modo per dichiarare brevemente un array, nel seguente modo: TIPO[]. Entrambe le forme sono corrette ma è preferibile utilizzare la seconda.</tipo>

Puoi inoltre inizializzare un array in maniera veramente semplificata, semplicemente scrivendo tra parentesi quadre alcuni valori, Swift ne riconoscerà automaticamente il tipo e lo imposterà automaticamente:

_{[value 1, value 2, value 3]}

In questo esempio si crea un array chiamato shoppingList per memorizzare valori String:

_{var shoppingList: String[] = [“Eggs”, “Milk”] // shoppingList has been initialized with two initial items}

La variabile The shoppingList è dichiarata come una “lista di valori string”, scritta come String[]. Visto che è stata dichiarata come string, non potrà contenere altri valori oltre le stringhe. Nel seguente esempio, la lista shoppingList è inizializzata inserendo due valori (“Eggs” e “Milk”).

In questo caso, la stringa viene inizializzata con 2 valori string e nient’altro. Visto che sono esattamente del tipo dichiarato in precedenza per la variabile, vengono assegnati in automatico alla stringa shoppingList senza alcun problema.

Grazie all’inferenza di tipo in Swift, non c’è bisogno di scrivere il tipo di una lista se viene inizializzata con due o più valori dello stesso tipo. L’inizializzazione della lista shoppinglist può essere abbreviata in questo modo:

_{var shoppingList = [“Eggs”, “Milk”]}

Visto che entrambi i valori sono di tipo string, Swift intuisce che dovrà inizializzare quella lista con il tipo string, senza dover scrivere il comando “string [].

Question 10

Q

Accesso e modifica di una lista

Answer

A

Per scoprire quanti valori contiene una lista si può agire nel seguente modo:

_{println(“The shopping list contains (shoppingList.count) items.”) // prints “The shopping list contains 2 items.}

Usando il valore booleano “isEmpty” come scorciatoia per quando il contatore degli elementi è uguale a 0:

_{if shoppingList.isEmpty { println(“The shopping list is empty.”) } else { println(“The shopping list is not empty.”) } // prints “The shopping list is not empty.}

Puoi aggiungere un valore alla fine di una lista nel seguente modo:

_{shoppingList.append(“Flour”) // shoppingList now contains 3 items, and someone is making pancakes}

_{In alternativa puoi utilizzare gli operatori di addizione (+=):}

_{shoppingList += “Baking Powder” // shoppingList now contains 4 items}

Puoi anche aggiungere ad una lista un’altra lista contenente valori di tipo compatibile, sempre utilizzando i seguenti operatori (+=):

_{shoppingList += [“Chocolate Spread”, “Cheese”, “Butter”] // shoppingList now contains 7 items}

Per leggere un valore in una data posizione, basta agire come nel seguente esempio. Notare che lo zero indica la prima posizione in una lista, quindi 1 indica la seconda posizione (in swift le liste sono “zero-indexed”:

_{var firstItem = shoppingList[0] // firstItem is equal to “Eggs”}

Puoi utilizzare questa sintassi per sostituire un valore in una data posizione:

_{shoppingList[0] = “Six eggs” // the first item in the list is now equal to “Six eggs” rather than “Eggs”}

Puoi anche cambiare un range di valori per volta, anche se la lunghezza del range e il numero di valori che vuoi modificare sono diversi. nel seguente esempio sostituiamo “Chocolate Spread”, “Cheese”, and “Butter” con “Bananas” and “Apples”:

_{shoppingList[4…6] = [“Bananas”, “Apples”] // shoppingList now contains 6 items”}

Per inserire un elemento in una specifica posizione di una lista, chiamiamo la posizione con il metodo (atIndex:) :

_{shoppingList.insert(“Maple Syrup”, atIndex: 0) // shoppingList now contains 7 items // “Maple Syrup” is now the first item in the list}

Questa chiamata inserisce il valore “Maple Syrup” nella prima posizione della lista, indicata con il valore 0 (zero).

Molto simile il metodo per rimuovere un valore in una data posizione: removeAtIndex method. Questo metodo rimuove un valore nella posizione specificata e restituisce il valore eliminato (se non hai bisogno del valore eliminato, puoi ignorarlo):

_{let mapleSyrup = shoppingList.removeAtIndex(0) // the item that was at index 0 has just been removed // shoppingList now contains 6 items, and no Maple Syrup // the mapleSyrup constant is now equal to the removed “Maple Syrup” string}

Quando viene eliminato un valore, tutti gli altri cambiano di posizione, scalando di un posto. In questo caso, “Six eggs” arriva in posizione zero:

_{firstItem = shoppingList[0] // firstItem is now equal to “Six eggs”}

Se vuoi togliere il valore finale in una lista puoi utilizzare il metodo removeLast invece di removeAtIndex per evitare di richiamare il metodo che serve a contare le posizioni dei valori. Anche removeLast restituisce il valore eliminato:

<sub>let apples = shoppingList.removeLast()<br>// the last item in the array has just been removed<br>// shoppingList now contains 5 items, and no cheese<br>// the apples constant is now equal to the removed “Apples” string</sub>
‌

Question 11

Q

Iterating Over an Array

Answer

A

Attraverso un for-in loop puoi iterare tra tutti i valori contenuti in una lista:

_{for item in shoppingList { println(item) } // Six eggs // Milk // Flour // Baking Powder // Bananas}

Se necessiti che venga restituito,oltre al valore, anche il numero dell’indice di ogni valore stesso, puoi utilizzare la funzione enumerate function. Questo metodo restituisce una tupla contenente il valore stesso e il suo numero di indice. Puoi scomporre temporaneamente il contenuto della tupla in costanti o variabili, così da averle chiare a schermo:

_{for (index, value) in enumerate(shoppingList) { println(“Item (index + 1): (value)”) } // Item 1: Six eggs // Item 2: Milk // Item 3: Flour // Item 4: Baking Powder // Item 5: Bananas}

Question 12

Q

Enumerate

Answer

A

Se avete bisogno di aver stampato a video l’indice di ogni valore, potete utilizzare la funzione enumerate per scorrere l’array e veder ei vari indici. La funzione enumerate restituisce una tupla per ogni elemento della matrice composta dell’indice e dal valore di tale elemento. È possibile scomporre la tupla in costanti temporanee o variabili come parte dell’iterazione:

_{for (index, value) in enumerate(shoppingList) { println(“Item (index + 1): (value)”) } // Item 1: Six eggs // Item 2: Milk // Item 3: Flour // Item 4: Baking Powder // Item 5: Bananas}

‌
Creare ed inizializzare un’Array (lista)
Si può inizializzare un array (senza assegnargli un valore iniziale) specificandone il tipo:

_{var someInts = Int println(“someInts is of type Int[] with (someInts.count) items.”) // prints “someInts is of type Int[] with 0 items.}

Il valore di someInts dovrà essere intero, perchè così è stato dichiarato al momento dell’inizializzazione.

In alternativa, se il contesto permette di capire il tipo di dati che la lista andrà a contenere, si può creare una lista mettendo tra parentesi un valore e quella lista sarà dello stesso tipo del valore messo tra parentesi:

_{someInts.append(3) // someInts now contains 1 value of type Int someInts = [] // someInts is now an empty array, but is still of type Int[]}

Swift prevede anche l’inizializzazione di una lista di dimensioni date, per poi inserirvi dei valori di default, tutti dello stesso tipo. Nell’esempio seguente specificheremo che la lista sarà lunga 3 posizioni e conterrà valori double (virgola fissa) e la inizializziamo con 3 valori di default (0.0,0.0,0.0 usando repeatedValue):

_{var threeDoubles = Double // threeDoubles is of type Double[], and equals [0.0, 0.0, 0.0]}

_{Non c’è bisogno di specificare il tipo di dato per ogni array, in quanto verrà dedotto dal tipo dei valori di default inseriti:}

_{var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5) // anotherThreeDoubles is inferred as Double[], and equals [2.5, 2.5, 2.5]}

Infine si possono unire 2 array dello stesso tipo, utilizzando l’operatore di addizione (+). Il tipo della nuova lista che si andrà a creare sarà dedotto dal tipo delle 2 liste che sono state unite:

_{var sixDoubles = threeDoubles + anotherThreeDoubles // sixDoubles is inferred as Double[], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]}

Un dizionario è una lista che memorizza diversi valori, dello stesso tipo. A differenza degli Array, ogni valore è associato ad una chiave univoca, che funge da identificatore per il valore stesso. A differenza delle liste, nei dizionari i valori non hanno uno specifico ordine. Un dizionario viene utilizzato quando c’è bisogno di richiamare i valori attraverso la loro chiave, come accade nel mondo reale con un dizionario in cui si cercano le definizioni scorrendo le parole (che in questo caso sono le chiavi).

In Swift i dizionari (come le liste) possono memorizzare solamente un tipo specifico di dati. Differiscono dalle classi NSDictionary e NSMutableDictionary in Objective-C, che possono memorizzare qualsiasi tipo di dato e le loro chiavi possono essere anche di tipi diversi. In Swift, il tipo di dato da memorizzare è sempre chiaro, sia se viene specificato al momento dell’inizializzazione, sia se viene dedotto dal compilatore.

In Swift i dizionari hanno questa forma <keytype>, dove KeyType è il tipo che può essere utilizzato per le chiavi, e ValueType è il tipo di dato che il dizionario può memorizzare in corrispondenza di ogni chiave.</keytype>

Question 13

Q

Dictionary Literals

Answer

A

Come per gli array, c’è un modo per inizializzare velocemente i dizionari, specificando una coppia chiave – valore.

Una coppia chiave valore è un oggetto del tipo chiave:valore. Si può procedere come nell’esempio seguente:

_{[key 1: value 1, key 2: value 2, key 3: value 3]}

In questo esempio si memorizzano le chiavi e i nomi di diversi aeroporti. In questo dizionario, le chiavi sono un identificativo dell’aeroporto e il valore è il nome completo dell’aeroporto stesso:

_{var airports: Dictionary<string> = [“TYO”: “Tokyo”, “DUB”: “Dublin”]</string>}

Il tipo del dizionario precedente è string sia per i dati che per le chiavi <string>.</string>

Come con gli array, non è necessario scrivere il tipo di dizionario se lo inizializzate con dati di tipo coerente. Avreste potuto inizializzare questo dizionario anche in forma breve:

_{var airports = [“TYO”: “Tokyo”, “DUB”: “Dublin”]}

Visto che tutti i valori sono dello stesso tipo, Swift può dedurre che la forma corretta per questo dizionario è proprio Dictionary<string>.</string>

Accedere ad un dizionario e modificarne i valori
È possibile accedere ai dati e modificare un dizionario attraverso i suoi metodi e proprietà. Come con una matrice, è possibile scoprire il numero di elementi in un dizionario con la proprietà count:

_{println(“The dictionary of airports contains (airports.count) items.”) // prints “The dictionary of airports contains 2 items.}

È possibile aggiungere un nuovo elemento a un dizionario con la sintassi seguente. Utilizzare una nuova chiave di tipo appropriato come indice, ed assegnare un nuovo valore del tipo appropriato:

_{airports[“LHR”] = “London” // the airports dictionary now contains 3 items}

Si può utilizzare la stessa sintassi per modificare un valore associato ad una chiave precisa:

_{airports[“LHR”] = “London Heathrow” // the value for “LHR” has been changed to “London Heathrow}

In alternativa all’indicizzazione, utilizzare il metodo UpdateValue di un dizionario (Forkey) per impostare o aggiornare il valore di una chiave specifica. Come gli esempi di cui sopra, il metodo UpdateValue (Forkey) imposta un valore per una chiave se non esistente, o aggiorna il valore se quella chiave esiste già. A differenza di un pedice, tuttavia, il metodo UpdateValue (Forkey) restituisce il valore precedente dopo aver eseguito un aggiornamento. Ciò consente di verificare se il valore è stato aggiornato correttamente.

Il metodo UpdateValue (Forkey) restituisce un valore facoltativo dello stesso tipo del dizionario. Per un dizionario che archivia valori string, ad esempio, il metodo restituisce un valore di tipo String?, O “optional String”. Questo valore opzionale contiene il vecchio valore per quella chiave (se il valore esiste prima dell’aggiornamento) o nullo se il valore non esiste:

_{if let oldValue = airports.updateValue(“Dublin International”, forKey: “DUB”) { println(“The old value for DUB was (oldValue).”) } // prints “The old value for DUB was Dublin.}

È inoltre possibile utilizzare questa sintassi per recuperare un valore dal dizionario per una chiave specifica. Poiché è possibile richiamare una chiave per la quale non esiste alcun valore, indice di un dizionario restituisce un valore facoltativo dello stesso tipo del dizionario. Se il dizionario contiene un valore per la chiave richiesta, si comporta in questo modo:

_{if let airportName = airports[“DUB”] { println(“The name of the airport is (airportName).”) } else { println(“That airport is not in the airports dictionary.”) } // prints “The name of the airport is Dublin International.}

È possibile inoltre utilizzare la stessa sintassi per rimuovere una coppia chiave-valore da un dizionario assegnando un valore pari a zero per quella chiave:

_{airports[“APL”] = “Apple International” // “Apple International” is not the real airport for APL, so delete it airports[“APL”] = nil // APL has now been removed from the dictionary}

In alternativa, si può rimuovere una coppia chiave-valore da un dizionario con il metodo removeValueForKey. Questo metodo rimuove la coppia chiave-valore(se esiste) e restituisce il valore rimosso, o ritorna un valore nullo se la chiave non ha alcun valore associato:

<sub>if let removedValue = airports.removeValueForKey(“DUB”) {<br>println(“The removed airport’s name is \(removedValue).”)<br>} else {<br>println(“The airports dictionary does not contain a value for DUB.”)<br>}<br>// prints “The removed airport’s name is Dublin International.</sub>
‌

Iterare in un dizionario
È possibile scorrere le coppie chiave-valore in un dizionario con un ciclo for-in. Ogni elemento del dizionario viene restituito nella tupla (chiave, valore), e si scompongono i membri della tupla in costanti temporanee o variabili come parte dell’ iterazione:

_{for (airportCode, airportName) in airports { println(“(airportCode): (airportName)”) } // TYO: Tokyo // LHR: London Heathrow For more about the for-in loop, see For Loops.}

È inoltre possibile recuperare una collezione di chiavi o valori di un dizionario:

_{for airportCode in airports.keys { println(“Airport code: (airportCode)”) } // Airport code: TYO // Airport code: LHR}

_{for airportName in airports.values { println(“Airport name: (airportName)”) } // Airport name: Tokyo // Airport name: London Heathrow}

Se avete bisogno di usare chiavi o valori di un dizionario con un’ API che accetta un’istanza di un Array, si può inizializzare un nuovo array con le sue chiavi o valori:

_{let airportCodes = Array(airports.keys) // airportCodes is [“TYO”, “LHR”]}

_{let airportNames = Array(airports.values) // airportNames is [“Tokyo”, “London Heathrow”]}

Question 14

Q

Creare un dizionario vuoto

Answer

A

Come per le liste, puoi creare un dizionario vuoto di uno specifico tipo utilizzando la seguente sintassi:

_{var namesOfIntegers = Dictionary<int>() // namesOfIntegers is an empty Dictionary<int></int></int>}

Questo esempio crea un dizionario vuoto di tipo Int, String per memorizzare i nomi richiamabili da valori interi. Le sue chiavi sono di tipo Int, e i suoi valori sono di tipo String.

Se il contesto già fornisce informazioni sul tipo, si può creare un dizionario vuoto, che viene scritto come [:] (due punti all’interno di parentesi quadre):

_{namesOfIntegers[16] = “sixteen” // namesOfIntegers now contains 1 key-value pair namesOfIntegers = [:] // namesOfIntegers is once again an empty dictionary of type Int, String}

‌

Matrici e dizionari permettono di memorizzare vari valori in una sorta di “collezione”. Se si crea un array o un dizionario e gli si assegna una variabile, la collezione creata sarà mutevole. Ciò significa che è possibile cambiare (o mutare) la sua dimensione dopo che è stato creato con l’aggiunta di altri elementi, o eliminando voci esistenti da quelle che esso contiene già. Al contrario, se si assegna a un array o ad un dizionario una costante, tale matrice o dizionario è immutabile, e la sua dimensione non può essere modificata.

Per i dizionari, immutabilità significa anche che non è possibile sostituire il valore di una chiave esistente nel dizionario. Il contenuto di un dizionario immutabile non può essere cambiato una volta che è stato inizializzato.

Brainscape's Knowledge GenomeTM

BASI Flashcards

Brainscape's Knowledge Genome^TM