willSet e didSet em Swift: o que são, sintaxe e funcionamento dos observadores

O que são willSet e didSet em Swift?

willSet e didSet são observadores de propriedade (property observers) em Swift, um mecanismo integrado para rastrear alterações em stored properties.

Ao contrário de outras linguagens que exigem implementação manual de setters ou sistemas de callback, o Swift fornece uma sintaxe declarativa para reagir a alterações. Observadores são adicionados diretamente após a declaração da propriedade e não requerem uma chamada separada.

De acordo com a Documentação do Desenvolvedor Apple (2026), property observers são suportados para stored properties de qualquer classe, estrutura ou enumeração. Eles não funcionam com computed properties porque estas não armazenam um valor — para elas, a reação à mudança é implementada diretamente no setter.

Quando willSet é chamado

willSet é chamado imediatamente antes de atribuir um novo valor à propriedade. Dentro de willSet, o parâmetro implícito newValue está disponível, contendo o valor que será definido. Neste momento, o valor atual da propriedade ainda não mudou — você pode ler o valor antigo diretamente através da propriedade.

De acordo com a proposta Swift Evolution SE-0001 (2024), willSet fornece a capacidade de realizar validação ou registro antes da alteração real. Se uma exceção for lançada em willSet, o novo valor não será aplicado, tornando os observadores um mecanismo de proteção de dados.

Quando didSet é chamado

didSet é chamado imediatamente após atribuir um novo valor. Dentro de didSet, o parâmetro implícito oldValue está disponível, contendo o valor antes da alteração. Neste ponto, a propriedade já contém o novo valor e você pode compará-lo com o antigo.

De acordo com Swift by Sundell (2025), didSet é o observador mais popular porque é mais frequentemente necessário para pós-processamento: atualizar a UI, recalcular campos dependentes ou enviar dados ao servidor após uma alteração.

Sintaxe dos observadores de propriedade

Property observers são declarados imediatamente após a propriedade usando chaves. A sintaxe mínima requer apenas um observador, mas você pode declarar ambos.

var score: Int = 0 {
    willSet {
        print("A pontuação mudará para \(newValue)")
    }
    didSet {
        print("A pontuação mudou de \(oldValue) para \(score)")
    }
}

Ambos observadores são opcionais — você pode especificar apenas willSet ou apenas didSet. Para willSet você pode renomear newValue especificando um nome entre parênteses.

var username: String = "guest" {
    willSet(newName) {
        print("Prestes a definir \(newName)")
    }
    didSet(oldName) {
        print("Era \(oldName), agora \(username)")
    }
}

De acordo com Swift Language Guide (2026), renomear parâmetros melhora a legibilidade do código, especialmente quando a propriedade e os observadores são usados em um projeto grande com nomes longos.

Como funcionam willSet e didSet

A ordem de execução é estritamente definida: primeiro willSet (valor antigo disponível), depois a atribuição, depois didSet (novo valor disponível).

class Temperature {
    var celsius: Double = 0.0 {
        willSet {
            print("A temperatura mudará de \(celsius) para \(newValue)")
        }
        didSet {
            if celsius > 100.0 {
                print("Ponto de ebulição excedido!")
            }
        }
    }
}

Uma limitação importante: os observadores não são chamados durante a inicialização da propriedade ao criar uma instância. Dentro de init, atribuir um valor não aciona willSet e didSet — isso evita efeitos colaterais indesejados na fase de construção.

De acordo com o Apple Swift Blog (2025), este comportamento difere de muitas outras linguagens onde os setters são chamados mesmo em construtores. Swift escolhe a segurança: os observadores só começam a funcionar após a conclusão da inicialização do objeto.

Chamadas aninhadas e recursão

Alterar uma propriedade dentro de didSet pode levar a chamadas repetidas do observador. O Swift não bloqueia a recursão — o programador deve controlá-la manualmente.

var counter: Int = 0 {
    didSet {
        if counter < 5 {
            counter += 1
        }
    }
}

Tal código criará recursão total com estouro de pilha se nenhuma condição de saída for fornecida. De acordo com a Stack Overflow Swift Community (2025), este é um dos erros mais comuns que iniciantes cometem ao trabalhar com property observers.

Observadores para propriedades de estruturas

Estruturas suportam willSet e didSet para stored properties sem restrições. É importante lembrar que estruturas são tipos de valor, e modificar uma propriedade dentro de um método mutante também aciona os observadores.

struct Point {
    var x: Double = 0.0 {
        didSet {
            print("X mudou para \(x)")
        }
    }
    var y: Double = 0.0 {
        didSet {
            print("Y mudou para \(y)")
        }
    }
}

var point = Point()
point.x = 5.0

Uso de observadores em projetos reais

Observadores de propriedade são usados em projetos Swift para uma ampla gama de tarefas: desde sincronização de UI até validação de dados e registro.

Validação de valores

didSet permite reverter ou corrigir um valor inválido imediatamente após sua definição. Isso substitui os setters complicados do Objective-C e garante a integridade dos dados no nível do modelo.

var age: Int = 0 {
    didSet {
        if age < 0 || age > 150 {
            age = oldValue
        }
    }
}

Sincronização de UI

Quando uma propriedade relacionada muda, você pode atualizar automaticamente os elementos da interface sem uma chamada de método de atualização separada.

var userName: String = "" {
    didSet {
        nameLabel.text = userName
    }
}

Registro de alterações

willSet é conveniente para registro com fins de depuração ou auditoria. Você pode registrar a hora e o novo valor antes de sua aplicação, garantindo que o log contenha os dados originais para análise.

De acordo com objc.io (2025), property observers são especialmente úteis em arquiteturas com fluxo de dados unidirecional, onde cada alteração de propriedade é registrada para posterior reprodução do estado.

Comparação com computed properties

Computed properties calculam um valor dinamicamente e não têm armazenamento, enquanto willSet e didSet trabalham em uma stored property com um valor real.

A diferença chave: uma computed property calcula um valor a cada acesso, enquanto um property observer reage a uma alteração de um valor existente. A escolha entre eles é ditada pela semântica — se a propriedade é derivada de outros dados, use computed; se é um valor independente cujas alterações precisam ser observadas, use willSet/didSet.

Erros comuns ao usar

O erro mais comum é a chamada recursiva de didSet sem uma condição de saída. Cada alteração de propriedade dentro de didSet aciona o observador novamente, levando a um loop infinito.

O segundo erro comum é tentar usar observadores em propriedades let. O compilador Swift emitirá um erro porque let é uma constante.

O terceiro erro é ignorar que o observador não é chamado durante a inicialização. Desenvolvedores que esperam que willSet dispare dentro de init obtêm um comportamento inesperado.

O quarto problema é aplicar observadores a propriedades em extensões. O Swift proíbe adicionar willSet/didSet a stored properties em extensões.

De acordo com Ray Wenderlich (2025), entender essas limitações ajuda a evitar bugs em estágios iniciais e torna o código Swift mais previsível.