Propiedades Computadas en Swift: Uso y Ejemplos Prácticos

Las computed properties en Swift permiten calcular valores al vuelo y mantener la coherencia del modelo. Aquí verás cómo usar getter y setter para obtener y modificar el center de un rectángulo a partir de su origin y size, evitando inconsistencias comunes entre stored properties.

¿Qué es una computed property y por qué evita inconsistencias?

Una computed property no almacena datos: los calcula según otras propiedades. Así se evita duplicar información y caer en desajustes entre variables relacionadas.

• stored properties: datos guardados como x, y, width, height.
• computed property: valor derivado como center.
• Beneficio clave: si cambias el center, el setter ajusta el origin sin tocar el size.

¿Cómo se evita el desajuste entre origin, size y center?

• Definiendo center como computed property.
• Con un getter que calcula el centro: origin.x + width/2 y origin.y + height/2.
• Con un setter que, dado un nuevo centro, actualiza origin.x e origin.y restando la mitad de width y height.

¿Qué conceptos y habilidades se practican?

• Modelado con estructuras: Point, Size, Rect.
• Uso de getter y setter para encapsular lógica.
• Cálculo geométrico 2D: mitades de width y height.
• Estilo Swift: return implícito en getters de una línea y uso de newValue en setters.

¿Cómo implementar getters y setters en Swift con un rectángulo?

A partir de un Rect definido por origin: Point y size: Size, se calcula un center: Point. El getter suma la mitad de la anchura y altura; el setter reposiciona el origen conservando el tamaño.

struct Point {
    var x: Double = 0
    var y: Double = 0
}

struct Size {
    var width: Double = 0
    var height: Double = 0
}

struct Rect {
    var origin: Point
    var size: Size

    var center: Point {
        get {
            Point(
                x: origin.x + size.width / 2,
                y: origin.y + size.height / 2
            )
        }
        set {
            origin.x = newValue.x - size.width / 2
            origin.y = newValue.y - size.height / 2
        }
    }
}

¿Cómo se vería con parámetro nombrado en el setter?

• Puedes nombrar el parámetro del setter para mayor claridad.

struct Rect2 {
    var origin: Point
    var size: Size

    var center: Point {
        get {
            Point(x: origin.x + size.width / 2, y: origin.y + size.height / 2)
        }
        set(newCenter) {
            origin.x = newCenter.x - size.width / 2
            origin.y = newCenter.y - size.height / 2
        }
    }
}

¿Qué ejemplos muestran el cálculo del centro y los efectos del setter?

Con un cuadrado de 10 por 10 cuyo origen es (0, 0), el centro se calcula y se actualiza automáticamente al cambiarlo.

var square = Rect(
    origin: Point(x: 0, y: 0),
    size: Size(width: 10, height: 10)
)

let initialSquareCenter = square.center // (5, 5)

// Mover el centro a (20, 20): ajusta el origen a (15, 15)
square.center = Point(x: 20, y: 20)

// Mover el centro a (18, 3): ajusta el origen a (13, -2)
square.center = Point(x: 18, y: 3)

¿Qué patrones de código optimizan el resultado?

• En el getter, una sola línea permite return implícito.
• En el setter, puedes omitir el nombre y usar newValue.
• Menos líneas y menos variables intermedias para código más claro.

¿Te gustaría ver más patrones de uso de computed properties o casos con otras figuras geométricas? Comparte tu duda o ejemplo ideal para explorarlo juntos.