Swift Academy · Lesson

@Published and Observation in Combine

How @Published works under the hood to emit changes through Combine publishers.

@Published and Observation in Combine is a free Swift Academy lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

`@Published` is a property wrapper from the Combine framework that emits a new value through a publisher whenever the property changes.

@Published Basics

```swift import Combine class Counter: ObservableObject { @Published var count = 0 } let c = Counter() let cancel = c.$count.sink { print("Count: \($0)") } c.count += 1 // "Count: 1" c.count += 1 // "Count: 2" ```

ObservableObject Protocol

```swift class ViewModel: ObservableObject { @Published var title = "Initial" @Published var items: [String] = [] } ``` Any class conforming to `ObservableObject` gets an `objectWillChange` publisher for free.

objectWillChange Publisher

```swift class VM: ObservableObject { @Published var name = "" } let vm = VM() let cancel = vm.objectWillChange.sink { print("Will change") } vm.name = "Alice" // "Will change" printed before assignment ```

@Published with SwiftUI @StateObject

```swift @StateObject var vm = ViewModel() // In View body: Text(vm.title) // Re-renders when vm.title changes ``` `@StateObject` owns the ViewModel; `@ObservedObject` observes an externally owned one.

Chaining Publishers from @Published

```swift class Search: ObservableObject { @Published var query = "" @Published var results: [String] = [] private var cancellables = Set() init() { $query .debounce(for: 0.3, scheduler: RunLoop.main) .sink { [weak self] q in self?.search(q) } .store(in: &cancellables) } } ```

@Published Fires Before Assignment

`objectWillChange` fires *before* the new value is stored: ```swift vm.objectWillChange.sink { _ in print("will change") } $count.sink { n in print("is \(n)") } // Order: "will change" then "is 1" ```

Storing Subscriptions

```swift var cancellables = Set() c.$count .sink { print("\($0)") } .store(in: &cancellables) // cancellables keeps subscription alive ```

@Published Limitations

• Only on classes (reference types) • Cannot use on `let` constants • Does not work across actor boundaries without explicit isolation • Value published *before* assignment completes (willSet semantics)

Observation Macro (Swift 5.9+)

Swift 5.9 introduces `@Observable` as a simpler alternative: ```swift @Observable class Counter { var count = 0 } // No Combine import needed; SwiftUI auto-subscribes ```

Quick Check

When does `@Published` emit its value — before or after the property is set?

Recap

Key takeaways: • `@Published var x` exposes `$x` as a `Publisher` • `ObservableObject` gets a free `objectWillChange` publisher • Fires before the new value is stored (willSet) • Store subscriptions in `Set` • Swift 5.9: `@Observable` replaces most `@Published` needs Next: composing property wrappers.

Frequently asked questions

Is the “@Published and Observation in Combine” lesson free?

Yes — the full text of “@Published and Observation in Combine” is free to read here on the web, and the Swift Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

What will I learn in “@Published and Observation in Combine”?

How @Published works under the hood to emit changes through Combine publishers. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “@Published and Observation in Combine” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Swift Academy