Swift Academy · Aula

@Published e observação no Combine

Entenda como @Published funciona internamente para emitir alterações por meio dos publishers do Combine.

Aula 3 de 412 etapas

@Published e observação no Combine é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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

`@Published` é um invólucro de propriedades da estrutura Combine que emite um novo valor por meio de um publicador sempre que a propriedade muda.

Noções básicas de @Published

```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" ```

Protocolo ObservableObject

```swift class ViewModel: ObservableObject { @Published var title = "Initial" @Published var items: [String] = [] } ``` Qualquer classe que esteja em conformidade com `ObservableObject` obtém gratuitamente um publicador `objectWillChange`.

Publicador objectWillChange

```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 com @StateObject do SwiftUI

```swift @StateObject var vm = ViewModel() // In View body: Text(vm.title) // Re-renders when vm.title changes ``` `@StateObject` é responsável pelo ViewModel; `@ObservedObject` observa um ViewModel pertencente a outro objeto.

Encadeando publicadores de @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 emite antes da atribuição

`objectWillChange` é emitido *antes* de o novo valor ser armazenado: ```swift vm.objectWillChange.sink { _ in print("will change") } $count.sink { n in print("is \(n)") } // Order: "will change" then "is 1" ```

Armazenando assinaturas

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

Limitações de @Published

• Apenas em classes (tipos de referência) • Não pode ser usado em constantes `let` • Não funciona entre limites de atores sem isolamento explícito • O valor é publicado *antes* de a atribuição ser concluída (semântica de willSet)

Macro de observação (Swift 5.9+)

O Swift 5.9 introduz `@Observable` como uma alternativa mais simples: ```swift @Observable class Counter { var count = 0 } // No Combine import needed; SwiftUI auto-subscribes ```

Verificação rápida

Quando `@Published` emite seu valor — antes ou depois de a propriedade ser definida?

Responda na aula interativa

Recapitulação

Principais conclusões: • `@Published var x` expõe `$x` como um `Publisher` • `ObservableObject` obtém gratuitamente um publicador `objectWillChange` • Emite antes de o novo valor ser armazenado (willSet) • Armazene as assinaturas em `Set` • Swift 5.9: `@Observable` atende à maioria dos casos que exigem `@Published` Próximo: composição de invólucros de propriedades.

Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 122
Aulas: 409

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “@Published e observação no Combine” é grátis?

Sim — o texto completo de “@Published e observação no Combine” é 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 “@Published e observação no Combine”?

Entenda como @Published funciona internamente para emitir alterações por meio dos publishers do Combine. 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 3 de 4.

Quanto tempo leva a aula “@Published e observação no Combine”?

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

Criação de um wrapper de propriedade personalizado
Valores projetados com $binding
@Published e observação no Combine
Composição de vários wrappers de propriedade

← Voltar para Swift Academy