Si primero aprendes Objective-C o Java y luego pasas a Swift, hay un punto que casi siempre aparece.
La pregunta es: «¿Cómo clono un objeto?»
Es fácil perder tiempo buscando un método como clone(), pero en Swift casi nunca hace falta.
Empecemos por la conclusión.
Gracias a los tipos por valor, como las estructuras y los arrays, y a la optimización Copy-on-Write (copia diferida), Swift sustituye a nivel de lenguaje el «patrón Prototype» de los patrones de diseño.
No necesitas diseñar un patrón aparte para clonar objetos: basta con asignar el valor para obtener una copia segura.
Aquí resumiremos qué problema intentaba resolver originalmente el patrón Prototype y cómo los tipos por valor y Copy-on-Write de Swift lo absorben de forma natural, con ejemplos.
Para distinguir primero los tipos de copia, Copia superficial vs. copia profunda es la base. Si necesitas clonar clases, Patrón Prototype y NSCopying en Swift muestra la alternativa opuesta.
El problema que originalmente resolvía el patrón Prototype
El patrón Prototype pertenece a los patrones creacionales de GoF.
La idea es sencilla: en lugar de crear un objeto desde cero, clonas uno existente para obtener una instancia nueva.
¿Por qué hacía falta algo así?
En lenguajes como Objective-C o Java, los objetos suelen ser tipos por referencia.
Al asignar un objeto a una variable, no se copia el valor; solo se copia la dirección que apunta al mismo objeto.
Por eso, si cambias A, B también cambia.
Para evitarlo, los desarrolladores creaban métodos como clone() o copy() que devolvían una «copia real».
El patrón Prototype es una herramienta para estas situaciones.
- Cuando crear un objeto es costoso, pero necesitas varios objetos similares
- Cuando necesitas una copia independiente sin modificar el original
- Cuando quieres que el propio objeto se encargue de la lógica de clonación
Tipos por valor de Swift: asignar y listo
Las estructuras (struct), enumeraciones (enum) y tipos estándar como Array, Dictionary y String de Swift son todos tipos por valor.
Los tipos por valor se copian al asignarlos o pasarlos a una función.
En otras palabras, el lenguaje crea la copia automáticamente.
Con un ejemplo resulta mucho más claro.
struct Point { var x: Int; var y: Int }
var a = Point(x: 1, y: 2)
var b = a // el valor se copia en ese momento
b.x = 99
// a.xsigue siendo 1, b.xsolo 99b = a Una sola línea sustituye el trabajo que hacía clone() del patrón Prototype.
No necesitas un método de clonación separado ni adoptar un protocolo de copia.
El original a queda protegido de forma segura, y b se convierte en una copia completamente independiente.
Los molestos bugs causados por objetos entrelazados ni siquiera pueden producirse con esta estructura.
Cómo Copy-on-Write resuelve el problema de rendimiento
Aquí surge una preocupación natural.
«Si copiamos todo cada vez que asignamos, ¿los arrays grandes no se volverán demasiado lentos?»
Es una observación válida. Por eso Swift usa la optimización Copy-on-Write, abreviada como CoW.
El principio de CoW es el siguiente.
Al asignar un valor, primero se comparte el espacio de almacenamiento interno. La copia real de los datos se aplaza.
Cuando uno de los dos intenta modificar el valor, entonces se realiza la copia de verdad.
| Momento | Operación interna | Coste |
|---|---|---|
| Al asignar | Espacio compartido (solo referencia) | Muy bajo |
| Al leer únicamente | Se mantiene el uso compartido | Sin copia |
| Al modificar el valor | La copia real se realiza entonces | Solo ocurre en este momento |
Así, disfrutas de la seguridad de los tipos por valor sin pagar costes de copia innecesarios.
Si solo lees y no modificas, la copia ni siquiera se realiza.
Los tipos de la biblioteca estándar, como Array, Dictionary, Set y String, ya incorporan CoW.
El lenguaje y la biblioteca estándar se encargan de ello automáticamente, sin que tengas que implementarlo.
¿Cuándo sigue haciendo falta el patrón Prototype?
«Entonces, ¿el patrón Prototype está completamente muerto en Swift?»
No necesariamente.
Hay situaciones en las que debes usar una clase (class): cuando necesitas semántica de referencia, interoperabilidad con Objective-C o herencia.
En esos casos, si necesitas una copia independiente de una instancia de clase, todavía debes crear la lógica de clonación manualmente.
Swift ofrece el protocolo NSCopying y copy(), que representan, en la práctica, la forma tradicional del patrón Prototype.
Puedes pensarlo de esta manera.
- Usas estructuras y tipos por valor → Copia completada con una asignación; no necesitas el patrón Prototype
- Debes usar una clase → Implementa la clonación manualmente cuando sea necesario; aquí el patrón sigue vigente
Por eso la comunidad de Swift recomienda a menudo «considera primero los tipos por valor».
Si los usas como opción predeterminada, el problema de la clonación desaparece.
Para terminar
Intentar trasladar a la fuerza patrones de diseño de otro lenguaje suele complicar el código.
En Swift, los tipos por valor y Copy-on-Write ocupan naturalmente el lugar del patrón Prototype. Recordar esto aligera mucho las dudas sobre la clonación.
La próxima vez que necesites copiar un objeto, antes de buscar clone(), pregúntate: «¿Podría convertirlo en una estructura?» Seguro que te ayuda.