iOS Swift — Cheat Sheet

Tag: ios, swift, uikit, swiftui, xcode, coredata, arc, mvc, mvvm

Livello: intermedio

TL;DR: Sintesi dei concetti base e avanzati di Swift per lo sviluppo iOS, con focus su gestione della memoria, pattern architetturali e differenze tra framework UI.

Concetti chiave

Swift è strongly typed e type-safe.

Optionals: gestiscono l'assenza di valore (? o !).

let per costanti, var per variabili.

Valori vs Reference: Struct ed Enum sono value type (copiati), Classi sono reference type (passati per riferimento).

ARC (Automatic Reference Counting) gestisce la memoria allocata dalle classi.

Protocolli definiscono blueprint di metodi, proprietà e requisiti.

Extension aggiungono funzionalità a tipi esistenti (senza subclassing).

Closures: blocchi di codice auto-contenuti (simili a lambda/blocks# iOS Swift — Cheat Sheet

Tag: ios, swift, uikit, swiftui, arc, concurrency, memory-management

Livello: intermedio

TL;DR: Sintesi rapida su Swift, gestione memoria con ARC, architetture iOS, async/await e ciclo di vita per colloqui tecnici.

Concetti chiave

Swift distingue rigorosamente tipi per valore (struct, enum) e tipi per riferimento (class).

ARC gestisce la memoria contando i riferimenti forti agli oggetti allocati su heap.

I closure catturano variabili per riferimento; richiedono capture list [weak self] per evitare retain cycle.

SwiftUI adotta un paradigma dichiarativo e reattivo basato su flussi unidirezionali di dati.

UIKit adotta un approccio imperativo basato sull'architettura MVC e sulla gerarchia di UIViewController.

La moderna concorrenza in Swift usa async/await, Task e Actor per prevenire i data race.

MainActor isola e vincola l'esecuzione del codice al thread principale per gli aggiornamenti UI.

Il Protocol-Oriented Programming privilegia la composizione e l'astrazione rispetto all'ereditarietà di classi.

I tipi opzionali gestiscono l'assenza di valore imponendo l'unwrapping sicuro tramite guard let o if let.

Domande tipiche e risposte pronte

Q: Qual è la differenza principale tra struct e class in Swift e quando usi l'una o l'altra?R: Le struct sono value type copiate per valore, allocate nello stack e thread-safe per natura. Le class sono reference type allocate su heap; le uso quando mi serve identità condivisa o gestione del ciclo di vita con deinit.

Q: Come eviti i retain cycle nelle closure e nei delegati?R: Nei delegati dichiaro sempre la proprietà come weak. Nelle closure inserisco una capture list con [weak self] ed eseguo un unwrap sicuro con guard let self = self else { return }.

Q: Come funziona il modello di concorrenza con gli actor in Swift?R: Un actor protegge il proprio stato mutabile garantendo l'accesso sincronizzato a un solo task alla volta, prevenendo i data race a tempo di compilazione.

Q: Qual è la differenza tra @StateObject e @ObservedObject in SwiftUI?R: @StateObject crea e gestisce il ciclo di vita dell'istanza mantenendola attiva tra i re-render della view; @ObservedObject non possiede l'istanza e va usato solo per dipendenze iniettate dall'esterno.

Insidie e errori comuni

Usare [unowned self] al posto di [weak self] quando il ciclo di vita dell'oggetto non è garantito, provocando crash a runtime.

Eseguire chiamate bloccanti di rete o calcoli computazionali pesanti sul thread principale.

Dimenticare di invalidare Timer o ignorare il ciclo di vita dei cancellable in Combine, generando memory leak.

Confondere frame e bounds in UIKit: frame è relativo alla superview, bounds al proprio sistema di coordinate.

Forzare l'unwrapping con operatore ! su valori opzionali privi di verifica preventiva.

Snippet e comandi

// Capture list debole e discesa su MainActor
final class UserRepository {
    weak var delegate: UserUpdateDelegate?

    func fetchUserProfile(id: String) {
        Task { [weak self] in
            guard let self = self else { return }
            let user = try await NetworkService.shared.get(userId: id)
            await MainActor.run {
                self.delegate?.didUpdateUser(user)
            }
        }
    }
}

Swift

// Isolamento dello stato con Actor
actor DataStore {
    private var cache: [String: Data] = [:]

    func set(_ data: Data, forKey key: String) {
        cache[key] = data
    }

    func get(forKey key: String) -> Data? {
        return cache[key]
    }
}

Da ripassare

[x] Differenza tra Value Type e Reference Type

[x] Gestione memoria ARC e capture list [weak self]

[ ] Concorrenza strutturata: TaskGroup e protocollo Sendable

[ ] Ciclo di vita dei View Controller in UIKit (loadView, viewDidLoad, viewWillAppear)

[ ] Property wrappers di SwiftUI: @Binding, @EnvironmentObject, @StateObject

Riferimenti

The Swift Programming Language (Swift.org)

Apple Developer Documentation - Swift Standard Library

Apple Developer Documentation - Concurrency & Memory Management