Il pattern MVVM
Separa le responsabilità di view, view model e model.
Il pattern MVVM è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 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.
Che cos'è MVVM?
MVVM sta per Model-View-ViewModel. È un pattern architetturale che separa l'app in tre livelli, ognuno con una responsabilità unica e ben definita.
- Model — dati e regole di business
- View — ciò che vede l'utente
- ViewModel — il collegamento che prepara i dati del Model per la View
L'obiettivo è la separazione delle responsabilità: ogni livello cambia per una propria ragione, indipendentemente dagli altri.
Il livello Model
Il Model contiene i dati grezzi e le regole che li governano. Non sa nulla dello schermo o del modo in cui gli elementi vengono visualizzati.
I Model sono solitamente semplici struct o oggetti del dominio. Sono facili da testare perché non hanno dipendenze dall'interfaccia utente.
struct User {
let id: UUID
let firstName: String
let lastName: String
let isPremium: Bool
}
struct Order {
let items: [String]
let total: Decimal
}Il livello View
La View ha una funzione esclusivamente di presentazione. In SwiftUI è costituita dalle struct View; in UIKit è costituita dal UIViewController e dalle relative subview.
Una buona View non contiene logica di business. Si limita a visualizzare lo stato e a inoltrare le action dell'utente al ViewModel.
struct ProfileView: View {
@StateObject var viewModel: ProfileViewModel
var body: some View {
VStack {
Text(viewModel.displayName)
if viewModel.showBadge {
Text("Premium")
}
}
}
}Il livello ViewModel
Il ViewModel si colloca tra Model e View. Prende i dati grezzi del Model e li trasforma in valori pronti per la presentazione che la View può mostrare direttamente.
Espone inoltre gli intenti (metodi) che la View invoca quando l'utente interagisce.
final class ProfileViewModel: ObservableObject {
@Published var displayName: String
@Published var showBadge: Bool
init(user: User) {
displayName = user.firstName + " " + user.lastName
showBadge = user.isPremium
}
}Perché separare le responsabilità?
Quando formattazione, networking e rendering sono tutti mescolati all'interno di un view controller, quel file diventa un blocco enorme e impossibile da testare.
Separando le responsabilità:
- Il Model può essere riutilizzato in più schermate
- Il ViewModel può essere testato con unit test senza un'interfaccia utente
- La View rimane piccola e dichiarativa
Cosa appartiene al Model
Inserisca nel Model:
- Entità del dominio (
User,Product) - Regole di convalida del business
- Astrazioni per la persistenza e il networking, spesso tramite servizi invocati dal ViewModel
Non inserisca mai stringhe dell'interfaccia utente, colori o formattazione nel Model.
Cosa appartiene al ViewModel
Il ViewModel gestisce la logica di presentazione:
- Formattare date, valute e nomi in stringhe da visualizzare
- Decidere quali stati dell'interfaccia utente sono visibili, come caricamento, errore e stato vuoto
- Coordinare le chiamate ai servizi ed esporre i risultati
final class CartViewModel: ObservableObject {
@Published var totalText: String = ""
func update(with order: Order) {
let formatter = NumberFormatter()
formatter.numberStyle = .currency
totalText = formatter.string(from: order.total as NSNumber) ?? "-"
}
}Cosa appartiene alla View
La View dovrebbe soltanto:
- Disporre e visualizzare gli elementi dell'interfaccia
- Leggere lo stato pubblicato dal ViewModel
- Inoltrare tap e gesti chiamando i metodi del ViewModel
Se trova un if che decide regole di business all'interno di una View, è probabile che quella logica appartenga al ViewModel.
Flusso dei dati in MVVM
Il flusso dei dati procede in una direzione, mentre le action seguono quella opposta:
- Model -> ViewModel -> View per i dati
- View -> ViewModel per gli intenti dell'utente
La View non comunica mai direttamente con il Model. In questo modo le dipendenze rimangono orientate verso l'interno, cioè verso il dominio.
MVVM e MVC a confronto
Nel MVC classico, il controller spesso cresce a dismisura perché gestisce contemporaneamente formattazione, networking e collegamento con la view.
MVVM estrae questa logica di presentazione nel ViewModel, lasciando sottile il controller, o la View di SwiftUI. Il ViewModel è indipendente dal framework dell'interfaccia utente, quindi è molto più facile da testare.
Una slice completa
Ecco una slice MVVM piccola ma completa, che collega tutti i livelli.
struct Account { let balance: Decimal }
final class AccountViewModel: ObservableObject {
@Published var balanceText: String
init(account: Account) {
balanceText = "$" + "\(account.balance)"
}
}
struct AccountView: View {
@StateObject var viewModel: AccountViewModel
var body: some View { Text(viewModel.balanceText) }
}Verifica rapida
Verifichi la Sua comprensione delle responsabilità di MVVM.
Riepilogo
Ha imparato a conoscere i tre livelli di MVVM e i relativi confini:
- Model — dati grezzi e regole di business, senza interfaccia utente
- ViewModel — logica di presentazione e intenti
- View — rendering puro dello stato del ViewModel
Mantenere separate queste responsabilità rende il codice testabile, riutilizzabile e facile da comprendere. Ora collegherà un ViewModel a una View tramite i binding.
Domande Frequenti
La lezione «Il pattern MVVM» è gratuita?
Sì — il testo completo di «Il pattern MVVM» è 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 «Il pattern MVVM»?
Separa le responsabilità di view, view model e model. 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 1 di 4.
Quanto tempo richiede la lezione «Il pattern MVVM»?
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.