Intérprete (patrón de diseño)

Este artículo puede contener trabajos no publicados o declaraciones no verificadas (octubre 2014).

Puede ayudar agregando referencias o eliminando contenido no publicado. Consulte la página de discusión para obtener más detalles.

En ingeniería de software , el patrón de diseño del intérprete se utiliza para software que necesita un lenguaje para describir las operaciones que puede realizar.

El modelo de diseño del intérprete define la gramática de ese idioma y usa esa gramática para interpretar los estados en ese idioma.

Este patrón de diseño es muy útil en dos casos:

  1. cuando el software necesita analizar / analizar una cadena algebraica. Este es un caso bastante obvio en el que el software debe realizar operaciones de acuerdo con una ecuación (dibujar la curva de una función, por ejemplo)
  2. cuando el software necesita producir diferentes tipos de datos como resultado. Este caso es menos obvio, pero el intérprete es muy útil allí. Tomemos el ejemplo de un software capaz de mostrar datos en cualquier orden, clasificarlos o no, etc.

Este patrón define cómo interpretar los elementos del lenguaje.

En este patrón de diseño, hay una clase por terminal y un símbolo no terminal del lenguaje a interpretar.

El árbol de sintaxis del lenguaje está representado por una instancia del patrón de diseño de objeto compuesto .

Diagrama de clase

El patrón de diseño del intérprete se puede representar mediante el siguiente diagrama de clases:

Ejemplos de

Java

El siguiente ejemplo de Java muestra cómo interpretar un lenguaje especializado, como las expresiones de notación polaca inversa. En este lenguaje, damos los operandos antes que el operador.

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 NonTerminalExpression_Plus implements Expression { public void interpret(Stack<Integer> s) { s.push( s.pop() + s.pop() ); } } class NonTerminalExpression_Minus implements Expression { public void interpret(Stack<Integer> s) { s.push( - s.pop() + s.pop() ); } } 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 NonTerminalExpression_Plus() ); else if (token.equals("-")) parseTree.add( new NonTerminalExpression_Minus() ); // ... else parseTree.add( new TerminalExpression_Number(Integer.parseInt(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) { String expression = "42 4 2 - +"; Parser p = new Parser(expression); System.out.println("'" + expression +"' equals " + p.evaluate()); } }

Este programa muestra:

'42 4 2 - +' equals 44