SwiftUI Fundamentals
Build value-driven navigation with destinations, paths, deep-linkable state, and clear ownership of the navigation model.
Before you begin
Learning stage
NavigationStack presents a root and a stack of pushed destinations. Value-based NavigationLink stores a Hashable value representing where the user wants to go. navigationDestination maps that value type to a destination view, separating navigation intent from destination construction.
A bound path makes the stack programmatically controllable. It can support deep links, restoration, multi-step flows, and returning to a known root. Prefer a typed array when one route enum represents all destinations; NavigationPath is useful when the path contains multiple unrelated Hashable types.
Navigation state needs an owner. A feature root may own a route array and pass action closures into children. Child rows should express user intent instead of reaching into a global router unnecessarily. Keep modal presentation separate from pushed path state unless the flow model deliberately unifies them.
Learning stage
A route enum creates one typed navigation vocabulary that supports links and programmatic path changes.
import SwiftUI
struct Lesson: Identifiable, Hashable {
let id: UUID
let title: String
}
enum LearningRoute: Hashable {
case lesson(Lesson)
case quiz(lessonID: Lesson.ID)
}
struct LearningRoot: View {
let lessons: [Lesson]
@State private var path: [LearningRoute] = []
var body: some View {
NavigationStack(path: $path) {
List(lessons) { lesson in
NavigationLink(lesson.title, value: LearningRoute.lesson(lesson))
}
.navigationTitle("Lessons")
.navigationDestination(for: LearningRoute.self) { route in
switch route {
case .lesson(let lesson):
LessonDetail(lesson: lesson) {
path.append(.quiz(lessonID: lesson.id))
}
case .quiz(let lessonID):
QuizScreen(lessonID: lessonID)
}
}
}
}
}Learning stage
Connect the SwiftUI concept to complete, maintainable application features.
Learning stage
Identify patterns that weaken ownership, identity, adaptation, accessibility, or user experience.
Learning stage
Build the behavior in a small Xcode project and review it in multiple states.
Activity 1
Build a route enum for course list, lesson detail, and quiz. Use a bound route array and navigate from detail to quiz programmatically.
Hint: Associated values should contain stable navigation inputs, not an entire service graph.
Activity 2
Given a lesson ID from a URL, validate it and construct the route path required to show its detail.
Hint: Invalid external input should result in a safe fallback, not an impossible route.
Learning stage
Answer each question before revealing the explanation.
QUESTION 1
Maps a navigation value type to its destination view
A value-based link expresses the route value; the destination modifier defines how that type is presented.
QUESTION 2
To inspect and change the pushed navigation state programmatically.
A path enables deep links, restoration, flow resets, and explicit navigation actions.
Learning stage
Explain the design in terms of data flow, identity, lifecycle, platform behavior, and trade-offs.
Short answer: It makes navigation explicit state that can be tested, deep-linked, restored, and changed programmatically.
Views emit Hashable route values rather than constructing every destination inline. A feature root maps routes to screens and owns the path. This separates navigation intent, state, and destination building while keeping small local flows simple.
Possible follow-ups
Learning stage
Modern SwiftUI navigation is value driven. Model valid destinations explicitly, let a stable feature root own the path, and map route values to screens in one reachable navigation context.