Swift Cheat Sheet
Ultimo aggiornamento
Hello World e basi
Swift non richiede codice di contorno al livello principale: basta una riga per eseguire qualcosa.
| Operazione | Sintassi |
|---|---|
| Stampare una riga | print("Hello, World!") |
| Stampare senza ritorno a capo | print("Hi", terminator: "") |
| Interpolazione di stringhe | print("Hi \(name)") |
| Commento | // this is a comment |
| Commento su più righe | /* ... */ |
| Importare un modulo | import Foundation |
| Eseguire un file | swift run o swift main.swift |
Variabili (let / var) e tipi
Usa let per le costanti e var per i valori modificabili; di solito i tipi vengono dedotti.
| Operazione | Sintassi |
|---|---|
| Costante | let age = 30 |
| Variabile | var count = 0 |
| Tipo esplicito | let name: String = "Ada" |
| Tipi base | Int, Double, String, Bool, Character |
| Conversione di tipo | Double(i), String(n), Int("42") |
| Tupla | let pair = (1, "a") |
| Alias di tipo | typealias ID = Int |
| Controllare il tipo | value is String, value as? String |
Optional
Gli optional rappresentano la possibile assenza di un valore; vanno scartati (unwrap) prima dell'uso.
| Operazione | Sintassi |
|---|---|
| Dichiarare un optional | var name: String? = nil |
| Optional binding | if let n = name { ... } |
| Unwrap con guard | guard let n = name else { return } |
| Nil-coalescing | let n = name ?? "default" |
| Optional chaining | user?.address?.city |
| Unwrap forzato (non sicuro) | name! |
| Unwrap implicito | var name: String! |
| Map su un optional | name.map { $0.count } |
Stringhe
Le stringhe sono tipi valore con pieno supporto Unicode.
| Operazione | Sintassi |
|---|---|
| Lunghezza | s.count |
| Maiuscolo / minuscolo | s.uppercased(), s.lowercased() |
| Concatenare | "foo" + "bar" |
| Interpolazione | "Total: \(price)" |
| Contiene | s.contains("ell") |
| Ha prefisso / suffisso | s.hasPrefix("he") |
| Dividere | s.split(separator: ",") |
| Sostituire | s.replacingOccurrences(of: "a", with: "b") |
| Stringa su più righe | """ ... """ |
Collezioni (Array, Dictionary, Set)
Tre tipi di collezione fondamentali, tutti tipi valore.
| Operazione | Sintassi |
|---|---|
| Array letterale | var nums = [1, 2, 3] |
| Aggiungere in coda | nums.append(4) |
| Accesso / conteggio | nums[0], nums.count |
| Map / filter | nums.map { $0 * 2 }, nums.filter { $0 > 1 } |
| Dizionario letterale | var ages = ["Ada": 30] |
| Accesso al dizionario | ages["Ada"] restituisce un optional |
| Set letterale | var ids: Set = [1, 2, 3] |
| Inserire in un set | ids.insert(4) |
| Iterare un dizionario | for (k, v) in ages { ... } |
Controllo del flusso
Le condizioni non richiedono parentesi; lo switch deve essere esaustivo.
| Operazione | Sintassi |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| Ternario | let r = x > 0 ? "pos" : "neg" |
| Switch | switch n { case 1: ...; default: ... } |
| Switch con intervallo | case 1...5: ... |
| Ciclo for-in | for i in 0..<10 { ... } |
| For-in su un array | for item in items { ... } |
| Ciclo while | while x < 100 { ... } |
| Repeat-while | repeat { ... } while x < 100 |
| Break / continue | break, continue |
Funzioni e closure
Le funzioni hanno parametri con etichetta; le closure sono blocchi di codice autonomi.
| Operazione | Sintassi |
|---|---|
| Definire una funzione | func add(a: Int, b: Int) -> Int { a + b } |
| Etichetta esterna | func greet(to name: String) { ... } |
| Parametro predefinito | func greet(name: String = "World") { ... } |
| Parametro variadico | func sum(_ nums: Int...) -> Int { ... } |
| Più valori di ritorno (tupla) | func bounds() -> (min: Int, max: Int) { ... } |
| Espressione closure | let f = { (x: Int) -> Int in x * x } |
| Trailing closure | nums.map { $0 * 2 } |
| Argomenti abbreviati | { $0 + $1 } |
Struct e classi a confronto
Le struct sono tipi valore (vengono copiate); le classi sono tipi riferimento (condivise).
| Operazione | Sintassi |
|---|---|
| Definire una struct | struct Point { var x: Int; var y: Int } |
| Definire una classe | class Person { var name: String } |
| Inizializzatore di classe | init(name: String) { self.name = name } |
| Creare un'istanza | let p = Point(x: 1, y: 2) |
| Metodo mutating di una struct | mutating func move() { x += 1 } |
| Metodo di classe | func greet() { ... } |
| Ereditarietà (solo classi) | class Student: Person { ... } |
| Proprietà calcolata | var area: Int { width * height } |
| Membro statico | static let shared = Manager() |
Enum
Gli enum raggruppano valori correlati e possono portare dati associati.
| Operazione | Sintassi |
|---|---|
| Definire un enum | enum Direction { case north, south } |
| Usare un case | let d = Direction.north |
| Switch su un enum | switch d { case .north: ... } |
| Valori raw | enum Status: Int { case ok = 200 } |
| Accedere al valore raw | Status.ok.rawValue |
| Inizializzare da un valore raw | Status(rawValue: 200) |
| Valori associati | case result(Int, String) |
| Metodi negli enum | func label() -> String { ... } |
La sintassi Swift che usi più spesso, in una sola pagina. Questa Swift cheat sheet è un riferimento rapido per il cuore del linguaggio: costanti e variabili, optional, stringhe, collezioni, controllo del flusso, funzioni e closure, oltre alle struct, alle classi e agli enum con cui crei app per iOS e macOS.
Tutto quello che trovi qui è Swift standard e compila con la toolchain ufficiale. Copia ciò che ti serve o prova ogni snippet dal vivo nel playground Swift, senza bisogno di Xcode.
Domande frequenti sulla Swift cheat sheet
Questa Swift cheat sheet è gratuita?
Sì. Questa Swift cheat sheet è completamente gratuita e non richiede registrazione. Salvala nei preferiti e torna qui ogni volta che devi cercare un pattern con gli optional, la sintassi delle closure o un metodo delle collezioni.
Come si fa l'unwrap di un optional in Swift?
nil, quindi va scartato prima di usarlo. I modi sicuri sono l'optional binding (if let n = name { ... }), un guard let all'inizio di una funzione, l'operatore nil-coalescing (name ?? "default") e l'optional chaining (user?.name). L'unwrap forzato con name! funziona ma manda in crash l'app se il valore è nil, quindi usalo solo quando ne hai la certezza.Qual è la differenza tra struct e class in Swift?
struct è un tipo valore: assegnarla o passarla crea una copia, quindi le modifiche non toccano l'originale. Una class è un tipo riferimento: le copie condividono la stessa istanza, e solo le classi supportano l'ereditarietà. Apple consiglia di preferire le struct per impostazione predefinita e di usare una classe quando ti serve uno stato mutabile condiviso o l'ereditarietà.Posso esercitarmi con Swift online?
Sì. Apri il playground Swift per eseguire nel browser qualsiasi snippet di questa cheat sheet, senza installare Xcode. Quando vuoi un percorso strutturato, il corso Swift interattivo e gratuito di Coddy ti accompagna passo dopo passo da optional e collezioni fino a struct, classi ed enum.
Questa cheat sheet va bene per chi inizia?
Sì. È organizzata dagli argomenti più comuni (variabili, optional, controllo del flusso) fino a quelli avanzati (closure, struct e classi, enum), così puoi usare le prime sezioni fin dal primo giorno e affrontare il resto man mano che procedi.
Risorse correlate
Altre cheat sheet
