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[](count: 3, repeatedValue: 0.0)
// 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, ValueType>, 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.

Dictionary Literals
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, String> = [“TYO”: “Tokyo”, “DUB”: “Dublin”]

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:

 

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

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”]

 

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

var namesOfIntegers = Dictionary<Int, String>()
// namesOfIntegers is an empty Dictionary<Int, String>

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.

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