Swift Academy · Aula

Cargas userInfo de Notificações

Associe dados tipados às notificações.

Aula 2 de 413 etapas

Cargas userInfo de Notificações é 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.

userInfo da notificação

Uma notificação pode transportar dados em seu dicionário userInfo, permitindo que os observadores recebam detalhes sobre o que aconteceu.

Publicação com userInfo

Passe um dicionário para post(name:object:userInfo:). As chaves e os valores são Any, portanto qualquer conteúdo é aceito.

import Foundation

let center = NotificationCenter.default
let name = Notification.Name("scoreChanged")
center.post(name: name, object: nil, userInfo: ["score": 100])
print("Posted with payload")

Leitura de userInfo

No observador, leia notification.userInfo e converta o valor para o tipo esperado.

import Foundation

let center = NotificationCenter.default
let name = Notification.Name("scoreChanged")
_ = center.addObserver(forName: name, object: nil, queue: nil) { note in
    if let score = note.userInfo?["score"] as? Int {
        print("Score: \(score)")
    }
}
center.post(name: name, object: nil, userInfo: ["score": 42])

Vários valores

O dicionário pode conter várias chaves, reunindo dados relacionados.

import Foundation

let center = NotificationCenter.default
let name = Notification.Name("login")
_ = center.addObserver(forName: name, object: nil, queue: nil) { note in
    let user = note.userInfo?["user"] as? String ?? "?"
    let admin = note.userInfo?["admin"] as? Bool ?? false
    print("\(user) admin=\(admin)")
}
center.post(name: name, object: nil, userInfo: ["user": "ada", "admin": true])

Chaves seguras quanto ao tipo

Usar chaves literais de string é propenso a erros. Defina constantes para evitar divergências entre quem publica e quem observa.

import Foundation

enum Keys { static let amount = "amount" }
let center = NotificationCenter.default
let name = Notification.Name("purchase")
center.post(name: name, object: nil, userInfo: [Keys.amount: 9.99])
print("Used a constant key")

Conversão de tipo cuidadosa

Como os valores são Any, as conversões podem falhar. Use vinculação opcional para que um tipo incorreto não cause uma falha.

import Foundation

let note = Notification(name: Notification.Name("x"), object: nil, userInfo: ["n": "oops"])
if let n = note.userInfo?["n"] as? Int {
    print(n)
} else {
    print("Wrong type, handled safely")
}

Estruturas personalizadas como conteúdo

Você pode armazenar uma estrutura inteira como valor e convertê-la novamente, mantendo os conteúdos fortemente tipados.

import Foundation

struct Event { let id: Int }
let note = Notification(name: Notification.Name("e"), object: nil, userInfo: ["event": Event(id: 7)])
if let e = note.userInfo?["event"] as? Event {
    print("Event id: \(e.id)")
}

Encapsulamento da publicação

Uma função auxiliar que constrói o userInfo mantém a criação dos conteúdos consistente em todo o app.

import Foundation

let name = Notification.Name("progress")
func postProgress(_ value: Int) {
    NotificationCenter.default.post(name: name, object: nil, userInfo: ["value": value])
}
postProgress(75)
print("Posted progress")

Encapsulamento da leitura

Combine a função auxiliar com um acessador tipado para que os observadores não repitam a lógica de conversão.

import Foundation

extension Notification {
    var progressValue: Int? { userInfo?["value"] as? Int }
}
let n = Notification(name: Notification.Name("progress"), object: nil, userInfo: ["value": 50])
print(n.progressValue ?? -1)

Valores padrão versus chaves ausentes

Se uma chave estiver ausente, a conversão produzirá nil. Forneça um valor padrão adequado com o operador de coalescência de nulos.

import Foundation

let n = Notification(name: Notification.Name("y"), object: nil, userInfo: [:])
let count = n.userInfo?["count"] as? Int ?? 0
print("Count defaulted to \(count)")

Mantenha os conteúdos pequenos

userInfo é mais adequado para dados pequenos e serializáveis. Para objetos grandes, passe um identificador e deixe os observadores buscarem o restante.

import Foundation

let name = Notification.Name("itemUpdated")
// Send just an id, not a heavy object graph.
NotificationCenter.default.post(name: name, object: nil, userInfo: ["id": 1234])
print("Posted a lightweight payload")

Verificação rápida

De que tipo são os valores armazenados no dicionário userInfo de uma notificação?

Responda na aula interativa

Recapitulação

O dicionário userInfo transporta dados de notificações como valores Any, portanto os observadores devem fazer conversões cuidadosas. Use chaves constantes, funções auxiliares e acessadores tipados, defina valores padrão para chaves ausentes e mantenha os conteúdos pequenos. Próximo: remover observadores com segurança.

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 “Cargas userInfo de Notificações” é grátis?

Sim — o texto completo de “Cargas userInfo de Notificações” é 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 “Cargas userInfo de Notificações”?

Associe dados tipados às notificações. 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 “Cargas userInfo de Notificações”?

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

← Voltar para Swift Academy