Mutación, compartición y aliasing inesperado

El aliasing ocurre cuando dos variables hacen referencia al mismo objeto. Con los tipos de valor es imposible; con los tipos de referencia provoca errores inesperados. Comprender esta diferencia es fundamental.

```swift var a = [1,2,3] var b = a // independent copy a.append(4) print(b) // [1,2,3] — unchanged ``` Cada asignación de un tipo de valor crea una copia independiente.

```swift class Counter { var value = 0 } let a = Counter() let b = a // SAME object a.value += 1 print(b.value) // 1 — b sees the change! ``` Tanto `a` como `b` apuntan al mismo objeto del montón.

```swift func increment(_ c: Counter) { c.value += 1 } let shared = Counter() increment(shared) print(shared.value) // 1 — mutated by the function ``` Las clases se pasan por referencia; la función modifica el original.

```swift class Cache { var items: [String] = [] } var cache = Cache() var cache2 = cache // aliased! cache.items.append("data") print(cache2.items) // ["data"] — unexpected! ``` Así es como partes del código aparentemente independientes se afectan entre sí.

```swift struct Cache { var items: [String] = [] } var cache = Cache() var cache2 = cache // independent copy cache.items.append("data") print(cache2.items) // [] — unaffected ```

```swift func process(_ c: Counter) { var local = Counter() local.value = c.value // copy values, not reference local.value += 1 } ``` Cuando necesite semántica de referencia, pero no aliasing, copie los valores explícitamente.

El aliasing se vuelve especialmente peligroso entre hilos: ```swift // Thread 1: cache.items.append("a") // Thread 2 simultaneously: cache.items.append("b") // ❌ data race! ``` Los tipos valor de Swift Concurrency lo evitan de forma predeterminada: solo los actores pueden compartir estado mutable.

El Thread Sanitizer (TSan) de Xcode detecta condiciones de carrera de datos durante la ejecución. Actívelo en Scheme > Diagnostics > Thread Sanitizer. Swift Exclusivity Enforcement detecta durante la ejecución las infracciones de aliasing en un solo hilo para los parámetros `inout`.

A veces el aliasing es intencional, por ejemplo, una caché global: ```swift class AppCache { static let shared = AppCache() // intentional shared reference var data: [String: Any] = [:] } ``` Documente claramente los casos de uso compartido intencional; evite el aliasing accidental usando tipos valor de forma predeterminada.

Conclusiones clave: • Tipos valor (struct): la asignación copia el valor; no es posible el aliasing • Tipos referencia (class): la asignación comparte la referencia; es posible el aliasing • El aliasing entre hilos = condición de carrera de datos • Use structs de forma predeterminada; use clases solo cuando necesite una identidad compartida • Use TSan y Swift Exclusivity para detectar problemas Siguiente: grafos mixtos de valores y referencias.