Prototype
Prototipo · Clonación
Crea objetos nuevos copiando un objeto existente, sin que el código dependa de su clase concreta ni exponga su estado interno.
“Crear el objeto desde cero es caro; prefiero copiar uno ya configurado.”
workEl caso real
Una aseguradora vende pólizas a partir de plantillas como "Auto Básico", "Auto Total" u "Hogar Premium". Cada plantilla trae coberturas, deducibles y cláusulas que el área técnica configura con reglas almacenadas en base de datos. El asesor parte de una plantilla y solo ajusta lo propio del cliente: el vehículo, la suma asegurada o un descuento.
warningEl problema sin el patrón
Para crear la póliza, el código copia campo por campo desde la plantilla. Cada vez que el área técnica añade un campo, alguien olvida copiarlo. Peor aún: la lista de coberturas se copia por referencia, así que modificar la póliza de un cliente modifica también la plantilla para todos.
check_circleCómo lo resuelve el patrón
Cada póliza sabe clonarse con clonar(). Como el propio objeto tiene acceso a sus campos privados, decide qué copiar en profundidad (las coberturas, que son mutables) y qué puede compartirse (datos inmutables). Un registro de prototipos guarda las plantillas listas para clonar.
schemaDiagrama de clases
Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.
codeEl código, antes y después
const poliza = new Poliza();
poliza.producto = plantilla.producto;
poliza.coberturas = plantilla.coberturas; // ❌ misma lista: se comparte la referencia
poliza.deducible = plantilla.deducible;
// ...¿y las cláusulas? alguien las olvidó
poliza.coberturas.push(coberturaExtra); // 💥 también cambia la plantillaclass Poliza {
constructor(
readonly producto: string,
private coberturas: Cobertura[],
private readonly clausulas: readonly string[],
) {}
clonar(): Poliza {
// Copia profunda de lo mutable; lo inmutable se puede compartir
const coberturas = this.coberturas.map((c) => ({ ...c }));
return new Poliza(this.producto, coberturas, this.clausulas);
}
agregarCobertura(c: Cobertura) { this.coberturas.push(c); }
}
const plantillas = new Map<string, Poliza>(); // registro de prototipos
const poliza = plantillas.get('auto-total')!.clonar();
poliza.agregarCobertura(coberturaExtra); // la plantilla no cambiaEjemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.
Matiz importante
La clave del patrón es decidir qué se copia en profundidad. Una copia superficial ({ ...obj } u Object.assign) solo copia el primer nivel: las listas y objetos internos siguen compartidos. JavaScript tiene structuredClone(), pero no conserva los métodos ni la clase del objeto; por eso el objeto suele implementar su propio clonar().
thumb_upCuándo usarlo
- ✓Creas objetos a partir de configuraciones costosas de armar (reglas, consultas, cálculos).
- ✓Tienes muchas variantes preconfiguradas y prefieres copiarlas antes que crear una subclase por cada una.
do_not_disturb_onCuándo no usarlo
- ✕El objeto es sencillo de construir: clonar no aporta nada.
- ✕El objeto tiene referencias circulares o recursos externos (conexiones, archivos abiertos) que no tiene sentido copiar.
memoryPrincipios en juego
- •Encapsulamiento: el objeto se copia a sí mismo sin exponer sus campos.
- •Independencia de clases concretas: el cliente clona sin saber qué subclase de póliza tiene.
hubPatrones relacionados
- •Abstract Factory: puede guardar prototipos y clonarlos en vez de instanciar clases.
- •Memento: en objetos simples, un clon puede servir como instantánea del estado.
- •Composite y Decorator: clonar estructuras complejas suele ser más fácil que reconstruirlas.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
code_blocksPrototype en tu lenguaje
El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.
LO IDIOMÁTICO EN TYPESCRIPT: El clon se crea con el propio constructor para conservar la clase y sus métodos, y structuredClone copia en profundidad los datos planos mutables (las coberturas). Las cláusulas son readonly string[], así que se pueden compartir sin riesgo.
export interface Cobertura {
nombre: string;
sumaAsegurada: number;
deducible: number;
}
export class Poliza {
constructor(
readonly producto: string,
private coberturas: Cobertura[],
private readonly clausulas: readonly string[],
) {}
clonar(): Poliza {
return new Poliza(this.producto, structuredClone(this.coberturas), this.clausulas);
}
agregarCobertura(cobertura: Cobertura): this {
this.coberturas.push(cobertura);
return this;
}
resumen(): string {
return `${this.producto}: ${this.coberturas.map((c) => c.nombre).join(', ')} (${this.clausulas.length} cláusulas)`;
}
}
// Registro de prototipos: plantillas configuradas una sola vez
const plantillas = new Map<string, Poliza>([
['auto-total', new Poliza(
'Auto Total',
[
{ nombre: 'Choque', sumaAsegurada: 30000, deducible: 500 },
{ nombre: 'Robo', sumaAsegurada: 30000, deducible: 800 },
],
['Vigencia anual', 'Cobertura nacional'],
)],
]);
export function cotizar(clave: string): Poliza {
const plantilla = plantillas.get(clave);
if (!plantilla) throw new Error(`No existe la plantilla ${clave}`);
return plantilla.clonar();
}
// ── Uso ──
const poliza = cotizar('auto-total')
.agregarCobertura({ nombre: 'Auto de reemplazo', sumaAsegurada: 1500, deducible: 0 });
console.log(poliza.resumen());
// Auto Total: Choque, Robo, Auto de reemplazo (2 cláusulas)
console.log(plantillas.get('auto-total')!.resumen());
// Auto Total: Choque, Robo (2 cláusulas) ← la plantilla no cambióLO IDIOMÁTICO EN C# / .NET: Los record traen la clonación incorporada: la expresión with crea una copia con algunos cambios. Pero es una copia superficial: la lista de coberturas seguiría compartida, así que Clonar la copia explícitamente con una expresión de colección ([.. Coberturas]).
var poliza = Plantillas.Cotizar("auto-total").AgregarCobertura(new Cobertura("Auto de reemplazo", 1_500, 0));
Console.WriteLine(poliza.Resumen()); // Auto Total: Choque, Robo, Auto de reemplazo (2 cláusulas)
Console.WriteLine(Plantillas.Obtener("auto-total").Resumen()); // Auto Total: Choque, Robo (2 cláusulas)
// Con `with` sin más, la lista se compartiría con la plantilla
var superficial = Plantillas.Obtener("auto-total") with { };
Console.WriteLine(ReferenceEquals(superficial.Coberturas, Plantillas.Obtener("auto-total").Coberturas)); // True
public record Cobertura(string Nombre, decimal SumaAsegurada, decimal Deducible);
public record Poliza(string Producto, List<Cobertura> Coberturas, IReadOnlyList<string> Clausulas)
{
public Poliza Clonar() => this with { Coberturas = [.. Coberturas] };
public Poliza AgregarCobertura(Cobertura cobertura)
{
Coberturas.Add(cobertura);
return this;
}
public string Resumen() =>
$"{Producto}: {string.Join(", ", Coberturas.Select(c => c.Nombre))} ({Clausulas.Count} cláusulas)";
}
// Registro de prototipos: plantillas configuradas una sola vez
public static class Plantillas
{
private static readonly Dictionary<string, Poliza> _plantillas = new()
{
["auto-total"] = new("Auto Total",
[new("Choque", 30_000, 500), new("Robo", 30_000, 800)],
["Vigencia anual", "Cobertura nacional"]),
};
public static Poliza Obtener(string clave) => _plantillas[clave];
public static Poliza Cotizar(string clave) =>
_plantillas.TryGetValue(clave, out var plantilla)
? plantilla.Clonar()
: throw new KeyNotFoundException($"No existe la plantilla {clave}");
}LO IDIOMÁTICO EN JAVA: En Java se evita Cloneable y clone(), que tienen un diseño problemático ("Effective Java", ítem 13). Lo idiomático es un constructor de copia: copia en profundidad lo mutable (la lista de coberturas) y comparte lo inmutable (List.copyOf y los record). La póliza también es un record.
void main() {
var poliza = Plantillas.cotizar("auto-total")
.agregarCobertura(new Cobertura("Auto de reemplazo", 1_500, 0));
IO.println(poliza.resumen()); // Auto Total: Choque, Robo, Auto de reemplazo (2 cláusulas)
IO.println(Plantillas.obtener("auto-total").resumen()); // Auto Total: Choque, Robo (2 cláusulas)
}
record Cobertura(String nombre, double sumaAsegurada, double deducible) {}
record Poliza(String producto, List<Cobertura> coberturas, List<String> clausulas) {
Poliza {
coberturas = new ArrayList<>(coberturas); // mutable: cada póliza necesita la suya
clausulas = List.copyOf(clausulas); // inmutable: se puede compartir
}
// Constructor de copia
Poliza(Poliza otra) {
this(otra.producto, otra.coberturas, otra.clausulas);
}
Poliza clonar() {
return new Poliza(this);
}
Poliza agregarCobertura(Cobertura cobertura) {
coberturas.add(cobertura);
return this;
}
String resumen() {
var nombres = coberturas.stream().map(Cobertura::nombre).collect(Collectors.joining(", "));
return "%s: %s (%d cláusulas)".formatted(producto, nombres, clausulas.size());
}
}
// Registro de prototipos: plantillas configuradas una sola vez
final class Plantillas {
private static final Map<String, Poliza> PLANTILLAS = Map.of(
"auto-total", new Poliza("Auto Total",
List.of(new Cobertura("Choque", 30_000, 500), new Cobertura("Robo", 30_000, 800)),
List.of("Vigencia anual", "Cobertura nacional")));
static Poliza obtener(String clave) {
return PLANTILLAS.get(clave);
}
static Poliza cotizar(String clave) {
var plantilla = PLANTILLAS.get(clave);
if (plantilla == null) throw new NoSuchElementException("No existe la plantilla " + clave);
return plantilla.clonar();
}
}LO IDIOMÁTICO EN JAVASCRIPT: JavaScript ya trabaja con prototipos: Object.create(Object.getPrototypeOf(this)) crea un objeto de la misma clase sin llamar al constructor. Ojo: debe ser el prototipo de la clase, no this; con Object.create(this) el clon heredaría del original. structuredClone copia en profundidad.
export class Poliza {
constructor(producto, coberturas, clausulas) {
this.producto = producto;
this.coberturas = coberturas;
this.clausulas = Object.freeze([...clausulas]); // inmutable: se puede compartir entre clones
}
clonar() {
const copia = Object.create(Object.getPrototypeOf(this)); // misma clase, mismos métodos
return Object.assign(copia, {
producto: this.producto,
coberturas: structuredClone(this.coberturas), // copia profunda de lo mutable
clausulas: this.clausulas,
});
}
agregarCobertura(cobertura) {
this.coberturas.push(cobertura);
return this;
}
resumen() {
return `${this.producto}: ${this.coberturas.map((c) => c.nombre).join(', ')} (${this.clausulas.length} cláusulas)`;
}
}
// Registro de prototipos: plantillas configuradas una sola vez
const plantillas = new Map([
['auto-total', new Poliza(
'Auto Total',
[{ nombre: 'Choque', sumaAsegurada: 30000, deducible: 500 }, { nombre: 'Robo', sumaAsegurada: 30000, deducible: 800 }],
['Vigencia anual', 'Cobertura nacional'],
)],
]);
export function cotizar(clave) {
const plantilla = plantillas.get(clave);
if (!plantilla) throw new Error(`No existe la plantilla ${clave}`);
return plantilla.clonar();
}
// ── Uso ──
const poliza = cotizar('auto-total').agregarCobertura({ nombre: 'Auto de reemplazo', sumaAsegurada: 1500, deducible: 0 });
console.log(poliza.resumen()); // Auto Total: Choque, Robo, Auto de reemplazo (2 cláusulas)
console.log(plantillas.get('auto-total').resumen()); // Auto Total: Choque, Robo (2 cláusulas)
console.log(poliza instanceof Poliza); // trueLO IDIOMÁTICO EN PYTHON: El módulo copy de la biblioteca estándar resuelve el patrón: copy.copy crea un objeto de la misma clase (copia superficial) y copy.deepcopy copia en profundidad. Lo habitual es combinarlos: copiar en profundidad solo lo mutable (las coberturas) y compartir lo inmutable (la tupla de cláusulas).
import copy
from dataclasses import dataclass
@dataclass
class Cobertura:
nombre: str
suma_asegurada: float
deducible: float
class Poliza:
def __init__(self, producto: str, coberturas: list[Cobertura], clausulas: tuple[str, ...]) -> None:
self.producto = producto
self.coberturas = coberturas
self.clausulas = clausulas # tupla: inmutable, se puede compartir entre clones
def clonar(self) -> "Poliza":
copia = copy.copy(self) # misma clase, mismos atributos
copia.coberturas = copy.deepcopy(self.coberturas) # copia profunda de lo mutable
return copia
def agregar_cobertura(self, cobertura: Cobertura) -> "Poliza":
self.coberturas.append(cobertura)
return self
def resumen(self) -> str:
nombres = ", ".join(c.nombre for c in self.coberturas)
return f"{self.producto}: {nombres} ({len(self.clausulas)} cláusulas)"
# Registro de prototipos: plantillas configuradas una sola vez
PLANTILLAS = {
"auto-total": Poliza(
"Auto Total",
[Cobertura("Choque", 30_000, 500), Cobertura("Robo", 30_000, 800)],
("Vigencia anual", "Cobertura nacional"),
),
}
def cotizar(clave: str) -> Poliza:
try:
return PLANTILLAS[clave].clonar()
except KeyError:
raise ValueError(f"No existe la plantilla {clave}") from None
if __name__ == "__main__":
poliza = cotizar("auto-total").agregar_cobertura(Cobertura("Auto de reemplazo", 1_500, 0))
print(poliza.resumen()) # Auto Total: Choque, Robo, Auto de reemplazo (2 cláusulas)
print(PLANTILLAS["auto-total"].resumen()) # Auto Total: Choque, Robo (2 cláusulas)
# Con una copia superficial, la lista se compartiría y la plantilla cambiaría también
mal = copy.copy(PLANTILLAS["auto-total"])
print(mal.coberturas is PLANTILLAS["auto-total"].coberturas) # True: ¡misma lista!LO IDIOMÁTICO EN GO: En Go, copiar un struct (copia := *p) ya copia sus campos, pero los slices y mapas siguen apuntando a los mismos datos: es una copia superficial. Clonar copia el struct y además duplica el slice de coberturas con slices.Clone.
package main
import (
"fmt"
"slices"
"strings"
)
type Cobertura struct {
Nombre string
SumaAsegurada float64
Deducible float64
}
type Poliza struct {
Producto string
Coberturas []Cobertura
Clausulas []string // no se modifican: se pueden compartir entre clones
}
func (p *Poliza) Clonar() *Poliza {
copia := *p // copia superficial de todos los campos
copia.Coberturas = slices.Clone(p.Coberturas) // copia propia de lo que sí cambia
return &copia
}
func (p *Poliza) Resumen() string {
nombres := make([]string, len(p.Coberturas))
for i, c := range p.Coberturas {
nombres[i] = c.Nombre
}
return fmt.Sprintf("%s: %s (%d cláusulas)", p.Producto, strings.Join(nombres, ", "), len(p.Clausulas))
}
// Registro de prototipos: plantillas configuradas una sola vez
var plantillas = map[string]*Poliza{
"auto-total": {
Producto: "Auto Total",
Coberturas: []Cobertura{{"Choque", 30_000, 500}, {"Robo", 30_000, 800}},
Clausulas: []string{"Vigencia anual", "Cobertura nacional"},
},
}
func Cotizar(clave string) (*Poliza, error) {
plantilla, existe := plantillas[clave]
if !existe {
return nil, fmt.Errorf("no existe la plantilla %s", clave)
}
return plantilla.Clonar(), nil
}
func main() {
poliza, _ := Cotizar("auto-total")
poliza.Coberturas[0].Deducible = 0 // descuento para este cliente
poliza.Coberturas = append(poliza.Coberturas, Cobertura{"Auto de reemplazo", 1_500, 0})
plantilla := plantillas["auto-total"]
fmt.Println(poliza.Resumen()) // Auto Total: Choque, Robo, Auto de reemplazo (2 cláusulas)
fmt.Println(plantilla.Resumen()) // Auto Total: Choque, Robo (2 cláusulas)
fmt.Println("Deducible de la plantilla:", plantilla.Coberturas[0].Deducible) // 500: no cambió
// Con una copia superficial, la plantilla se modificaría
mal := *plantilla
mal.Coberturas[0].Deducible = 0
fmt.Println("Tras una copia superficial:", plantilla.Coberturas[0].Deducible) // 0: ¡cambió la plantilla!
}LO IDIOMÁTICO EN RUST: En Rust el patrón es el trait Clone: #[derive(Clone)] genera la copia, y para un Vec copia también sus elementos (copia profunda). Lo inmutable se comparte con Rc: clonar un Rc solo incrementa un contador, así que las cláusulas no se duplican.
use std::collections::HashMap;
use std::rc::Rc;
#[derive(Clone)]
struct Cobertura {
nombre: String,
deducible: f64,
}
#[derive(Clone)]
struct Poliza {
producto: String,
coberturas: Vec<Cobertura>, // se copia en cada clon
clausulas: Rc<[String]>, // inmutable: se comparte entre clones
}
impl Poliza {
fn resumen(&self) -> String {
let nombres: Vec<&str> = self.coberturas.iter().map(|c| c.nombre.as_str()).collect();
format!(
"{}: {} ({} cláusulas)",
self.producto,
nombres.join(", "),
self.clausulas.len()
)
}
}
fn cobertura(nombre: &str, deducible: f64) -> Cobertura {
Cobertura {
nombre: nombre.to_string(),
deducible,
}
}
fn main() {
// Registro de prototipos: plantillas configuradas una sola vez
let plantillas = HashMap::from([(
"auto-total",
Poliza {
producto: "Auto Total".to_string(),
coberturas: vec![cobertura("Choque", 500.0), cobertura("Robo", 800.0)],
clausulas: Rc::from(vec![
"Vigencia anual".to_string(),
"Cobertura nacional".to_string(),
]),
},
)]);
let plantilla = &plantillas["auto-total"];
let mut poliza = plantilla.clone();
poliza.coberturas[0].deducible = 0.0; // descuento para este cliente
poliza.coberturas.push(cobertura("Auto de reemplazo", 0.0));
println!("{}", poliza.resumen()); // Auto Total: Choque, Robo, Auto de reemplazo (2 cláusulas)
println!("{}", plantilla.resumen()); // Auto Total: Choque, Robo (2 cláusulas)
println!(
"Deducible de la plantilla: {}",
plantilla.coberturas[0].deducible
); // 500
println!(
"Cláusulas compartidas: {}",
Rc::ptr_eq(&poliza.clausulas, &plantilla.clausulas)
); // true
}LO IDIOMÁTICO EN PHP: PHP trae el patrón en el lenguaje: clone copia un objeto y el método mágico __clone() se ejecuta sobre la copia para completar la copia profunda. Los arrays ya se copian por valor, pero los objetos que contienen no: __clone() clona cada cobertura.
<?php
declare(strict_types=1);
final class Cobertura
{
public function __construct(public string $nombre, public float $deducible) {}
}
final class Poliza
{
/** @param list<Cobertura> $coberturas @param list<string> $clausulas */
public function __construct(
public readonly string $producto,
private array $coberturas,
private readonly array $clausulas,
) {}
public function __clone()
{
// Copia profunda de lo mutable; las cláusulas son texto inmutable
$this->coberturas = array_map(fn (Cobertura $c) => clone $c, $this->coberturas);
}
public function agregarCobertura(Cobertura $cobertura): static
{
$this->coberturas[] = $cobertura;
return $this;
}
public function cobertura(int $indice): Cobertura
{
return $this->coberturas[$indice];
}
public function resumen(): string
{
$nombres = implode(', ', array_map(fn (Cobertura $c) => $c->nombre, $this->coberturas));
return sprintf('%s: %s (%d cláusulas)', $this->producto, $nombres, count($this->clausulas));
}
}
// Registro de prototipos: plantillas configuradas una sola vez
$plantillas = [
'auto-total' => new Poliza(
'Auto Total',
[new Cobertura('Choque', 500), new Cobertura('Robo', 800)],
['Vigencia anual', 'Cobertura nacional'],
),
];
$poliza = clone $plantillas['auto-total'];
$poliza->cobertura(0)->deducible = 0; // descuento para este cliente
$poliza->agregarCobertura(new Cobertura('Auto de reemplazo', 0));
echo $poliza->resumen(), "\n"; // Auto Total: Choque, Robo, Auto de reemplazo (2 cláusulas)
echo $plantillas['auto-total']->resumen(), "\n"; // Auto Total: Choque, Robo (2 cláusulas)
echo 'Deducible de la plantilla: ', $plantillas['auto-total']->cobertura(0)->deducible, "\n"; // 500