Swift Academy · Aula

@ObservableObject e @StateObject

Crie modelos de tipo referência que conduzam views do SwiftUI por meio de @Published.

@ObservableObject e @StateObject é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Boas-vindas

Para estados complexos compartilhados entre várias visualizações, use modelos de tipo de referência conformes a `ObservableObject`, gerenciados por `@StateObject` ou observados por `@ObservedObject`.

Definindo um ObservableObject

```swift class CartModel: ObservableObject { @Published var items: [CartItem] = [] @Published var total: Double = 0 func add(_ item: CartItem) { items.append(item) } } ```

@StateObject — propriedade

```swift struct ShopView: View { @StateObject private var cart = CartModel() // owns the model var body: some View { CartList(cart: cart) } } ``` Use `@StateObject` quando a visualização cria e é proprietária do modelo.

@ObservedObject — propriedade externa

```swift struct CartList: View { @ObservedObject var cart: CartModel // doesn't own; passed in var body: some View { List(cart.items) { item in Text(item.name) } } } ```

A diferença

• `@StateObject` — a visualização cria o modelo; o modelo persiste entre novas renderizações • `@ObservedObject` — o modelo é recebido como parâmetro; pode ser recriado pelo pai Usar `@ObservedObject` quando `@StateObject` é necessário faz o modelo ser redefinido inesperadamente.

Assinatura de objectWillChange

O SwiftUI assina automaticamente `objectWillChange` ao usar `@StateObject` ou `@ObservedObject`. Cada alteração em `@Published` aciona uma nova renderização.

objectWillChange manual

```swift class Timer: ObservableObject { var count = 0 func tick() { objectWillChange.send() // manual notification count += 1 } } ```

ObservableObjects aninhados

O SwiftUI não observa automaticamente ObservableObjects aninhados. Encaminhe as alterações manualmente: ```swift class Parent: ObservableObject { @Published var child = ChildModel() private var cancel: AnyCancellable? init() { cancel = child.objectWillChange.sink { [weak self] _ in self?.objectWillChange.send() } } } ```

Macro @Observable (Swift 5.9)

```swift @Observable class Counter { var count = 0 } // No ObservableObject, no @Published, no @StateObject needed // SwiftUI automatically tracks access ```

Testando ObservableObject

```swift func testCart() { let cart = CartModel() cart.add(CartItem(name:"Apple",price:1.0)) XCTAssertEqual(cart.items.count, 1) XCTAssertEqual(cart.total, 1.0) } ```

Verificação rápida

Quando você deve usar `@StateObject` em vez de `@ObservedObject`?

Recapitulação

Principais conclusões: • `ObservableObject` + `@Published` = modelo reativo • `@StateObject` — a visualização é proprietária do modelo; ele persiste entre novas renderizações • `@ObservedObject` — o modelo é recebido como parâmetro; propriedade externa • `objectWillChange.send()` para notificações manuais • A macro `@Observable` do Swift 5.9 substitui a maior parte disso Próximo: @EnvironmentObject.

Perguntas Frequentes

A aula “@ObservableObject e @StateObject” é grátis?

Sim — o texto completo de “@ObservableObject e @StateObject” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “@ObservableObject e @StateObject”?

Crie modelos de tipo referência que conduzam views do SwiftUI por meio de @Published. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “@ObservableObject e @StateObject”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

@Binding: fluxo de dados bidirecional
@ObservableObject e @StateObject
@EnvironmentObject para estado compartilhado
Fonte única da verdade e fluxo unidirecional

← Voltar para Swift Academy