Swift Academy · Lezione

Inferenza dei tipi e tipi espliciti

Scopra come Swift deduce i tipi e quando dichiararli esplicitamente.

Inferenza dei tipi e tipi espliciti è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Benvenuti

Swift è un linguaggio *staticamente tipizzato*: ogni valore ha un tipo noto in fase di compilazione. Tuttavia, raramente è necessario scrivere personalmente il tipo, perché Swift lo deduce automaticamente.

Che cos'è l'inferenza dei tipi?

Swift esamina il valore a destra dell'assegnazione e deduce automaticamente il tipo: ```swift let message = "Hello" // inferred as String let count = 42 // inferred as Int let price = 9.99 // inferred as Double ``` Non è necessaria alcuna annotazione del tipo: il compilatore lo determina automaticamente.

Annotazioni esplicite del tipo

Può sempre specificare esplicitamente il tipo utilizzando i due punti: ```swift let message: String = "Hello" let count: Int = 42 let price: Double = 9.99 ``` È utile quando il tipo dedotto non è quello desiderato.

Quando l'inferenza sceglie il tipo sbagliato

I letterali in virgola mobile hanno `Double` come tipo predefinito. Se le serve `Float`, specifichi il tipo in modo esplicito: ```swift let inferred = 3.14 // Double let explicit: Float = 3.14 // Float ``` Analogamente, i letterali interi hanno `Int` come tipo predefinito: specifichi il tipo per ottenere `Int32`, `UInt8` e così via.

La sicurezza dei tipi nella pratica

Una volta impostato, un tipo non può cambiare: ```swift var score = 0 // Int score = "ten" // ❌ cannot assign String to Int ``` La sicurezza dei tipi rileva questa categoria di bug in fase di compilazione, molto prima dell'esecuzione.

La funzione type(of:)

Utilizzi `type(of:)` per esaminare il tipo a runtime: ```swift let value = 42 print(type(of: value)) // Int let name = "Alice" print(type(of: name)) // String ``` È utile per eseguire il debug dei casi in cui l'inferenza dei tipi produce risultati inattesi.

Alias di tipo

`typealias` assegna un nuovo nome a un tipo esistente per migliorare la leggibilità: ```swift typealias Celsius = Double typealias UserID = Int var temperature: Celsius = 36.6 var userId: UserID = 1001 ``` Gli alias di tipo sono puramente cosmetici: il tipo sottostante non cambia.

Annotazioni senza inizializzazione

Quando dichiara una variabile senza un valore iniziale, *deve* specificarne il tipo: ```swift var name: String // ✓ annotation required name = "Bob" var total: Int total = 0 ``` Senza un valore presente, Swift non ha modo di dedurre il tipo.

Letterali numerici e leggibilità

Swift consente di utilizzare caratteri di sottolineatura nei letterali numerici per migliorarne la leggibilità: ```swift let million = 1_000_000 let hex = 0xFF_EC_D3 let binary = 0b1111_0000 ``` Il compilatore ignora i caratteri di sottolineatura: sono puramente cosmetici.

Conversione dei tipi — nessuna conversione implicita

Swift non converte mai implicitamente un tipo in un altro. Deve eseguire la conversione in modo esplicito: ```swift let intVal: Int = 5 let dblVal: Double = Double(intVal) // explicit conversion let sum = Double(intVal) + 2.5 ``` In questo modo si evitano bug difficili da individuare causati da promozioni numeriche indesiderate.

Verifica rapida

Quale tipo deduce Swift per `let x = 3.14`?

Riepilogo

Concetti chiave: • Swift deduce i tipi dai valori iniziali: di solito non è necessaria alcuna annotazione • Le annotazioni esplicite (`: Type`) sostituiscono l'inferenza • I numeri in virgola mobile hanno `Double` come tipo predefinito, gli interi `Int` • Non esistono conversioni implicite: utilizzi `Int()`, `Double()` e così via • `type(of:)` mostra il tipo a runtime Prossimo argomento: i tipi fondamentali — numeri, Bool e Character.

Domande Frequenti

La lezione «Inferenza dei tipi e tipi espliciti» è gratuita?

Sì — il testo completo di «Inferenza dei tipi e tipi espliciti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Inferenza dei tipi e tipi espliciti»?

Scopra come Swift deduce i tipi e quando dichiararli esplicitamente. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Inferenza dei tipi e tipi espliciti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

let e var: costanti e variabili
Inferenza dei tipi e tipi espliciti
Numeri, valori booleani e caratteri
Fondamenti delle stringhe e interpolazione

← Torna a Swift Academy