Patrón Interpreter

💡 Ver Caso Práctico: Ejemplo Práctico del Patrón Interpreter

Interpreter (Intérprete) es un patrón de diseño comportamental que define una representación para la gramática de un lenguaje simple y un intérprete que usa esa representación para evaluar sentencias del lenguaje.

Propósito y Caso de Uso

Utiliza Interpreter cuando necesites evaluar expresiones de un mini-lenguaje propio (filtros de búsqueda tipo categoria:design-patterns AND tipo:handbook, reglas de negocio configurables, fórmulas matemáticas simples) sin recurrir a un parser completo de terceros. Cada regla gramatical se modela como una clase que sabe evaluarse a sí misma.

Estructura del Patrón

1. Expresión Abstracta: Declara el método interpret(context) común a todas las expresiones.
2. Expresiones Terminales: Representan los elementos más básicos de la gramática (ej. un literal o variable).
3. Expresiones No Terminales: Combinan otras expresiones (ej. AND, OR) y delegan la evaluación en ellas recursivamente.

Flujo de Funcionamiento

1. Construcción del árbol: Un parser sencillo transforma el texto de entrada en un árbol de expresiones.
2. Evaluación recursiva: Se invoca interpret(context) en la raíz, que delega en sus subexpresiones.
3. Resultado: Cada expresión terminal resuelve su parte, y las no terminales combinan los resultados.

Ejemplos de Implementación Reales

interface Expression {
  interpret(context: Record<string, string>): boolean;
}
 
class TermExpression implements Expression {
  constructor(private key: string, private value: string) {}
  interpret(context: Record<string, string>): boolean {
    return context[this.key] === this.value;
  }
}
 
class AndExpression implements Expression {
  constructor(private left: Expression, private right: Expression) {}
  interpret(context: Record<string, string>): boolean {
    return this.left.interpret(context) && this.right.interpret(context);
  }
}
 
const filter = new AndExpression(
  new TermExpression('category', 'design-patterns'),
  new TermExpression('type', 'handbook'),
);
 
console.log(filter.interpret({ category: 'design-patterns', type: 'handbook' })); // true
console.log(filter.interpret({ category: 'seo', type: 'handbook' })); // false

Cuándo NO usarlo

Si la gramática crece en complejidad (más de un puñado de reglas), es mejor usar un parser/librería dedicada; Interpreter se vuelve difícil de mantener con gramáticas grandes (YAGNIGlosarioYAGNI (You Aren't Gonna Need It)Principio de Extreme Programming (XP) que establece que un programador no debe añadir funcionalidad hasta que sea estrictamente necesario. Su objetivo es evitar la sobre-ingeniería (over-engineering), previniendo código para funcionalidades hipotéticas.Ver término completo →).