0Pricing
Swift Academy · Aula

Mutação e Reatribuição de self

Substitua completamente self a partir de um método mutating.

Mutação e Reatribuição de self é 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.

Reatribuindo self

Dentro de um método mutating, você pode atribuir um valor totalmente novo a self, substituindo a instância inteira.

struct Point {
    var x = 0
    var y = 0
    mutating func reset() {
        self = Point(x: 0, y: 0)
    }
}
var p = Point(x: 3, y: 4)
p.reset()
print(p.x, p.y)

Por que reatribuir self

Reatribuir self é útil quando o novo estado é mais fácil de expressar como uma instância nova do que editando os campos um por um.

struct Vector {
    var dx: Int
    var dy: Int
    mutating func negate() {
        self = Vector(dx: -dx, dy: -dy)
    }
}
var v = Vector(dx: 2, dy: -3)
v.negate()
print(v.dx, v.dy)

Enumerações reatribuem self

Nas enumerações, a mudança de caso é feita atribuindo um novo caso a self.

enum State {
    case idle, running, done
    mutating func advance() {
        switch self {
        case .idle: self = .running
        case .running: self = .done
        case .done: self = .done
        }
    }
}
var s = State.idle
s.advance()
s.advance()
print(s)

Equivalente a editar os campos

Atribuir self = Point(x: 1, y: 1) equivale a definir x e y individualmente, mas é mais conciso.

struct Point {
    var x = 0
    var y = 0
    mutating func setBoth(_ n: Int) {
        self = Point(x: n, y: n)
    }
}
var p = Point()
p.setBoth(7)
print(p.x, p.y)

Lendo o self antigo primeiro

Você pode calcular a nova instância a partir da atual antes de fazer a reatribuição.

struct Counter {
    var value: Int
    mutating func doubled() {
        self = Counter(value: value * 2)
    }
}
var c = Counter(value: 5)
c.doubled()
print(c.value)

Transformação no estilo construtor

A reatribuição de self permite que um método expresse uma transformação completa em uma única etapa.

struct Temperature {
    var celsius: Double
    mutating func toRounded() {
        self = Temperature(celsius: celsius.rounded())
    }
}
var t = Temperature(celsius: 21.7)
t.toRounded()
print(t.celsius)

Somente em métodos mutating

Você só pode atribuir a self dentro de um método marcado como mutating. Um método normal não pode fazer isso.

struct Flag {
    var on = false
    mutating func turnOn() {
        self = Flag(on: true)
    }
}
var f = Flag()
f.turnOn()
print(f.on)

Combinando com lógica

Você pode criar ramificações e reatribuir self somente em alguns casos.

struct Score {
    var points: Int
    mutating func clamp() {
        if points > 100 {
            self = Score(points: 100)
        }
    }
}
var s = Score(points: 150)
s.clamp()
print(s.points)

Padrão de alternância de enumeração

A alternância de uma enumeração com dois casos é um exemplo clássico de reatribuição de self.

enum Switch {
    case off, on
    mutating func flip() {
        self = (self == .off) ? .on : .off
    }
}
var sw = Switch.off
sw.flip()
print(sw)

Nenhum efeito sobre outras cópias

Reatribuir self altera somente esta instância. As outras cópias do valor permanecem intactas.

struct Box { var n: Int; mutating func zero() { self = Box(n: 0) } }
var a = Box(n: 5)
var b = a
a.zero()
print(a.n, b.n)

Intenção clara

Use a reatribuição de self quando ela tornar a transformação óbvia; use edições de campos quando apenas uma propriedade mudar.

struct Pair {
    var a: Int
    var b: Int
    mutating func swapValues() {
        self = Pair(a: b, b: a)
    }
}
var p = Pair(a: 1, b: 2)
p.swapValues()
print(p.a, p.b)

Verificação rápida

Teste a reatribuição de self.

Recapitulação

Dentro de um método mutating, você pode atribuir um valor totalmente novo a self, substituindo a instância. Isso é conciso para transformações completas e é assim que as enumerações mudam de caso. A alteração afeta somente esta instância, não as outras cópias.

enum T { case a, b; mutating func go() { self = .b } }
var t = T.a
t.go()
print(t)

Perguntas Frequentes

A aula “Mutação e Reatribuição de self” é grátis?

Sim — o texto completo de “Mutação e Reatribuição de self” é 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 “Mutação e Reatribuição de self”?

Substitua completamente self a partir de um método mutating. 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 “Mutação e Reatribuição de self”?

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

  1. Tipos de Valor e Imutabilidade
  2. A Palavra-chave mutating
  3. Mutação e Reatribuição de self
  4. Alternativas sem Mutação
← Voltar para Swift Academy