Variables estáticas en clases, estructuras y enumerados

Domina las propiedades de tipo en Swift con ejemplos claros. Aquí entenderás cuándo usar static y class para crear valores compartidos entre todas las instancias, cómo acceder a ellos y qué diferencias hay en struct, enum y class. Así tomarás decisiones seguras y evitarás errores comunes.

¿Qué es una property de tipo static en Swift?

Las propiedades de tipo son valores compartidos por todas las instancias de un mismo tipo. Se declaran con static y no pertenecen a un objeto concreto, sino al tipo en sí. Esto aplica a struct, enum y class.

• Una type property no se accede desde la instancia.
• Se accede desde el nombre del tipo: Tipo.propiedad.
• Puede ser stored property o computed property.

¿Cómo se declara una stored type property con static?

Ejemplo en struct con una stored property y una propiedad de instancia:

struct SomeStruct {
    static var storedTypeProperty: String = "some value"
    var counter: Int = 0
}

var instanceStr = SomeStruct()
var otherInstance = SomeStruct()

// Acceso correcto a la propiedad de tipo:
let v1 = SomeStruct.storedTypeProperty

// Acceso incorrecto desde la instancia (no compila):
// instanceStr.storedTypeProperty

• storedTypeProperty es común a todas las instancias.
• counter pertenece a cada objeto y sí aparece en la instancia.

¿Cómo funciona una computed type property?

También puedes definir una computed property de tipo con static en una struct:

struct SomeStruct {
    static var storedTypeProperty: String = "some value"
    static var computedTypeProperty: Int { 1 }
    var counter: Int = 0
}

let c = SomeStruct.computedTypeProperty  // 1

• Las computed type properties no dependen de una instancia concreta.
• Se consultan así: SomeStruct.computedTypeProperty.

¿Cómo aplicar static en structs y enums?

En struct y enum puedes declarar tanto stored como computed con static. El acceso siempre es desde el tipo. No necesitas crear una instancia para leer o modificar estas propiedades (si son variables).

¿Se pueden usar en enums sin casos?

Sí. Un enum puede tener solo propiedades de tipo y cero casos si lo necesitas.

enum SomeEnum {
    static var storedTypeProperty: String = "some value"
    static var computedTypeProperty: Int { 5 }
}

let a = SomeEnum.storedTypeProperty     // "some value"
let b = SomeEnum.computedTypeProperty   // 5

• Las propiedades viven en el enum y son compartidas por todo el tipo.
• Es útil para constantes comunes o configuraciones.

¿Cómo acceder a las propiedades de tipo?

• Desde el tipo: SomeStruct.storedTypeProperty o SomeEnum.computedTypeProperty.
• Nunca desde la instancia: instance.propiedad no funciona para type properties.

¿Qué cambia en clases con class y sobrescritura?

En class, además de static, existe class var para propiedades de tipo. La clave: una computed type property declarada con class puede sobrescribirse en subclases; si usas static, no.

¿Cómo se declara y cuándo usar class var?

Usa class var cuando quieras permitir que una subclase redefina el valor calculado.

class SomeClass {
    static var storedTypeProperty: String = "some value"
    static var fixedComputedTypeProperty: Int { -9 } // no sobreescribible
    class var overrideableComputedTypeProperty: Int { 108 } // sobreescribible
}

class ChildClass: SomeClass {
    override class var overrideableComputedTypeProperty: Int { 42 }
}

let fixed = SomeClass.fixedComputedTypeProperty           // -9
let base = SomeClass.overrideableComputedTypeProperty     // 108
let child = ChildClass.overrideableComputedTypeProperty   // 42

• static en class: no permite sobrescritura.
• class var en class: permite que una subclase cambie el cálculo.

¿Para qué casos prácticos sirve una type property?

• Contador global asociado a un tipo.
• Constantes compartidas como un valor numérico fijo.
• Presupuesto común en un modelo de familia, donde todas las instancias comparten el mismo saldo.

Idea de práctica: modela un presupuesto de comida compartido con static para registrar gastos y aportes entre miembros. Úsalo para razonar sobre acceso desde el tipo y evitar modificarlo desde la instancia.

¿Tienes una implementación de presupuesto compartido u otra idea que aproveche static y class? Cuéntala en comentarios y comparte tu enfoque.