Collegamento dei view model alle view
Colleghi i view model con SwiftUI e Combine.
Collegamento dei view model alle view è 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.
Collegare il ViewModel alla View
Un ViewModel è utile solo quando la View reagisce alle sue modifiche. In SwiftUI, questa reattività è basata sui property wrapper di Combine @Published, @StateObject e @ObservedObject.
Insieme formano un binding automatico: quando il ViewModel cambia, la View viene ridisegnata.
ObservableObject
Per poter essere osservato da SwiftUI, un ViewModel deve conformarsi a ObservableObject. Questo protocollo gli fornisce un publisher objectWillChange che viene attivato prima di qualsiasi modifica.
final class CounterViewModel: ObservableObject {
@Published var count: Int = 0
func increment() {
count += 1
}
}Proprietà @Published
Contrassegnare una proprietà con @Published emette automaticamente una notifica di modifica ogni volta che il suo valore viene impostato.
Ogni proprietà @Published alimenta il publisher objectWillChange dell'oggetto, così la View sa esattamente quando aggiornarsi.
final class SearchViewModel: ObservableObject {
@Published var query: String = ""
@Published var results: [String] = []
}@StateObject
@StateObject indica a una View di creare e possedere un ViewModel. SwiftUI lo istanzia una volta sola e lo mantiene in vita durante i successivi ridisegni della View.
Utilizzi @StateObject nel punto in cui il ViewModel viene creato per la prima volta.
struct CounterView: View {
@StateObject private var viewModel = CounterViewModel()
var body: some View {
Button("Count: \(viewModel.count)") {
viewModel.increment()
}
}
}@ObservedObject
@ObservedObject viene usato per un ViewModel creato altrove e passato alla View. La View lo osserva, ma non ne gestisce il ciclo di vita.
Lo utilizzi per le view figlie che ricevono un ViewModel dal genitore.
struct BadgeView: View {
@ObservedObject var viewModel: CounterViewModel
var body: some View {
Text("Total: \(viewModel.count)")
}
}StateObject e ObservedObject a confronto
La differenza fondamentale riguarda la proprietà:
- @StateObject — appartiene alla View e sopravvive ai ridisegni
- @ObservedObject — viene passato dall'esterno e non appartiene alla View
Usare @ObservedObject dove sarebbe necessario @StateObject può causare la ricreazione dell'oggetto e la perdita del suo stato a ogni aggiornamento del genitore.
Passare un ViewModel alle view figlie
Crei il ViewModel una sola volta con @StateObject nel genitore, quindi lo passi alle view figlie che lo contrassegnano con @ObservedObject.
struct ParentView: View {
@StateObject private var viewModel = CounterViewModel()
var body: some View {
VStack {
BadgeView(viewModel: viewModel)
Button("Add") { viewModel.increment() }
}
}
}Binding bidirezionali
Per gli input come i campi di testo è necessario un Binding bidirezionale. SwiftUI ne genera uno da una proprietà @Published usando il prefisso $ del wrapper.
struct SearchView: View {
@StateObject private var viewModel = SearchViewModel()
var body: some View {
TextField("Search", text: $viewModel.query)
}
}Gestire lo stato dell'interfaccia
La View dovrebbe derivare tutto ciò che mostra dalle proprietà pubblicate. Indicatori di caricamento, banner di errore e contenuti devono dipendere dallo stato del ViewModel.
final class FeedViewModel: ObservableObject {
enum State { case loading, loaded([String]), error(String) }
@Published var state: State = .loading
}Reagire allo stato
La View esamina lo stato del ViewModel per visualizzare l'interfaccia corretta. Non c'è codice imperativo per mostrare o nascondere elementi, ma solo una mappatura dichiarativa.
struct FeedView: View {
@StateObject var viewModel = FeedViewModel()
var body: some View {
switch viewModel.state {
case .loading: ProgressView()
case .loaded(let items): List(items, id: \.self) { Text($0) }
case .error(let message): Text(message)
}
}
}Mantenere gli aggiornamenti sul thread principale
SwiftUI richiede che le modifiche alle proprietà pubblicate avvengano sul thread principale. Quando un ViewModel aggiorna lo stato dopo un lavoro asincrono, lo annoti con @MainActor per garantirlo.
@MainActor
final class ProfileViewModel: ObservableObject {
@Published var name: String = ""
func load() async {
name = await fetchName()
}
}Verifica rapida
Verifichi le Sue conoscenze sui binding.
Riepilogo
Ha collegato i ViewModel alle View usando i binding di SwiftUI:
- ObservableObject e @Published emettono notifiche di modifica
- @StateObject crea e possiede un ViewModel
- @ObservedObject osserva un ViewModel passato dall'esterno
- @MainActor mantiene gli aggiornamenti asincroni sul thread principale
Con i binding reattivi configurati, la View riflette automaticamente in ogni momento lo stato più recente del ViewModel.
Domande Frequenti
La lezione «Collegamento dei view model alle view» è gratuita?
Sì — il testo completo di «Collegamento dei view model alle view» è 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 «Collegamento dei view model alle view»?
Colleghi i view model con SwiftUI e Combine. 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 «Collegamento dei view model alle view»?
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
- Il pattern MVVM
- Collegamento dei view model alle view
- Il pattern Coordinator
- Test dei view model