Arquetipo
Patrones de comportamientoUso: BajaComplejidad: Alta

Interpreter

Intérprete

Define cómo representar la gramática de un lenguaje sencillo como objetos y cómo evaluar frases de ese lenguaje.

“Mis usuarios escriben reglas en un mini-lenguaje que debo evaluar.”

workEl caso real

Tu e-commerce permite que el equipo de marketing escriba sus propias reglas de promoción sin pedir un despliegue, por ejemplo: total > 100 Y cliente_frecuente O cupon = "VERANO". Cada regla debe evaluarse contra cada carrito durante el checkout.

warningEl problema sin el patrón

La regla se evalúa con expresiones regulares y comparaciones de texto o, peor, con eval(), que permite ejecutar código arbitrario. Cada operador nuevo complica más el código y los errores aparecen en producción.

check_circleCómo lo resuelve el patrón

Se define una clase por cada elemento de la gramática: expresiones terminales (una comparación, una condición) y no terminales (Y, O, NO). La regla se representa como un árbol de esos objetos, y evaluarla consiste en pedirle a la raíz que se interprete con los datos del carrito.

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
// Frágil y peligroso: eval ejecuta cualquier código
const aplica = eval(regla.replace('Y', '&&').replace('O', '||'));
check_circleCon el patrónDESPUÉS
interface Expresion {
  interpretar(carrito: Carrito): boolean;
}

class TotalMayorQue implements Expresion {
  constructor(private limite: number) {}
  interpretar(c: Carrito) { return c.total > this.limite; }
}

class EsClienteFrecuente implements Expresion {
  interpretar(c: Carrito) { return c.cliente.frecuente; }
}

class Y implements Expresion {
  constructor(private izquierda: Expresion, private derecha: Expresion) {}
  interpretar(c: Carrito) {
    return this.izquierda.interpretar(c) && this.derecha.interpretar(c);
  }
}

// Árbol que construye el parser a partir del texto de la regla
const regla = new Y(new TotalMayorQue(100), new EsClienteFrecuente());
regla.interpretar(carrito);

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

lightbulb

Matiz importante

Interpreter no incluye el análisis del texto (parsing). El patrón parte de que ya tienes el árbol de expresiones; convertir "total > 100 Y ..." en ese árbol es trabajo de un parser, que se construye aparte.

thumb_upCuándo usarlo

  • ✓Tienes un lenguaje pequeño y estable (reglas de negocio, filtros, fórmulas) que se evalúa muchas veces.
  • ✓Quieres que personas no técnicas definan reglas sin tocar el código.

do_not_disturb_onCuándo no usarlo

  • ✕La gramática es grande o cambia mucho: usa un generador de parsers (ANTLR, Tree-sitter) o un motor de reglas existente.
  • ✕El rendimiento es crítico: interpretar un árbol de objetos es más lento que compilar la regla.

memoryPrincipios en juego

  • •Composición: las expresiones complejas se forman combinando expresiones simples.
  • •Abierto/Cerrado: un operador nuevo es una clase nueva.

hubPatrones relacionados

  • •Composite: el árbol de expresiones es un Composite.
  • •Visitor: permite añadir operaciones al árbol (validar, imprimir, optimizar) sin cambiar las expresiones.
  • •Flyweight: las expresiones terminales que se repiten pueden compartirse.

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_blocksInterpreter en tu lenguaje

El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.

LO IDIOMÁTICO EN TYPESCRIPT: Cada elemento de la gramática es una clase que implementa Expresion; los no terminales guardan sus subexpresiones con parameter properties. Una alternativa muy habitual en TypeScript es modelar el árbol como unión discriminada y evaluarlo con un switch.

interpreter.ts · 49 líneas
export interface Carrito {
  total: number;
  clienteFrecuente: boolean;
  cupon?: string;
}

export interface Expresion {
  interpretar(carrito: Carrito): boolean;
  describir(): string;
}

export class TotalMayorQue implements Expresion {
  constructor(private readonly limite: number) {}
  interpretar(carrito: Carrito) { return carrito.total > this.limite; }
  describir() { return `total > ${this.limite}`; }
}

export class EsClienteFrecuente implements Expresion {
  interpretar(carrito: Carrito) { return carrito.clienteFrecuente; }
  describir() { return 'cliente_frecuente'; }
}

export class CuponIgual implements Expresion {
  constructor(private readonly codigo: string) {}
  interpretar(carrito: Carrito) { return carrito.cupon === this.codigo; }
  describir() { return `cupon = "${this.codigo}"`; }
}

export class Y implements Expresion {
  constructor(private readonly izquierda: Expresion, private readonly derecha: Expresion) {}
  interpretar(carrito: Carrito) { return this.izquierda.interpretar(carrito) && this.derecha.interpretar(carrito); }
  describir() { return `(${this.izquierda.describir()} Y ${this.derecha.describir()})`; }
}

export class O implements Expresion {
  constructor(private readonly izquierda: Expresion, private readonly derecha: Expresion) {}
  interpretar(carrito: Carrito) { return this.izquierda.interpretar(carrito) || this.derecha.interpretar(carrito); }
  describir() { return `(${this.izquierda.describir()} O ${this.derecha.describir()})`; }
}

// ── Uso ──
// Árbol de la regla: total > 100 Y cliente_frecuente O cupon = "VERANO"
// (en la aplicación real lo construiría un parser a partir del texto)
const regla = new O(new Y(new TotalMayorQue(100), new EsClienteFrecuente()), new CuponIgual('VERANO'));

console.log(regla.describir());
console.log(regla.interpretar({ total: 150, clienteFrecuente: true }));                  // true
console.log(regla.interpretar({ total: 150, clienteFrecuente: false }));                 // false
console.log(regla.interpretar({ total: 20, clienteFrecuente: false, cupon: 'VERANO' })); // true
Ver los 23 patrones en TypeScript →