View-identiteit begrijpen
Bepaal hoe SwiftUI views vergelijkt en hergebruikt.
View-identiteit begrijpen is een gratis Swift Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Swift Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Swift Academy bevat in totaal 4 lessen.
Identiteit bepaalt het gedrag van SwiftUI
SwiftUI houdt elke weergave bij aan de hand van zijn identiteit om te bepalen of een bestaande weergave moet worden bijgewerkt of een nieuwe moet worden gemaakt.
De identiteit goed instellen heeft de grootste invloed op correctheid en prestaties.
Twee soorten identiteit
SwiftUI gebruikt twee vormen: structurele identiteit (de positie van een weergave in de weergaveboom) en expliciete identiteit (een id dat je toewijst).
Structurele identiteit
Standaard wordt de identiteit van een weergave bepaald door de plaats ervan in de hiërarchie. De onderstaande if-vertakkingen maken twee structureel verschillende weergaven.
var body: some View {
if isOn {
Text("On") // one identity
} else {
Text("Off") // a different identity
}
}Waarom vertakkingen hun toestand verliezen
Omdat elke vertakking een andere structurele identiteit heeft, vernietigt het wisselen ertussen de eerste weergave en maakt het de tweede aan. Elke @State daarin wordt teruggezet.
if isExpanded {
DetailView() // new instance each time the branch flips
} else {
SummaryView()
}Expliciete identiteit met id()
De modifier .id(_:) wijst een expliciete identiteit toe. Als je de id verandert, laat je SwiftUI weten: "dit is een andere weergave". Daardoor wordt een nieuwe instantie gemaakt en de toestand teruggezet.
CounterView()
.id(selectedTab) // new identity per tabIdentiteit in ForEach
ForEach heeft een stabiele identiteit per element nodig. Gebruik een key path naar een stabiele id, nooit de index van de array voor veranderlijke verzamelingen.
ForEach(items, id: \.id) { item in
RowView(item: item)
}De valkuil van indexidentiteit
Als je id: \.self gebruikt voor indices of waarden die veranderen, worden identiteiten opnieuw geordend wanneer de gegevens wijzigen. Dat veroorzaakt verkeerde animaties en verloren toestand.
// Risky if items reorder or values repeat:
// ForEach(0..<items.count, id: \.self) { ... }Identiteit en animatie
Animaties interpoleren tussen toestanden van dezelfde identiteit. Als de identiteit verandert, voert SwiftUI een overgang voor invoegen en verwijderen uit in plaats van een vloeiende animatie.
withAnimation {
// same identity -> property animates
// changed id -> transition (fade/slide)
}Voorwaardelijke modifiers veranderen de identiteit
Een modifier binnen een if toepassen kan de structurele identiteit veranderen, waardoor de toestand wordt teruggezet. Gebruik liever één weergave waarvan de waarde van de modifier voorwaardelijk wordt berekend.
// Better: keep one identity
Text("Hi")
.opacity(isHidden ? 0 : 1)
// Worse: branching creates two identitiesAnyView wist identiteitsinformatie
Als je weergaven in AnyView verpakt, verberg je hun type voor SwiftUI, waardoor SwiftUI minder goed efficiënt kan bepalen wat er is veranderd. Gebruik waar mogelijk concrete typen of @ViewBuilder.
// Prefer @ViewBuilder over returning AnyView
@ViewBuilder
func content() -> some View {
if flag { A() } else { B() }
}Stabiele identiteit = stabiele toestand
Vuistregel: houd de identiteit stabiel als je de toestand en vloeiende animaties wilt behouden; verander de identiteit bewust wanneer je echt opnieuw wilt beginnen.
Korte controle: identiteit van weergaven
Test je begrip van de identiteit van weergaven.
Samenvatting: identiteit van weergaven begrijpen
SwiftUI identificeert weergaven structureel (positie in de boom) en expliciet (.id). Een stabiele identiteit behoudt @State en maakt vloeiende animatie van eigenschappen mogelijk; een veranderde identiteit zet de toestand terug en start overgangen.
Geef ForEach stabiele id's, vermijd indexidentiteit voor veranderlijke gegevens, beperk vertakkingen die de identiteit omdraaien en vermijd AnyView wanneer een concreet type werkt.
Leer Swift met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 122
- Lessen
- 409
Veelgestelde vragen
Is de les “View-identiteit begrijpen” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Swift Academy, waaronder “View-identiteit begrijpen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Swift Academy bevat in totaal 4 lessen.
Wat leer ik in “View-identiteit begrijpen”?
Bepaal hoe SwiftUI views vergelijkt en hergebruikt. Je oefent met Swift Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Swift Academy te beginnen?
Ervaring vooraf is niet nodig. Swift Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “View-identiteit begrijpen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Swift Academy?
Ja. Elke les over Swift Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- View-identiteit begrijpen
- Herberekening van body beperken
- Equatable views en @State-scope
- Profileren met het SwiftUI-instrument