Interpreter (patrón de diseño)

De Wikipedia, la enciclopedia libre

Tienes mensajes nuevos (Dif. entre las dos últimas versiones).

El interpreter es un patrón de diseño que, dado un lenguaje, define una representación para su gramática junto con un intérprete del lenguaje.

Se usa para definir un lenguaje para representar expresiones regulares que representen cadenas a buscar dentro de otras cadenas. Además, en general, para definir un lenguaje que permita representar las distintas instancias de una familia de problemas.

[editar] Ejemplos

[editar] Java

El siguiente ejemplo en Java muestra como podría un lenguaje de proposito general podía interpretar un lenguaje más especializado, aquí la Notación polaca inversa.

La salida es:

'42 2 1 - +' equals 43

import java.util.*;

interface Expression {
   public void interpret(Stack<Integer> s);
}

class TerminalExpression_Number implements Expression {
   private int number;
   public TerminalExpression_Number(int number)       { this.number = number; }
   public void interpret(Stack<Integer> s)  { s.push(number); }
}

class TerminalExpression_Plus implements Expression {
   public void interpret(Stack<Integer> s)  { s.push( s.pop() + s.pop() ); }
}

class TerminalExpression_Minus implements Expression {
   public void interpret(Stack<Integer> s)  { int tmp = s.pop(); s.push( s.pop() - tmp ); }
}
 
class Parser {
   private ArrayList<Expression> parseTree = new ArrayList<Expression>(); // only one NonTerminal Expression here

   public Parser(String s) {
       for (String token : s.split(" ")) {
           if      (token.equals("+")) parseTree.add( new TerminalExpression_Plus() );
           else if (token.equals("-")) parseTree.add( new TerminalExpression_Minus() );
           // ...
           else                        parseTree.add( new TerminalExpression_Number(Integer.valueOf(token)) );
       }
   }

   public int evaluate() {
       Stack<Integer> context = new Stack<Integer>(); 
       for (Expression e : parseTree) e.interpret(context);
       return context.pop();
   }
}

class InterpreterExample {
   public static void main(String[] args) {
       System.out.println("'42 2 1 - +' equals " + new Parser("42 2 1 - +").evaluate());
   }
}

Patrones de Diseño
Creacionales: Abstract Factory \| Builder \| Factory Method \| Prototype \| Singleton \| Secreton
Estructurales: Adapter \| Bridge \| Composite \| Decorator \| Facade \| Flyweight \| Proxy
De Comportamiento: Chain of Responsibility \| Command \| Interpreter \| Iterator \| Mediator \| Memento \| Observer \| State \| Strategy \| Template Method \| Visitor