Arquetipo
Patrones creacionalesUso: MediaComplejidad: Baja

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

cancelSin el patrónANTES
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 plantilla
check_circleCon el patrónDESPUÉS
class 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 cambia

Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.

lightbulb

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.

Más ejercicios →

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.

prototype.ts · 53 líneas
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ó
Ver los 23 patrones en TypeScript →