> For the complete documentation index, see [llms.txt](https://swift.unicorndonkeys.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://swift.unicorndonkeys.com/guida-al-linguaggio/tipi-collezione.md). # Tipi collezione (Collection Types) Organizza i dati usando array, set e dizionari. Swift fornisce tre *tipi collezione* principali, noti come array, set e dizionari, per memorizzare collezioni di valori. Gli array sono collezioni ordinate di valori. I set sono collezioni non ordinate di valori unici. I dizionari sono collezioni non ordinate di associazioni chiave-valore. ![](https://3581893755-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNzatREGwodw9Z93LQYJb%2Fuploads%2FNDMrQjB4ShpSGouCodih%2FCollectionTypes_intro%402x.png?alt=media) Array, set e dizionari in Swift sono sempre chiari riguardo ai tipi di valori e di chiavi che possono memorizzare. Ciò significa che non puoi inserire per errore un valore del tipo sbagliato in una collezione. Significa anche che puoi essere sicuro del tipo dei valori che recupererai da una collezione. {% hint style="info" %} **Nota:** I tipi array, set e dizionario di Swift sono implementati come *collezioni generiche*. Per saperne di più su tipi e collezioni generici, vedi [Generici](/guida-al-linguaggio/generici.md). {% endhint %} ## Mutabilità delle collezioni Se crei un array, un set o un dizionario e lo assegni a una variabile, la collezione creata sarà *mutabile*. Ciò significa che puoi modificare (o *mutare*) la collezione dopo che è stata creata aggiungendo, rimuovendo o modificando gli elementi nella collezione. Se assegni un array, un set o un dizionario a una costante, quella collezione è *immutabile*, e la sua dimensione e il suo contenuto non possono essere modificati. {% hint style="info" %} **Nota:** È buona pratica creare collezioni immutabili in tutti i casi in cui la collezione non ha bisogno di cambiare. Farlo ti rende più facile ragionare sul tuo codice e permette al compilatore Swift di ottimizzare le prestazioni delle collezioni che crei. {% endhint %} ## Array Un *array* memorizza valori dello stesso tipo in un elenco ordinato. Lo stesso valore può comparire in un array più volte in posizioni diverse. {% hint style="info" %} **Nota:** Il tipo `Array` di Swift è collegato (bridged) alla classe `NSArray` di Foundation. Per maggiori informazioni sull'uso di `Array` con Foundation e Cocoa, vedi [Bridging Between Array and NSArray](https://developer.apple.com/documentation/swift/array#Bridging-Between-Array-and-NSArray). {% endhint %} ### Sintassi abbreviata del tipo array Il tipo di un array Swift si scrive per esteso come `Array`, dove `Element` è il tipo dei valori che l'array può memorizzare. Puoi anche scrivere il tipo di un array in forma abbreviata come `[Element]`. Sebbene le due forme siano funzionalmente identiche, la forma abbreviata è preferita ed è usata in tutta questa guida quando ci si riferisce al tipo di un array. ### Creare un array vuoto In Swift puoi creare un array vuoto usando due approcci. Se il contesto fornisce già informazioni di tipo, come un argomento di funzione o una variabile o costante già tipizzata, puoi usare un letterale array vuoto, che si scrive `[]` (una coppia vuota di parentesi quadre): ```swift var someInts: [Int] = [] print("someInts is of type [Int] with \(someInts.count) items.") // Stampa "someInts is of type [Int] with 0 items." ``` In alternativa, puoi creare un array vuoto di un certo tipo usando la sintassi esplicita di inizializzazione, scrivendo il tipo degli elementi tra parentesi quadre seguito da parentesi tonde — per esempio, `[Int]()` in quanto segue: ```swift var someInts = [Int]() print("someInts is of type [Int] with \(someInts.count) items.") // Stampa "someInts is of type [Int] with 0 items." ``` Entrambi gli approcci producono lo stesso risultato. Tuttavia, un letterale array vuoto è più breve e di solito più facile da leggere. In entrambi i casi, puoi usare il letterale array vuoto (`[]`) per riassegnare un array vuoto a una variabile esistente: ```swift someInts.append(3) // someInts ora contiene 1 valore di tipo Int someInts = [] // someInts ora è un array vuoto, ma è ancora di tipo [Int] ``` ### Creare un array con un valore predefinito Il tipo `Array` di Swift fornisce anche un inizializzatore per creare un array di una certa dimensione con tutti i suoi valori impostati allo stesso valore predefinito. A questo inizializzatore passi un valore predefinito del tipo appropriato (chiamato `repeating`): e il numero di volte in cui quel valore viene ripetuto nel nuovo array (chiamato `count`): ```swift var threeDoubles = Array(repeating: 0.0, count: 3) // threeDoubles è di tipo [Double], ed è uguale a [0.0, 0.0, 0.0] ``` ### Creare un array sommando due array Puoi creare un nuovo array sommando due array esistenti con tipi compatibili tramite l'operatore di addizione (`+`). Il tipo del nuovo array viene inferito dal tipo dei due array che sommi: ```swift var anotherThreeDoubles = Array(repeating: 2.5, count: 3) // anotherThreeDoubles è di tipo [Double], ed è uguale a [2.5, 2.5, 2.5] var sixDoubles = threeDoubles + anotherThreeDoubles // sixDoubles viene inferito come [Double], ed è uguale a [0.0, 0.0, 0.0, 2.5, 2.5, 2.5] ``` ### Creare un array con un letterale array Puoi anche inizializzare un array con un *letterale array*, che è un modo abbreviato per scrivere uno o più valori come una collezione array. Un letterale array si scrive come un elenco di valori, separati da virgole, racchiuso da una coppia di parentesi quadre: ```swift [<#value 1#>, <#value 2#>, <#value 3#>] ``` L'esempio seguente crea un array chiamato `shoppingList` per memorizzare valori `String`: ```swift var shoppingList: [String] = ["Eggs", "Milk"] // shoppingList è stato inizializzato con due elementi iniziali ``` La variabile `shoppingList` è dichiarata come “un array di valori stringa”, scritto `[String]`. Poiché questo particolare array ha specificato un tipo di valore `String`, può memorizzare solo valori `String`. Qui, l'array `shoppingList` viene inizializzato con due valori `String` (`"Eggs"` e `"Milk"`), scritti all'interno di un letterale array. {% hint style="info" %} **Nota:** L'array `shoppingList` è dichiarato come variabile (con l'introduttore `var`) e non come costante (con l'introduttore `let`) perché negli esempi seguenti vengono aggiunti altri elementi alla lista della spesa. {% endhint %} In questo caso, il letterale array contiene due valori `String` e nient'altro. Questo corrisponde al tipo della dichiarazione della variabile `shoppingList` (un array che può contenere solo valori `String`), e quindi l'assegnamento del letterale array è consentito come modo per inizializzare `shoppingList` con due elementi iniziali. Grazie all'inferenza di tipo di Swift, non devi scrivere il tipo dell'array se lo stai inizializzando con un letterale array contenente valori dello stesso tipo. L'inizializzazione di `shoppingList` avrebbe potuto essere scritta invece in forma più breve: ```swift var shoppingList = ["Eggs", "Milk"] ``` Poiché tutti i valori del letterale array sono dello stesso tipo, Swift può inferire che `[String]` è il tipo corretto da usare per la variabile `shoppingList`. Puoi includere una virgola dopo l'ultimo valore di un letterale array, nota come *virgola finale* (trailing comma): ```swift var shoppingList = [ "Eggs", "Milk", ] ``` Poiché la virgola finale fa terminare ogni riga nello stesso modo, è un modo utile per scrivere array come quello qui sopra che hanno un valore per riga. Quando modifichi l'array, devi solo aggiungere, rimuovere o riordinare i valori — non devi aggiungere o rimuovere virgole. ### Accedere a un array e modificarlo Accedi a un array e lo modifichi tramite i suoi metodi e le sue proprietà, oppure usando la sintassi dei subscript. Per conoscere il numero di elementi di un array, controlla la sua proprietà di sola lettura `count`: ```swift print("The shopping list contains \(shoppingList.count) items.") // Stampa "The shopping list contains 2 items." ``` Usa la proprietà booleana `isEmpty` come scorciatoia per verificare se la proprietà `count` è uguale a `0`: ```swift if shoppingList.isEmpty { print("The shopping list is empty.") } else { print("The shopping list isn't empty.") } // Stampa "The shopping list isn't empty." ``` Puoi aggiungere un nuovo elemento alla fine di un array chiamando il metodo `append(_:)` dell'array: ```swift shoppingList.append("Flour") // shoppingList ora contiene 3 elementi, e qualcuno sta preparando dei pancake ``` In alternativa, aggiungi un array di uno o più elementi compatibili con l'operatore di assegnamento con addizione (`+=`): ```swift shoppingList += ["Baking Powder"] // shoppingList ora contiene 4 elementi shoppingList += ["Chocolate Spread", "Cheese", "Butter"] // shoppingList ora contiene 7 elementi ``` Recupera un valore dall'array usando la *sintassi dei subscript*, passando l'indice del valore che vuoi recuperare tra parentesi quadre subito dopo il nome dell'array: ```swift var firstItem = shoppingList[0] // firstItem è uguale a "Eggs" ``` {% hint style="info" %} **Nota:** Il primo elemento dell'array ha indice `0`, non `1`. Gli array in Swift hanno sempre indici a base zero. {% endhint %} Puoi usare la sintassi dei subscript per modificare un valore esistente a un dato indice: ```swift shoppingList[0] = "Six eggs" // il primo elemento della lista ora è uguale a "Six eggs" anziché a "Eggs" ``` Quando usi la sintassi dei subscript, l'indice che specifichi deve essere valido. Per esempio, scrivere `shoppingList[shoppingList.count] = "Salt"` per provare ad aggiungere un elemento alla fine dell'array produce un errore in fase di esecuzione. Puoi anche usare la sintassi dei subscript per modificare un intervallo di valori contemporaneamente, anche se l'insieme di valori sostitutivi ha una lunghezza diversa dall'intervallo che stai sostituendo. L'esempio seguente sostituisce `"Chocolate Spread"`, `"Cheese"` e `"Butter"` con `"Bananas"` e `"Apples"`: ```swift shoppingList[4...6] = ["Bananas", "Apples"] // shoppingList ora contiene 6 elementi ``` Per inserire un elemento nell'array a un indice specificato, chiama il metodo `insert(_:at:)` dell'array: ```swift shoppingList.insert("Maple Syrup", at: 0) // shoppingList ora contiene 7 elementi // "Maple Syrup" ora è il primo elemento della lista ``` Questa chiamata al metodo `insert(_:at:)` inserisce un nuovo elemento con valore `"Maple Syrup"` all'inizio della lista della spesa, indicato da un indice pari a `0`. Analogamente, rimuovi un elemento dall'array con il metodo `remove(at:)`. Questo metodo rimuove l'elemento all'indice specificato e restituisce l'elemento rimosso (anche se puoi ignorare il valore restituito se non ti serve): ```swift let mapleSyrup = shoppingList.remove(at: 0) // l'elemento che si trovava all'indice 0 è appena stato rimosso // shoppingList ora contiene 6 elementi, e niente sciroppo d'acero // la costante mapleSyrup ora è uguale alla stringa rimossa "Maple Syrup" ``` {% hint style="info" %} **Nota:** Se provi ad accedere o a modificare un valore per un indice che si trova al di fuori dei limiti esistenti di un array, attiverai un errore in fase di esecuzione. Puoi verificare che un indice sia valido prima di usarlo confrontandolo con la proprietà `count` dell'array. L'indice valido più grande di un array è `count - 1` perché gli array sono indicizzati a partire da zero — tuttavia, quando `count` è `0` (il che significa che l'array è vuoto), non esistono indici validi. {% endhint %} Qualsiasi vuoto in un array viene colmato quando un elemento viene rimosso, e quindi il valore all'indice `0` è di nuovo uguale a `"Six eggs"`: ```swift firstItem = shoppingList[0] // firstItem ora è uguale a "Six eggs" ``` Se vuoi rimuovere l'ultimo elemento da un array, usa il metodo `removeLast()` anziché il metodo `remove(at:)` per evitare di dover interrogare la proprietà `count` dell'array. Come il metodo `remove(at:)`, `removeLast()` restituisce l'elemento rimosso: ```swift let apples = shoppingList.removeLast() // l'ultimo elemento dell'array è appena stato rimosso // shoppingList ora contiene 5 elementi, e niente mele // la costante apples ora è uguale alla stringa rimossa "Apples" ``` ### Iterare su un array Puoi iterare sull'intero insieme di valori di un array con il ciclo `for`-`in`: ```swift for item in shoppingList { print(item) } // Six eggs // Milk // Flour // Baking Powder // Bananas ``` Se hai bisogno dell'indice intero di ciascun elemento oltre al suo valore, usa invece il metodo `enumerated()` per iterare sull'array. Per ciascun elemento dell'array, il metodo `enumerated()` restituisce una tupla composta da un intero e dall'elemento. Gli interi partono da zero e aumentano di uno per ciascun elemento; se enumeri un intero array, questi interi corrispondono agli indici degli elementi. Puoi scomporre la tupla in costanti o variabili temporanee come parte dell'iterazione: ```swift for (index, value) in shoppingList.enumerated() { print("Item \(index + 1): \(value)") } // Item 1: Six eggs // Item 2: Milk // Item 3: Flour // Item 4: Baking Powder // Item 5: Bananas ``` Per saperne di più sul ciclo `for`-`in`, vedi [Cicli for-in](/guida-al-linguaggio/flusso-di-controllo.md#cicli-for-in). ## Set Un *set* memorizza valori distinti dello stesso tipo in una collezione priva di un ordinamento definito. Puoi usare un set invece di un array quando l'ordine degli elementi non è importante, o quando devi garantire che un elemento compaia una sola volta. {% hint style="info" %} **Nota:** Il tipo `Set` di Swift è collegato (bridged) alla classe `NSSet` di Foundation. Per maggiori informazioni sull'uso di `Set` con Foundation e Cocoa, vedi [Bridging Between Set and NSSet](https://developer.apple.com/documentation/swift/set#Bridging-Between-Set-and-NSSet). {% endhint %} ### Valori hash per i tipi set Un tipo deve essere *hashable* per poter essere memorizzato in un set — cioè, il tipo deve fornire un modo per calcolare un *valore hash* per sé stesso. Un valore hash è un valore `Int` che è lo stesso per tutti gli oggetti che risultano uguali nel confronto, in modo tale che se `a == b`, il valore hash di `a` sia uguale al valore hash di `b`. Tutti i tipi di base di Swift (come `String`, `Int`, `Double` e `Bool`) sono hashable per impostazione predefinita, e possono essere usati come tipi di valore di un set o come tipi di chiave di un dizionario. Anche i valori dei casi di enumerazione privi di valori associati (come descritto in [Enumerazioni](/guida-al-linguaggio/enumerazioni.md)) sono hashable per impostazione predefinita. {% hint style="info" %} **Nota:** Puoi usare i tuoi tipi personalizzati come tipi di valore di un set o tipi di chiave di un dizionario rendendoli conformi al protocollo `Hashable` della libreria standard di Swift. Per informazioni sull'implementazione del metodo richiesto `hash(into:)`, vedi [`Hashable`](https://developer.apple.com/documentation/swift/hashable). Per informazioni sulla conformità ai protocolli, vedi [Protocolli](/guida-al-linguaggio/protocolli.md). {% endhint %} ### Sintassi del tipo set Il tipo di un set Swift si scrive `Set`, dove `Element` è il tipo che il set può memorizzare. A differenza degli array, i set non hanno una forma abbreviata equivalente. ### Creare e inizializzare un set vuoto Puoi creare un set vuoto di un certo tipo usando la sintassi di inizializzazione: ```swift var letters = Set() print("letters is of type Set with \(letters.count) items.") // Stampa "letters is of type Set with 0 items." ``` {% hint style="info" %} **Nota:** Il tipo della variabile `letters` viene inferito come `Set`, dal tipo dell'inizializzatore. {% endhint %} In alternativa, se il contesto fornisce già informazioni di tipo, come un argomento di funzione o una variabile o costante già tipizzata, puoi creare un set vuoto con un letterale array vuoto: ```swift letters.insert("a") // letters ora contiene 1 valore di tipo Character letters = [] // letters ora è un set vuoto, ma è ancora di tipo Set ``` ### Creare un set con un letterale array Puoi anche inizializzare un set con un letterale array, come modo abbreviato per scrivere uno o più valori come una collezione set. L'esempio seguente crea un set chiamato `favoriteGenres` per memorizzare valori `String`: ```swift var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"] // favoriteGenres è stato inizializzato con tre elementi iniziali ``` La variabile `favoriteGenres` è dichiarata come “un set di valori `String`”, scritto `Set`. Poiché questo particolare set ha specificato un tipo di valore `String`, può memorizzare *solo* valori `String`. Qui, il set `favoriteGenres` viene inizializzato con tre valori `String` (`"Rock"`, `"Classical"` e `"Hip hop"`), scritti all'interno di un letterale array. {% hint style="info" %} **Nota:** Il set `favoriteGenres` è dichiarato come variabile (con l'introduttore `var`) e non come costante (con l'introduttore `let`) perché negli esempi seguenti vengono aggiunti e rimossi elementi. {% endhint %} Un tipo set non può essere inferito da un letterale array da solo, quindi il tipo `Set` deve essere dichiarato esplicitamente. Tuttavia, grazie all'inferenza di tipo di Swift, non devi scrivere il tipo degli elementi del set se lo stai inizializzando con un letterale array che contiene valori di un solo tipo. L'inizializzazione di `favoriteGenres` avrebbe potuto essere scritta invece in forma più breve: ```swift var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"] ``` Poiché tutti i valori del letterale array sono dello stesso tipo, Swift può inferire che `Set` è il tipo corretto da usare per la variabile `favoriteGenres`. ### Accedere a un set e modificarlo Accedi a un set e lo modifichi tramite i suoi metodi e le sue proprietà. Per conoscere il numero di elementi di un set, controlla la sua proprietà di sola lettura `count`: ```swift print("I have \(favoriteGenres.count) favorite music genres.") // Stampa "I have 3 favorite music genres." ``` Usa la proprietà booleana `isEmpty` come scorciatoia per verificare se la proprietà `count` è uguale a `0`: ```swift if favoriteGenres.isEmpty { print("As far as music goes, I'm not picky.") } else { print("I have particular music preferences.") } // Stampa "I have particular music preferences." ``` Puoi aggiungere un nuovo elemento a un set chiamando il metodo `insert(_:)` del set: ```swift favoriteGenres.insert("Jazz") // favoriteGenres ora contiene 4 elementi ``` Puoi rimuovere un elemento da un set chiamando il metodo `remove(_:)` del set, che rimuove l'elemento se è un membro del set, e restituisce il valore rimosso, oppure restituisce `nil` se il set non lo conteneva. In alternativa, tutti gli elementi di un set possono essere rimossi con il suo metodo `removeAll()`. ```swift if let removedGenre = favoriteGenres.remove("Rock") { print("\(removedGenre)? I'm over it.") } else { print("I never much cared for that.") } // Stampa "Rock? I'm over it." ``` Per verificare se un set contiene un particolare elemento, usa il metodo `contains(_:)`. ```swift if favoriteGenres.contains("Funk") { print("I get up on the good foot.") } else { print("It's too funky in here.") } // Stampa "It's too funky in here." ``` ### Iterare su un set Puoi iterare sui valori di un set con un ciclo `for`-`in`. ```swift for genre in favoriteGenres { print("\(genre)") } // Classical // Jazz // Hip hop ``` Per saperne di più sul ciclo `for`-`in`, vedi [Cicli for-in](/guida-al-linguaggio/flusso-di-controllo.md#cicli-for-in). Il tipo `Set` di Swift non ha un ordinamento definito. Per iterare sui valori di un set in un ordine specifico, usa il metodo `sorted()`, che restituisce gli elementi del set come un array ordinato usando l'operatore `<`. ```swift for genre in favoriteGenres.sorted() { print("\(genre)") } // Classical // Hip hop // Jazz ``` ## Eseguire operazioni sui set Puoi eseguire in modo efficiente le operazioni fondamentali sui set, come combinare due set, determinare quali valori due set hanno in comune, o determinare se due set contengono tutti, alcuni o nessuno degli stessi valori. ### Operazioni fondamentali sui set L'illustrazione seguente raffigura due set — `a` e `b` — con i risultati di varie operazioni sui set rappresentati dalle regioni ombreggiate. ![](https://3581893755-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNzatREGwodw9Z93LQYJb%2Fuploads%2FIJ9AENMg7xCNKPzWiiLY%2FsetVennDiagram%402x.png?alt=media) * Usa il metodo `intersection(_:)` per creare un nuovo set con i soli valori comuni a entrambi i set. * Usa il metodo `symmetricDifference(_:)` per creare un nuovo set con i valori presenti in uno dei due set, ma non in entrambi. * Usa il metodo `union(_:)` per creare un nuovo set con tutti i valori di entrambi i set. * Usa il metodo `subtracting(_:)` per creare un nuovo set con i valori non presenti nel set specificato. ```swift let oddDigits: Set = [1, 3, 5, 7, 9] let evenDigits: Set = [0, 2, 4, 6, 8] let singleDigitPrimeNumbers: Set = [2, 3, 5, 7] oddDigits.union(evenDigits).sorted() // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] oddDigits.intersection(evenDigits).sorted() // [] oddDigits.subtracting(singleDigitPrimeNumbers).sorted() // [1, 9] oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted() // [1, 2, 9] ``` ### Appartenenza e uguaglianza tra set L'illustrazione seguente raffigura tre set — `a`, `b` e `c` — con regioni sovrapposte che rappresentano gli elementi condivisi tra i set. Il set `a` è un *superinsieme* del set `b`, perché `a` contiene tutti gli elementi di `b`. Viceversa, il set `b` è un *sottoinsieme* del set `a`, perché tutti gli elementi di `b` sono contenuti anche in `a`. Il set `b` e il set `c` sono *disgiunti* l'uno dall'altro, perché non hanno elementi in comune. ![](https://3581893755-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNzatREGwodw9Z93LQYJb%2Fuploads%2FadGN2niWrlOVBsZzj3v0%2FsetEulerDiagram%402x.png?alt=media) * Usa l'operatore “è uguale a” (`==`) per determinare se due set contengono tutti gli stessi valori. * Usa il metodo `isSubset(of:)` per determinare se tutti i valori di un set sono contenuti nel set specificato. * Usa il metodo `isSuperset(of:)` per determinare se un set contiene tutti i valori di un set specificato. * Usa i metodi `isStrictSubset(of:)` o `isStrictSuperset(of:)` per determinare se un set è un sottoinsieme o un superinsieme di un set specificato, ma non uguale a esso. * Usa il metodo `isDisjoint(with:)` per determinare se due set non hanno valori in comune. ```swift let houseAnimals: Set = ["🐶", "🐱"] let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"] let cityAnimals: Set = ["🐦", "🐭"] houseAnimals.isSubset(of: farmAnimals) // true farmAnimals.isSuperset(of: houseAnimals) // true farmAnimals.isDisjoint(with: cityAnimals) // true ``` ## Dizionari Un *dizionario* memorizza associazioni tra chiavi dello stesso tipo e valori dello stesso tipo in una collezione priva di un ordinamento definito. Ogni valore è associato a una *chiave* univoca, che funge da identificatore per quel valore all'interno del dizionario. A differenza degli elementi di un array, gli elementi di un dizionario non hanno un ordine specificato. Usi un dizionario quando hai bisogno di cercare valori in base al loro identificatore, più o meno nello stesso modo in cui si usa un dizionario reale per cercare la definizione di una particolare parola. {% hint style="info" %} **Nota:** Il tipo `Dictionary` di Swift è collegato (bridged) alla classe `NSDictionary` di Foundation. Per maggiori informazioni sull'uso di `Dictionary` con Foundation e Cocoa, vedi [Bridging Between Dictionary and NSDictionary](https://developer.apple.com/documentation/swift/dictionary#Bridging-Between-Dictionary-and-NSDictionary). {% endhint %} ### Sintassi abbreviata del tipo dizionario Il tipo di un dizionario Swift si scrive per esteso come `Dictionary`, dove `Key` è il tipo di valore che può essere usato come chiave del dizionario, e `Value` è il tipo di valore che il dizionario memorizza per quelle chiavi. {% hint style="info" %} **Nota:** Il tipo `Key` di un dizionario deve essere conforme al protocollo `Hashable`, come il tipo di valore di un set. {% endhint %} Puoi anche scrivere il tipo di un dizionario in forma abbreviata come `[Key: Value]`. Sebbene le due forme siano funzionalmente identiche, la forma abbreviata è preferita ed è usata in tutta questa guida quando ci si riferisce al tipo di un dizionario. ### Creare un dizionario vuoto Come per gli array, puoi creare un `Dictionary` vuoto di un certo tipo usando la sintassi di inizializzazione: ```swift var namesOfIntegers: [Int: String] = [:] // namesOfIntegers è un dizionario [Int: String] vuoto ``` Questo esempio crea un dizionario vuoto di tipo `[Int: String]` per memorizzare nomi leggibili di valori interi. Le sue chiavi sono di tipo `Int`, e i suoi valori sono di tipo `String`. Se il contesto fornisce già informazioni di tipo, puoi creare un dizionario vuoto con un letterale dizionario vuoto, che si scrive `[:]` (due punti all'interno di una coppia di parentesi quadre): ```swift namesOfIntegers[16] = "sixteen" // namesOfIntegers ora contiene 1 coppia chiave-valore namesOfIntegers = [:] // namesOfIntegers è di nuovo un dizionario vuoto di tipo [Int: String] ``` ### Creare un dizionario con un letterale dizionario Puoi anche inizializzare un dizionario con un *letterale dizionario*, che ha una sintassi simile al letterale array visto in precedenza. Un letterale dizionario è un modo abbreviato per scrivere una o più coppie chiave-valore come una collezione `Dictionary`. Una *coppia chiave-valore* è la combinazione di una chiave e di un valore. In un letterale dizionario, la chiave e il valore di ciascuna coppia chiave-valore sono separati da due punti. Le coppie chiave-valore si scrivono come un elenco, separate da virgole, racchiuso da una coppia di parentesi quadre: ```swift [<#key 1#>: <#value 1#>, <#key 2#>: <#value 2#>, <#key 3#>: <#value 3#>] ``` L'esempio seguente crea un dizionario per memorizzare i nomi di aeroporti internazionali. In questo dizionario, le chiavi sono codici di tre lettere dell'International Air Transport Association, e i valori sono i nomi degli aeroporti: ```swift var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"] ``` Il dizionario `airports` è dichiarato con tipo `[String: String]`, che significa “un `Dictionary` le cui chiavi sono di tipo `String`, e i cui valori sono anch'essi di tipo `String`”. {% hint style="info" %} **Nota:** Il dizionario `airports` è dichiarato come variabile (con l'introduttore `var`), e non come costante (con l'introduttore `let`), perché negli esempi seguenti vengono aggiunti altri aeroporti al dizionario. {% endhint %} Il dizionario `airports` viene inizializzato con un letterale dizionario contenente due coppie chiave-valore. La prima coppia ha chiave `"YYZ"` e valore `"Toronto Pearson"`. La seconda coppia ha chiave `"DUB"` e valore `"Dublin"`. Questo letterale dizionario contiene due coppie `String: String`. Questo tipo chiave-valore corrisponde al tipo della dichiarazione della variabile `airports` (un dizionario con sole chiavi `String` e soli valori `String`), e quindi l'assegnamento del letterale dizionario è consentito come modo per inizializzare il dizionario `airports` con due elementi iniziali. Come per gli array, non devi scrivere il tipo del dizionario se lo stai inizializzando con un letterale dizionario le cui chiavi e i cui valori hanno tipi coerenti. L'inizializzazione di `airports` avrebbe potuto essere scritta invece in forma più breve: ```swift var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"] ``` Poiché tutte le chiavi del letterale sono dello stesso tipo tra loro, e analogamente tutti i valori sono dello stesso tipo tra loro, Swift può inferire che `[String: String]` è il tipo corretto da usare per il dizionario `airports`. Come i letterali array, i letterali dizionario possono includere una virgola finale dopo l'ultima coppia chiave-valore: ```swift var airports = [ "YYZ": "Toronto Pearson", "DUB": "Dublin", ] ``` ### Accedere a un dizionario e modificarlo Accedi a un dizionario e lo modifichi tramite i suoi metodi e le sue proprietà, oppure usando la sintassi dei subscript. Come per un array, conosci il numero di elementi di un `Dictionary` controllando la sua proprietà di sola lettura `count`: ```swift print("The airports dictionary contains \(airports.count) items.") // Stampa "The airports dictionary contains 2 items." ``` Usa la proprietà booleana `isEmpty` come scorciatoia per verificare se la proprietà `count` è uguale a `0`: ```swift if airports.isEmpty { print("The airports dictionary is empty.") } else { print("The airports dictionary isn't empty.") } // Stampa "The airports dictionary isn't empty." ``` Puoi aggiungere un nuovo elemento a un dizionario con la sintassi dei subscript. Usa una nuova chiave del tipo appropriato come indice del subscript, e assegna un nuovo valore del tipo appropriato: ```swift airports["LHR"] = "London" // il dizionario airports ora contiene 3 elementi ``` Puoi anche usare la sintassi dei subscript per modificare il valore associato a una particolare chiave: ```swift airports["LHR"] = "London Heathrow" // il valore per "LHR" è stato cambiato in "London Heathrow" ``` In alternativa ai subscript, usa il metodo `updateValue(_:forKey:)` di un dizionario per impostare o aggiornare il valore di una particolare chiave. Come negli esempi con i subscript qui sopra, il metodo `updateValue(_:forKey:)` imposta un valore per una chiave se non ne esiste uno, oppure aggiorna il valore se quella chiave esiste già. A differenza di un subscript, però, il metodo `updateValue(_:forKey:)` restituisce il *vecchio* valore dopo aver eseguito un aggiornamento. Questo ti permette di verificare se un aggiornamento è avvenuto o meno. Il metodo `updateValue(_:forKey:)` restituisce un valore opzionale del tipo di valore del dizionario. Per un dizionario che memorizza valori `String`, per esempio, il metodo restituisce un valore di tipo `String?`, ovvero “`String` opzionale”. Questo valore opzionale contiene il vecchio valore per quella chiave se ne esisteva uno prima dell'aggiornamento, oppure `nil` se non esisteva alcun valore: ```swift if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") { print("The old value for DUB was \(oldValue).") } // Stampa "The old value for DUB was Dublin." ``` Puoi anche usare la sintassi dei subscript per recuperare dal dizionario un valore per una particolare chiave. Poiché è possibile richiedere una chiave per cui non esiste alcun valore, il subscript di un dizionario restituisce un valore opzionale del tipo di valore del dizionario. Se il dizionario contiene un valore per la chiave richiesta, il subscript restituisce un valore opzionale contenente il valore esistente per quella chiave. Altrimenti, il subscript restituisce `nil`: ```swift if let airportName = airports["DUB"] { print("The name of the airport is \(airportName).") } else { print("That airport isn't in the airports dictionary.") } // Stampa "The name of the airport is Dublin Airport." ``` Puoi usare la sintassi dei subscript per rimuovere una coppia chiave-valore da un dizionario assegnando un valore `nil` a quella chiave: ```swift airports["APL"] = "Apple International" // "Apple International" non è il vero aeroporto per APL, quindi eliminalo airports["APL"] = nil // APL ora è stato rimosso dal dizionario ``` In alternativa, rimuovi una coppia chiave-valore da un dizionario con il metodo `removeValue(forKey:)`. Questo metodo rimuove la coppia chiave-valore se esiste e restituisce il valore rimosso, oppure restituisce `nil` se non esisteva alcun valore: ```swift if let removedValue = airports.removeValue(forKey: "DUB") { print("The removed airport's name is \(removedValue).") } else { print("The airports dictionary doesn't contain a value for DUB.") } // Stampa "The removed airport's name is Dublin Airport." ``` ### Iterare su un dizionario Puoi iterare sulle coppie chiave-valore di un dizionario con un ciclo `for`-`in`. Ogni elemento del dizionario viene restituito come una tupla `(key, value)`, e puoi scomporre i membri della tupla in costanti o variabili temporanee come parte dell'iterazione: ```swift for (airportCode, airportName) in airports { print("\(airportCode): \(airportName)") } // LHR: London Heathrow // YYZ: Toronto Pearson ``` Per saperne di più sul ciclo `for`-`in`, vedi [Cicli for-in](/guida-al-linguaggio/flusso-di-controllo.md#cicli-for-in). Puoi anche recuperare una collezione iterabile delle chiavi o dei valori di un dizionario accedendo alle sue proprietà `keys` e `values`: ```swift for airportCode in airports.keys { print("Airport code: \(airportCode)") } // Airport code: LHR // Airport code: YYZ for airportName in airports.values { print("Airport name: \(airportName)") } // Airport name: London Heathrow // Airport name: Toronto Pearson ``` Se hai bisogno di usare le chiavi o i valori di un dizionario con un'API che accetta un'istanza di `Array`, inizializza un nuovo array con la proprietà `keys` o `values`: ```swift let airportCodes = [String](airports.keys) // airportCodes è ["LHR", "YYZ"] let airportNames = [String](airports.values) // airportNames è ["London Heathrow", "Toronto Pearson"] ``` Il tipo `Dictionary` di Swift non ha un ordinamento definito. Per iterare sulle chiavi o sui valori di un dizionario in un ordine specifico, usa il metodo `sorted()` sulla sua proprietà `keys` o `values`.