Swift Academy · Lección

mutating y reasignación de self

Reemplace self por completo desde un método mutating.

mutating y reasignación de self es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Reasignar self

Dentro de un método mutating puede asignar un valor completamente nuevo a self, reemplazando toda la instancia.

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 qué reasignar self

Reasignar self resulta útil cuando el nuevo estado se expresa mejor como una instancia nueva que editando los campos uno por uno.

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)

Los enums reasignan self

En los enums, el cambio de caso se realiza asignando un caso nuevo 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 campos

Asignar self = Point(x: 1, y: 1) equivale a establecer x y y individualmente, pero es más 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)

Leer el self anterior primero

Puede calcular la instancia nueva a partir de la actual antes de reasignarla.

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

Transformación al estilo builder

Reasignar self permite que un método exprese una transformación completa en un solo paso.

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

Solo en métodos mutating

Solo puede asignar a self dentro de un método marcado como mutating. Un método normal no puede hacerlo.

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

Combinar con lógica

Puede usar ramificaciones y reasignar self solo en algunos 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)

Patrón de alternancia de un enum

Un enum con dos casos que alternan entre sí es un ejemplo clásico de reasignación de self.

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

No afecta a otras copias

Reasignar self cambia únicamente esta instancia. Las demás copias del valor permanecen 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)

Intención clara

Use la reasignación de self cuando haga evidente la transformación; use la edición de campos cuando solo cambie una propiedad.

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)

Comprobación rápida

Compruebe la reasignación de self.

Repaso

Dentro de un método mutating puede asignar un valor completamente nuevo a self, reemplazando la instancia. Esto resulta conciso para transformaciones completas y es la forma en que los enums cambian de caso. Solo afecta a esta instancia, no a las demás copias.

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

Preguntas frecuentes

¿La lección «mutating y reasignación de self» es gratis?

Sí — el texto completo de «mutating y reasignación de self» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «mutating y reasignación de self»?

Reemplace self por completo desde un método mutating. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «mutating y reasignación de self»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Swift Academy