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
// Frágil y peligroso: eval ejecuta cualquier código
const aplica = eval(regla.replace('Y', '&&').replace('O', '||'));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.
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.
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.
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' })); // trueLO IDIOMÁTICO EN C# / .NET: Las expresiones son record y la clase base sobrecarga los operadores & y |, así que una regla se escribe en C# casi igual que en el mini-lenguaje de promociones: (new TotalMayorQue(100) & new EsClienteFrecuente()) | new CuponIgual("VERANO").
var regla = (new TotalMayorQue(100) & new EsClienteFrecuente()) | new CuponIgual("VERANO");
Console.WriteLine(regla.Describir()); // ((total > 100 Y cliente_frecuente) O cupon = "VERANO")
Console.WriteLine(regla.Interpretar(new Carrito(150, ClienteFrecuente: true))); // True
Console.WriteLine(regla.Interpretar(new Carrito(150, ClienteFrecuente: false))); // False
Console.WriteLine(regla.Interpretar(new Carrito(20, false, Cupon: "VERANO"))); // True
public record Carrito(decimal Total, bool ClienteFrecuente, string? Cupon = null);
public abstract record Expresion
{
public abstract bool Interpretar(Carrito carrito);
public abstract string Describir();
public static Expresion operator &(Expresion izquierda, Expresion derecha) => new Y(izquierda, derecha);
public static Expresion operator |(Expresion izquierda, Expresion derecha) => new O(izquierda, derecha);
}
public sealed record TotalMayorQue(decimal Limite) : Expresion
{
public override bool Interpretar(Carrito carrito) => carrito.Total > Limite;
public override string Describir() => $"total > {Limite}";
}
public sealed record EsClienteFrecuente : Expresion
{
public override bool Interpretar(Carrito carrito) => carrito.ClienteFrecuente;
public override string Describir() => "cliente_frecuente";
}
public sealed record CuponIgual(string Codigo) : Expresion
{
public override bool Interpretar(Carrito carrito) => carrito.Cupon == Codigo;
public override string Describir() => $"cupon = \"{Codigo}\"";
}
public sealed record Y(Expresion Izquierda, Expresion Derecha) : Expresion
{
public override bool Interpretar(Carrito carrito) => Izquierda.Interpretar(carrito) && Derecha.Interpretar(carrito);
public override string Describir() => $"({Izquierda.Describir()} Y {Derecha.Describir()})";
}
public sealed record O(Expresion Izquierda, Expresion Derecha) : Expresion
{
public override bool Interpretar(Carrito carrito) => Izquierda.Interpretar(carrito) || Derecha.Interpretar(carrito);
public override string Describir() => $"({Izquierda.Describir()} O {Derecha.Describir()})";
}LO IDIOMÁTICO EN JAVA: Es el estilo de "programación orientada a datos" de Java 21+: el árbol es una interfaz sealed con record, y la evaluación es un switch con patrones de registro que el compilador revisa por completo (si falta un caso, no compila). Los métodos default y/o permiten escribir las reglas de forma encadenada.
void main() {
// total > 100 Y cliente_frecuente O cupon = "VERANO"
var regla = new TotalMayorQue(100).y(new EsClienteFrecuente()).o(new CuponIgual("VERANO"));
IO.println(regla.describir()); // ((total > 100 Y cliente_frecuente) O cupon = "VERANO")
IO.println(regla.interpretar(new Carrito(150, true, null))); // true
IO.println(regla.interpretar(new Carrito(150, false, null))); // false
IO.println(regla.interpretar(new Carrito(20, false, "VERANO"))); // true
}
record Carrito(double total, boolean clienteFrecuente, String cupon) {}
sealed interface Expresion permits TotalMayorQue, EsClienteFrecuente, CuponIgual, Y, O {
default boolean interpretar(Carrito c) {
return switch (this) {
case TotalMayorQue(var limite) -> c.total() > limite;
case EsClienteFrecuente() -> c.clienteFrecuente();
case CuponIgual(var codigo) -> codigo.equals(c.cupon());
case Y(var izquierda, var derecha) -> izquierda.interpretar(c) && derecha.interpretar(c);
case O(var izquierda, var derecha) -> izquierda.interpretar(c) || derecha.interpretar(c);
};
}
default String describir() {
return switch (this) {
case TotalMayorQue(var limite) -> "total > %.0f".formatted(limite);
case EsClienteFrecuente() -> "cliente_frecuente";
case CuponIgual(var codigo) -> "cupon = \"%s\"".formatted(codigo);
case Y(var izquierda, var derecha) -> "(%s Y %s)".formatted(izquierda.describir(), derecha.describir());
case O(var izquierda, var derecha) -> "(%s O %s)".formatted(izquierda.describir(), derecha.describir());
};
}
default Expresion y(Expresion otra) { return new Y(this, otra); }
default Expresion o(Expresion otra) { return new O(this, otra); }
}
record TotalMayorQue(double limite) implements Expresion {}
record EsClienteFrecuente() implements Expresion {}
record CuponIgual(String codigo) implements Expresion {}
record Y(Expresion izquierda, Expresion derecha) implements Expresion {}
record O(Expresion izquierda, Expresion derecha) implements Expresion {}LO IDIOMÁTICO EN JAVASCRIPT: Cada expresión de la gramática se crea con una pequeña función que devuelve un objeto con interpretar y describir. Las expresiones compuestas (y, o) cierran sobre sus partes, así que el árbol se arma combinando funciones, como si fuera el propio lenguaje de reglas.
const totalMayorQue = (limite) => ({
interpretar: (carrito) => carrito.total > limite,
describir: () => `total > ${limite}`,
});
const esClienteFrecuente = () => ({
interpretar: (carrito) => carrito.clienteFrecuente,
describir: () => 'cliente_frecuente',
});
const cuponIgual = (codigo) => ({
interpretar: (carrito) => carrito.cupon === codigo,
describir: () => `cupon = "${codigo}"`,
});
const y = (izquierda, derecha) => ({
interpretar: (carrito) => izquierda.interpretar(carrito) && derecha.interpretar(carrito),
describir: () => `(${izquierda.describir()} Y ${derecha.describir()})`,
});
const o = (izquierda, derecha) => ({
interpretar: (carrito) => izquierda.interpretar(carrito) || derecha.interpretar(carrito),
describir: () => `(${izquierda.describir()} O ${derecha.describir()})`,
});
// ── Uso ──
// Árbol de: total > 100 Y cliente_frecuente O cupon = "VERANO"
// (en la aplicación real lo construiría un parser a partir del texto)
const regla = o(y(totalMayorQue(100), esClienteFrecuente()), 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' })); // trueLO IDIOMÁTICO EN PYTHON: Cada elemento de la gramática es una dataclass, y la clase base sobrecarga los operadores & y | (__and__ y __or__). Así las reglas se escriben en Python casi como en el mini-lenguaje: (TotalMayorQue(100) & EsClienteFrecuente()) | CuponIgual("VERANO").
from abc import ABC, abstractmethod
from dataclasses import dataclass
@dataclass(frozen=True)
class Carrito:
total: float
cliente_frecuente: bool
cupon: str | None = None
class Expresion(ABC):
@abstractmethod
def interpretar(self, carrito: Carrito) -> bool: ...
def __and__(self, otra: "Expresion") -> "Expresion":
return Y(self, otra)
def __or__(self, otra: "Expresion") -> "Expresion":
return O(self, otra)
@dataclass(frozen=True)
class TotalMayorQue(Expresion):
limite: float
def interpretar(self, carrito: Carrito) -> bool:
return carrito.total > self.limite
@dataclass(frozen=True)
class EsClienteFrecuente(Expresion):
def interpretar(self, carrito: Carrito) -> bool:
return carrito.cliente_frecuente
@dataclass(frozen=True)
class CuponIgual(Expresion):
codigo: str
def interpretar(self, carrito: Carrito) -> bool:
return carrito.cupon == self.codigo
@dataclass(frozen=True)
class Y(Expresion):
izquierda: Expresion
derecha: Expresion
def interpretar(self, carrito: Carrito) -> bool:
return self.izquierda.interpretar(carrito) and self.derecha.interpretar(carrito)
@dataclass(frozen=True)
class O(Expresion):
izquierda: Expresion
derecha: Expresion
def interpretar(self, carrito: Carrito) -> bool:
return self.izquierda.interpretar(carrito) or self.derecha.interpretar(carrito)
if __name__ == "__main__":
# total > 100 Y cliente_frecuente O cupon = "VERANO"
regla = (TotalMayorQue(100) & EsClienteFrecuente()) | CuponIgual("VERANO")
print(regla) # el árbol, gracias al repr de las dataclasses
print(regla.interpretar(Carrito(150, cliente_frecuente=True))) # True
print(regla.interpretar(Carrito(150, cliente_frecuente=False))) # False
print(regla.interpretar(Carrito(20, cliente_frecuente=False, cupon="VERANO"))) # TrueLO IDIOMÁTICO EN GO: Cada expresión cumple la interfaz Expresion. Las terminales son tipos definidos sobre tipos básicos (type TotalMayorQue float64), algo muy propio de Go. Al implementar también String() (la interfaz fmt.Stringer), fmt.Println muestra la regla de forma legible.
package main
import "fmt"
type Carrito struct {
Total float64
ClienteFrecuente bool
Cupon string
}
type Expresion interface {
Interpretar(Carrito) bool
fmt.Stringer
}
type TotalMayorQue float64
func (t TotalMayorQue) Interpretar(c Carrito) bool { return c.Total > float64(t) }
func (t TotalMayorQue) String() string { return fmt.Sprintf("total > %g", float64(t)) }
type EsClienteFrecuente struct{}
func (EsClienteFrecuente) Interpretar(c Carrito) bool { return c.ClienteFrecuente }
func (EsClienteFrecuente) String() string { return "cliente_frecuente" }
type CuponIgual string
func (cupon CuponIgual) Interpretar(c Carrito) bool { return c.Cupon == string(cupon) }
func (cupon CuponIgual) String() string { return fmt.Sprintf("cupon = %q", string(cupon)) }
type Y struct{ Izquierda, Derecha Expresion }
func (y Y) Interpretar(c Carrito) bool { return y.Izquierda.Interpretar(c) && y.Derecha.Interpretar(c) }
func (y Y) String() string { return fmt.Sprintf("(%v Y %v)", y.Izquierda, y.Derecha) }
type O struct{ Izquierda, Derecha Expresion }
func (o O) Interpretar(c Carrito) bool { return o.Izquierda.Interpretar(c) || o.Derecha.Interpretar(c) }
func (o O) String() string { return fmt.Sprintf("(%v O %v)", o.Izquierda, o.Derecha) }
func main() {
// total > 100 Y cliente_frecuente O cupon = "VERANO"
// (en la aplicación real, este árbol lo construiría un parser a partir del texto)
var regla Expresion = O{Y{TotalMayorQue(100), EsClienteFrecuente{}}, CuponIgual("VERANO")}
fmt.Println(regla) // ((total > 100 Y cliente_frecuente) O cupon = "VERANO")
fmt.Println(regla.Interpretar(Carrito{Total: 150, ClienteFrecuente: true})) // true
fmt.Println(regla.Interpretar(Carrito{Total: 150, ClienteFrecuente: false})) // false
fmt.Println(regla.Interpretar(Carrito{Total: 20, Cupon: "VERANO"})) // true
}LO IDIOMÁTICO EN RUST: El árbol de la regla es un enum recursivo (con Box para los hijos) e interpretar es un match. Al implementar los traits BitAnd y BitOr, las reglas se escriben con & y |, y el trait Display las muestra de forma legible.
use std::fmt;
use std::ops::{BitAnd, BitOr};
struct Carrito {
total: f64,
cliente_frecuente: bool,
cupon: Option<&'static str>,
}
enum Expresion {
TotalMayorQue(f64),
EsClienteFrecuente,
CuponIgual(&'static str),
Y(Box<Expresion>, Box<Expresion>),
O(Box<Expresion>, Box<Expresion>),
}
impl Expresion {
fn interpretar(&self, carrito: &Carrito) -> bool {
match self {
Self::TotalMayorQue(limite) => carrito.total > *limite,
Self::EsClienteFrecuente => carrito.cliente_frecuente,
Self::CuponIgual(codigo) => carrito.cupon == Some(*codigo),
Self::Y(izquierda, derecha) => {
izquierda.interpretar(carrito) && derecha.interpretar(carrito)
}
Self::O(izquierda, derecha) => {
izquierda.interpretar(carrito) || derecha.interpretar(carrito)
}
}
}
}
impl BitAnd for Expresion {
type Output = Expresion;
fn bitand(self, otra: Expresion) -> Expresion {
Expresion::Y(Box::new(self), Box::new(otra))
}
}
impl BitOr for Expresion {
type Output = Expresion;
fn bitor(self, otra: Expresion) -> Expresion {
Expresion::O(Box::new(self), Box::new(otra))
}
}
impl fmt::Display for Expresion {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::TotalMayorQue(limite) => write!(f, "total > {limite}"),
Self::EsClienteFrecuente => write!(f, "cliente_frecuente"),
Self::CuponIgual(codigo) => write!(f, "cupon = \"{codigo}\""),
Self::Y(izquierda, derecha) => write!(f, "({izquierda} Y {derecha})"),
Self::O(izquierda, derecha) => write!(f, "({izquierda} O {derecha})"),
}
}
}
fn main() {
// total > 100 Y cliente_frecuente O cupon = "VERANO"
let regla = (Expresion::TotalMayorQue(100.0) & Expresion::EsClienteFrecuente)
| Expresion::CuponIgual("VERANO");
println!("{regla}"); // ((total > 100 Y cliente_frecuente) O cupon = "VERANO")
let carrito = |total, cliente_frecuente, cupon| Carrito {
total,
cliente_frecuente,
cupon,
};
println!("{}", regla.interpretar(&carrito(150.0, true, None))); // true
println!("{}", regla.interpretar(&carrito(150.0, false, None))); // false
println!(
"{}",
regla.interpretar(&carrito(20.0, false, Some("VERANO")))
); // true
}LO IDIOMÁTICO EN PHP: Cada elemento de la gramática es una clase readonly que implementa Expresion. La interfaz extiende Stringable (__toString), así que la regla se puede imprimir con echo de forma legible, y las expresiones compuestas guardan sus hijos con promoción de propiedades.
<?php
declare(strict_types=1);
final readonly class Carrito
{
public function __construct(public float $total, public bool $clienteFrecuente, public ?string $cupon = null) {}
}
interface Expresion extends Stringable
{
public function interpretar(Carrito $carrito): bool;
}
final readonly class TotalMayorQue implements Expresion
{
public function __construct(private float $limite) {}
public function interpretar(Carrito $carrito): bool { return $carrito->total > $this->limite; }
public function __toString(): string { return "total > {$this->limite}"; }
}
final readonly class EsClienteFrecuente implements Expresion
{
public function interpretar(Carrito $carrito): bool { return $carrito->clienteFrecuente; }
public function __toString(): string { return 'cliente_frecuente'; }
}
final readonly class CuponIgual implements Expresion
{
public function __construct(private string $codigo) {}
public function interpretar(Carrito $carrito): bool { return $carrito->cupon === $this->codigo; }
public function __toString(): string { return "cupon = \"{$this->codigo}\""; }
}
final readonly class Y implements Expresion
{
public function __construct(private Expresion $izquierda, private Expresion $derecha) {}
public function interpretar(Carrito $carrito): bool { return $this->izquierda->interpretar($carrito) && $this->derecha->interpretar($carrito); }
public function __toString(): string { return "({$this->izquierda} Y {$this->derecha})"; }
}
final readonly class O implements Expresion
{
public function __construct(private Expresion $izquierda, private Expresion $derecha) {}
public function interpretar(Carrito $carrito): bool { return $this->izquierda->interpretar($carrito) || $this->derecha->interpretar($carrito); }
public function __toString(): string { return "({$this->izquierda} O {$this->derecha})"; }
}
// total > 100 Y cliente_frecuente O cupon = "VERANO"
// (en la aplicación real, este árbol lo construiría un parser a partir del texto)
$regla = new O(new Y(new TotalMayorQue(100), new EsClienteFrecuente()), new CuponIgual('VERANO'));
echo $regla, "\n"; // ((total > 100 Y cliente_frecuente) O cupon = "VERANO")
var_dump($regla->interpretar(new Carrito(150, clienteFrecuente: true))); // bool(true)
var_dump($regla->interpretar(new Carrito(150, clienteFrecuente: false))); // bool(false)
var_dump($regla->interpretar(new Carrito(20, false, cupon: 'VERANO'))); // bool(true)