1.  <!doctype html>
  2.  <html lang="en">
  3.  <head>
  4.      <meta charset="UTF-8">
  5.      <title>解释器模式</title>
  6.  </head>
  7.  <body>
  8.  
  9.  &lt;root id="rootId"><br>
  10.  &lt;a> <br>
  11.  &lt;b> <br>
  12.  &lt;c name="testC">12345</c> <br>
  13.  &lt;d id="1">d1</d> <br>
  14.  &lt;d id="2">d2</d> <br>
  15.  &lt;d id="3">d3</d> <br>
  16.  &lt;d id="4">d4</d> <br>
  17.  &lt;/b> <br>
  18.  &lt;/a> <br>
  19.  &lt;/root> <br>
  20.  
  21.  <script>
  22.  /**
  23.   * 解释器模式
  24.   *
  25.   * 定义：
  26.   * 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
  27.   *
  28.   * 本质： 分离实现，解释执行
  29.   *
  30.   * 动机
  31.   * 如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。
  32.   *
  33.   * 抽象语法树
  34.   * 解释器模式并未解释如何创建一个抽象语法树。它不涉及语法分析。抽象语法树可用一个表驱动的语法分析程序来完成，也可用手写的（通常为递归下降法）语法分析程序创建，或直接client提供。
  35.   *
  36.   * 解析器
  37.   * 指的是把描述客户端调用要求的表达式，经过解析，形成一个抽象语法树的程序。
  38.   *
  39.   * 解释器
  40.   * 指的是解释抽象语法树，并执行每个节点对应的功能的程序。
  41.   *
  42.   * 要使用解释器模式，一个重要的前提就是要定义一套语法规则，也成为文法。不管这套文法的规则是简单还是复杂，必须要有这些规则，因为解释器模式就是按照这些规则来进行解析并执行相应的功能的。
  43.   *
  44.   * 解释器模式用过一个解释器对象处理一个语法规则的方式，把复杂的功能分离开；然后选择需要被执行的功能，并把这些功能组合成为需要被解释执行的抽象语法树；再按照抽象语法树来解释执行，实现相应的功能。
  45.   * 从表面上看，解释器模式关注的是我们平时不太用到的自定义语法的处理；但从实质上看，解释器模式的思想然后是分离，封装，简化，和很多模式是一样的。
  46.   * 比如，可以使用解释器模式模拟状态模式的功能。如果把解释器模式要处理的语法简化到只有一个状态标记，把解释器看成是对状态的处理对象，对同一个表示状态的语法，可以有很多不用的解释器，也就是有很多不同的处理状态的对象，然后再创建抽象语法树的时候，简化成根据状态的标记来创建相应的解释器，不用再构建树了。
  47.   * 同理，解释器模式可以模拟实现策略模式的功能，装饰器模式的功能等，尤其是模拟装饰器模式的功能，构建抽象语法树的过程，自然就对应成为组合装饰器的过程。
  48.   *
  49.   * 解释器模式执行速度通常不快（大多数时候非常慢），而且错误调试比较困难（附注：虽然调试比较困难，但事实上它降低了错误的发生可能性），但它的优势是显而易见的，它能有效控制模块之间接口的复杂性，对于那种执行频率不高但代码频率足够高，且多样性很强的功能，解释器是非常适合的模式。此外解释器还有一个不太为人所注意的优势，就是它可以方便地跨语言和跨平台。
  50.   *
  51.   * 优点：
  52.   * 1.易于实现语法
  53.   * 在解释器模式中，一条语法规则用一个解释器对象来解释执行。对于解释器的实现来讲，功能就变得比较简单，只需要考虑这一条语法规则的实现就可以了，其他的都不用管。
  54.   * 2.易于扩展新的语法
  55.   * 正是由于采用一个解释器对象负责一条语法规则的方式，使得扩展新的语法非常容易。扩展了新的语法，只需要创建相应的解释器对象，在创建抽象语法树的时候使用这个新的解释器对象就可以了。
  56.   *
  57.   * 缺点：
  58.   * 不适合复杂的语法
  59.   * 如果语法特别复杂，构建解释器模式需要的抽象语法树的工作是非常艰巨的，再加上有可能会需要构建多个抽象语法树。所以解释器模式不太适合复杂的语法。使用语法分析程序或编译器生成器可能会更好一些。
  60.   *
  61.   * 何时使用
  62.   * 当有一个语言需要解释执行，并且可以将该语言中的句子表示为一个抽象语法树的时候，可以考虑使用解释器模式。
  63.   * 在使用解释器模式的时候，还有两个特点需要考虑，一个是语法相对应该比较简单，太负责的语法不适合使用解释器模式玲玲一个是效率要求不是很高，对效率要求很高的，不适合使用。
  64.   *
  65.   *
  66.   */
  67.  
  68.  (function () {
  69.      // 示例代码
  70.  
  71.      // 终结符表达式
  72.      var TerminalExpression = function () {};
  73.      TerminalExpression.prototype = {
  74.          /**
  75.           * 解释的操作
  76.           * @param  {[type]} context [上下文]
  77.           */
  78.          interpret: function (context) {
  79.              // 实现与语法规则中的终结符相关联的解释操作
  80.          }
  81.      };
  82.  
  83.      // 非终结符表达式
  84.      var NonterminalExpression = function () {};
  85.      NonterminalExpression.prototype = {
  86.          interpret: function (context) {
  87.              // 实现与语法规则中的非终结符相关联的解释操作
  88.          }
  89.      };
  90.  
  91.      // 上下文，包含解释器之外的一些全局信息
  92.      var Context = function () {};
  93.  
  94.      // 使用解释器的客户
  95.      // 主要按照语法规则对特定句子构建抽象语法树
  96.      // 然后调用解释操作
  97.  }());
  98.  
  99.  (function () {
  100.      /**
  101.       * 1.为表达式设计简单的文法
  102.       *
  103.       * 为了通用，用root表示根元素，abc等来代表元素，一个简单的xml如下：
  104.       * <?xml version="1.0" encoding="UTF-8">
  105.       * <root id="rootId">
  106.       *     <a>
  107.       *         <b>
  108.       *             <c name="testC">12345</c>
  109.       *             <d id="1">d1</d>
  110.       *             <d id="2">d2</d>
  111.       *             <d id="3">d3</d>
  112.       *             <d id="4">d4</d>
  113.       *         </b>
  114.       *     </a>
  115.       * </root>
  116.       *
  117.       * 约定表达式的文法如下：
  118.       * 1.获取单个元素的值：从根元素开始，一直到想要获取取值的元素，元素中间用“/”分隔，根元素前不加“/”。比如，表达式“root/a/b/c”就表示获取根元素下，a元素下，b元素下，c元素的值。
  119.       * 2.获取单个元素的属性的值：当然是多个，要获取值的属性一定是表达式的最后一个元素的属性，在最后一个元素后面添加“.”然后再加上属性的名称。比如，表达式“root/a/b/c.name”就表示获取根元素下，a元素下，b元素下，c元素的name属性的值。
  120.       * 3.获取相同元素名称的值，当然是多个，要获取值的元素一定是表达式的最后一个元素，在最后一个元素后面添加“$”。比如，表达式“root/a/b/d$”就表示获取根元素下，a元素下，b元素下的多个d元素的值的集合。
  121.       * 4.获取相同元素名称的属性的值，当然也是多个：要获取属性值的元素一定是表达式的最后一个元素，在最后一个元素后面添加"$"。比如，表达式“root/a/b/d$.id$”就表示获取根元素下，a元素下，b元素下的多个d元素的id属性的值的集合。
  122.       */
  123.  
  124.      /**
  125.       * 上下文，用来包含解释器需要的一些全局信息
  126.       * @param {String} filePathName [需要读取的xml的路径和名字]
  127.       */
  128.      function Context(filePathName) {
  129.          // 上一个被处理元素
  130.          this.preEle = null;
  131.          // xml的Document对象
  132.          this.document = XmlUtil.getRoot(filePathName);
  133.      }
  134.  
  135.      Context.prototype = {
  136.          // 重新初始化上下文
  137.          reInit: function () {
  138.              this.preEle = null;
  139.          },
  140.          /**
  141.           *  各个Expression公共使用的方法
  142.           * 根据父元素和当前元素的名称来获取当前元素
  143.           * @param  {Element} pEle    [父元素]
  144.           * @param  {String} eleName [当前元素名称]
  145.           * @return {Element|null}         [找到的当前元素]
  146.           */
  147.          getNowEle: function (pEle, eleName) {
  148.              var tempNodeList = pEle.childNodes;
  149.              var nowEle;
  150.  
  151.              for (var i = 0, len = tempNodeList.length; i < len; i++) {
  152.                  if ((nowEle = tempNodeList[i]).nodeType === 1)
  153.                      if (nowEle.nodeName === eleName)
  154.                          return nowEle;
  155.              }
  156.  
  157.              return null;
  158.          },
  159.          getPreEle: function () {
  160.              return this.preEle;
  161.          },
  162.          setPreEle: function (preEle) {
  163.              this.preEle = preEle;
  164.          },
  165.          getDocument: function () {
  166.              return this.document;
  167.          }
  168.      };
  169.  
  170.      // 工具对象
  171.      // 解析xml，获取相应的Document对象
  172.      var XmlUtil = {
  173.          getRoot: function (filePathName) {
  174.              var parser = new DOMParser();
  175.              var xmldom = parser.parseFromString('<root id="rootId"><a><b><c name="testC">12345</c><d id="1">d1</d><d id="2">d2</d><d id="3">d3</d><d id="4">d4</d></b></a></root>', 'text/xml');
  176.  
  177.              return xmldom;
  178.          }
  179.      };
  180.  
  181.      /**
  182.       * 元素作为非终结符对应的解释器，解释并执行中间元素
  183.       * @param {String} eleName [元素的名称]
  184.       */
  185.      function ElementExpression(eleName) {
  186.          this.eles = [];
  187.          this.eleName = eleName;
  188.      }
  189.  
  190.      ElementExpression.prototype = {
  191.          addEle: function (eleName) {
  192.              this.eles.push(eleName);
  193.              return true;
  194.          },
  195.          removeEle: function (ele) {
  196.              for (var i = 0, len = this.eles.length; i < len; i++) {
  197.                  if (ele === this.eles[i])
  198.                      this.eles.splice(i--, 1);
  199.              }
  200.              return true;
  201.          },
  202.          interpret: function (context) {
  203.              // 先取出上下文中的当前元素作为父级元素
  204.              // 查找到当前元素名称所对应的xml元素，并设置回到上下文中
  205.              var pEle = context.getPreEle();
  206.  
  207.              if (!pEle) {
  208.                  // 说明现在获取的是根元素
  209.                  context.setPreEle(context.getDocument().documentElement);
  210.              } else {
  211.                  // 根据父级元素和要查找的元素的名称来获取当前的元素
  212.                  var nowEle = context.getNowEle(pEle, this.eleName);
  213.                  // 把当前获取的元素放到上下文中
  214.                  context.setPreEle(nowEle);
  215.              }
  216.  
  217.              var ss;
  218.              // 循环调用子元素的interpret方法
  219.              for (var i = 0, len = this.eles.length; i < len; i++) {
  220.                  ss = this.eles[i].interpret(context);
  221.              }
  222.  
  223.              // 返回最后一个解释器的解释结果，一般最后一个解释器就是终结符解释器了
  224.              return ss;
  225.          }
  226.      };
  227.  
  228.      /**
  229.       * 元素作为终结符对应的解释器
  230.       * @param {String} name [元素的名称]
  231.       */
  232.      function ElementTerminalExpression(name) {
  233.          this.eleName = name;
  234.      }
  235.  
  236.      ElementTerminalExpression.prototype = {
  237.          interpret: function (context) {
  238.              var pEle = context.getPreEle();
  239.              var ele = null;
  240.              if (!pEle) {
  241.                  ele = context.getDocument().documentElement;
  242.              } else {
  243.                  ele = context.getNowEle(pEle, this.eleName);
  244.                  context.setPreEle(ele);
  245.              }
  246.  
  247.              // 获取元素的值
  248.              return ele.firstChild.nodeValue;
  249.          }
  250.      };
  251.  
  252.      /**
  253.       * 属性作为终结符对应的解释器
  254.       * @param {String} propName [属性的名称]
  255.       */
  256.      function PropertyTerminalExpression(propName) {
  257.          this.propName = propName;
  258.      }
  259.  
  260.      PropertyTerminalExpression.prototype = {
  261.          interpret: function (context) {
  262.              // 直接获取最后的元素属性的值
  263.              return context.getPreEle().getAttribute(this.propName);
  264.          }
  265.      };
  266.  
  267.      new function () {
  268.          var c = new Context('InterpreterTest.xml');
  269.          // 想要获取多个d元素的值，也就是如下表达式的值：“root/a/b/c”
  270.          // 首先要构建解释器的抽象语法树
  271.          var root = new ElementExpression('root');
  272.          var aEle = new ElementExpression('a');
  273.          var bEle = new ElementExpression('b');
  274.          var cEle = new ElementTerminalExpression('c');
  275.  
  276.          // 组合
  277.          root.addEle(aEle);
  278.          aEle.addEle(bEle);
  279.          bEle.addEle(cEle);
  280.  
  281.          console.log('c的值是 = ' + root.interpret(c));
  282.  
  283.      }();
  284.  
  285.      new function () {
  286.          var c = new Context('InterpreterTest.xml');
  287.          // 想要获取d元素的id属性，也就是如下表达式的值：“a/b/c.name”
  288.          // 这个时候c不是终结了，需要把c修改成ElementExpression
  289.          var root = new ElementExpression('root');
  290.          var aEle = new ElementExpression('a');
  291.          var bEle = new ElementExpression('b');
  292.          var cEle = new ElementExpression('c');
  293.          var prop = new PropertyTerminalExpression('name');
  294.  
  295.          // 组合
  296.          root.addEle(aEle);
  297.          aEle.addEle(bEle);
  298.          bEle.addEle(cEle);
  299.          cEle.addEle(prop);
  300.  
  301.          console.log('c的属性name值是 = ' + root.interpret(c));
  302.  
  303.          // 如果要使用同一个上下文，连续进行解析，需要重新初始化上下文对象
  304.          // 比如，要连续的重新再获取一次属性name的值，当然你可以重新组合元素
  305.          // 重新解析，只要是在使用同一个上下文，就需要重新初始化上下文对象
  306.          c.reInit();
  307.          console.log('重新获取c的属性name值是 = ' + root.interpret(c));
  308.      }();
  309.  
  310.      // 读取多个元素或属性的值
  311.      (function () {
  312.          /**
  313.           * 上下文，用来包含解释器需要的一些全局信息
  314.           * @param {String} filePathName [需要读取的xml的路径和名字]
  315.           */
  316.          function Context(filePathName) {
  317.              // 上一个被处理的多个元素
  318.              this.preEles = [];
  319.              // xml的Document对象
  320.              this.document = XmlUtil.getRoot(filePathName);
  321.          }
  322.  
  323.          Context.prototype = {
  324.              // 重新初始化上下文
  325.              reInit: function () {
  326.                  this.preEles = [];
  327.              },
  328.              /**
  329.               *  各个Expression公共使用的方法
  330.               * 根据父元素和当前元素的名称来获取当前元素
  331.               * @param  {Element} pEle    [父元素]
  332.               * @param  {String} eleName [当前元素名称]
  333.               * @return {Element|null}         [找到的当前元素]
  334.               */
  335.              getNowEles: function (pEle, eleName) {
  336.                  var elements = [];
  337.                  var tempNodeList = pEle.childNodes;
  338.                  var nowEle;
  339.  
  340.                  for (var i = 0, len = tempNodeList.length; i < len; i++) {
  341.                      if ((nowEle = tempNodeList[i]).nodeType === 1) {
  342.                          if (nowEle.nodeName === eleName) {
  343.                              elements.push(nowEle);
  344.                          }
  345.                      }
  346.                  }
  347.  
  348.                  return elements;
  349.              },
  350.              getPreEles: function () {
  351.                  return this.preEles;
  352.              },
  353.              setPreEles: function (nowEles) {
  354.                  this.preEles = nowEles;
  355.              },
  356.              getDocument: function () {
  357.                  return this.document;
  358.              }
  359.          };
  360.  
  361.          // 工具对象
  362.          // 解析xml，获取相应的Document对象
  363.          var XmlUtil = {
  364.              getRoot: function (filePathName) {
  365.                  var parser = new DOMParser();
  366.                  var xmldom = parser.parseFromString('<root id="rootId"><a><b><c name="testC">12345</c><d id="1">d1</d><d id="2">d2</d><d id="3">d3</d><d id="4">d4</d></b></a></root>', 'text/xml');
  367.  
  368.                  return xmldom;
  369.              }
  370.          };
  371.  
  372.          /**
  373.           * 元素作为非终结符对应的解释器，解释并执行中间元素
  374.           * @param {String} eleName [元素的名称]
  375.           */
  376.          function ElementExpression(eleName) {
  377.              this.eles = [];
  378.              this.eleName = eleName;
  379.          }
  380.  
  381.          ElementExpression.prototype = {
  382.              addEle: function (eleName) {
  383.                  this.eles.push(eleName);
  384.                  return true;
  385.              },
  386.              removeEle: function (ele) {
  387.                  for (var i = 0, len = this.eles.length; i < len; i++) {
  388.                      if (ele === this.eles[i]) {
  389.                          this.eles.splice(i--, 1);
  390.                      }
  391.                  }
  392.                  return true;
  393.              },
  394.              interpret: function (context) {
  395.                  // 先取出上下文中的当前元素作为父级元素
  396.                  // 查找到当前元素名称所对应的xml元素，并设置回到上下文中
  397.                  var pEles = context.getPreEles();
  398.                  var ele = null;
  399.                  var nowEles = [];
  400.  
  401.                  if (!pEles.length) {
  402.                      // 说明现在获取的是根元素
  403.                      ele = context.getDocument().documentElement;
  404.                      pEles.push(ele);
  405.                      context.setPreEles(pEles);
  406.                  } else {
  407.                      var tempEle;
  408.                      for (var i = 0, len = pEles.length; i < len; i++) {
  409.                          tempEle = pEles[i];
  410.                          nowEles = nowEles.concat(context.getNowEles(tempEle, this.eleName));
  411.  
  412.                          // 找到一个就停止
  413.                          if (nowEles.length) break;
  414.                      }
  415.  
  416.                      context.setPreEles([nowEles[0]]);
  417.                  }
  418.  
  419.                  var ss;
  420.                  // 循环调用子元素的interpret方法
  421.                  for (var i = 0, len = this.eles.length; i < len; i++) {
  422.                      ss = this.eles[i].interpret(context);
  423.                  }
  424.  
  425.                  return ss;
  426.              }
  427.          };
  428.  
  429.          /**
  430.           * 元素作为终结符对应的解释器
  431.           * @param {String} name [元素的名称]
  432.           */
  433.          function ElementTerminalExpression(name) {
  434.              this.eleName = name;
  435.          }
  436.  
  437.          ElementTerminalExpression.prototype = {
  438.              interpret: function (context) {
  439.                  var pEles = context.getPreEles();
  440.                  var ele = null;
  441.                  if (!pEles.length) {
  442.                      ele = context.getDocument().documentElement;
  443.                  } else {
  444.                      ele = context.getNowEles(pEles[0], this.eleName)[0];
  445.                  }
  446.  
  447.                  // 获取元素的值
  448.                  return ele.firstChild.nodeValue;
  449.              }
  450.          };
  451.  
  452.          /**
  453.           * 属性作为终结符对应的解释器
  454.           * @param {String} propName [属性的名称]
  455.           */
  456.          function PropertyTerminalExpression(propName) {
  457.              this.propName = propName;
  458.          }
  459.  
  460.          PropertyTerminalExpression.prototype = {
  461.              interpret: function (context) {
  462.                  // 直接获取最后的元素属性的值
  463.                  return context.getPreEles()[0].getAttribute(this.propName);
  464.              }
  465.          };
  466.  
  467.          /**
  468.           * 多个属性作为终结符对应的解释器
  469.           * @param {String} propName [属性的名称]
  470.           */
  471.          function PropertysTerminalExpression(propName) {
  472.              this.propName = propName;
  473.          }
  474.  
  475.          PropertysTerminalExpression.prototype = {
  476.              interpret: function (context) {
  477.                  var eles = context.getPreEles();
  478.                  var ss = [];
  479.  
  480.                  for (var i = 0, len = eles.length; i < len; i++) {
  481.                      ss.push(eles[i].getAttribute(this.propName));
  482.                  }
  483.  
  484.                  return ss;
  485.              }
  486.          };
  487.  
  488.          /**
  489.           * 以多个元素作为终结符的解释处理对象
  490.           * @param {[type]} name [description]
  491.           */
  492.          function ElementsTerminalExpression(name) {
  493.              this.eleName = name;
  494.          }
  495.  
  496.          ElementsTerminalExpression.prototype = {
  497.              interpret: function (context) {
  498.                  var pEles = context.getPreEles();
  499.                  var nowEles = [];
  500.  
  501.                  for (var i = 0, len = pEles.length; i < len; i++) {
  502.                      nowEles = nowEles.concat(context.getNowEles(pEles[i], this.eleName));
  503.                  }
  504.  
  505.                  var ss = [];
  506.  
  507.                  for (i = 0, len = nowEles.length; i < len; i++) {
  508.                      ss.push(nowEles[i].firstChild.nodeValue);
  509.                  }
  510.  
  511.                  return ss;
  512.              }
  513.          };
  514.  
  515.          /**
  516.           * 多个元素作为非终结符的解释处理对象
  517.           */
  518.          function ElementsExpression(name) {
  519.              this.eleName = name;
  520.              this.eles = [];
  521.          }
  522.  
  523.          ElementsExpression.prototype = {
  524.              interpret: function (context) {
  525.                  var pEles = context.getPreEles();
  526.                  var nowEles = [];
  527.  
  528.                  for (var i = 0, len = pEles.length; i < len; i++) {
  529.                      nowEles = nowEles.concat(context.getNowEles(pEles[i], this.eleName));
  530.                  }
  531.                  context.setPreEles(nowEles);
  532.  
  533.                  var ss;
  534.                  for (i = 0, len = this.eles.length; i < len; i++) {
  535.                      ss = this.eles[i].interpret(context);
  536.                  }
  537.  
  538.                  return ss;
  539.              },
  540.              addEle: function (ele) {
  541.                  this.eles.push(ele);
  542.                  return true;
  543.              },
  544.              removeEle: function (ele) {
  545.                  for (var i = 0, len = this.eles.length; i < len; i++) {
  546.                      if (ele === this.eles[i]) {
  547.                          this.eles.splice(i--, 1);
  548.                      }
  549.                  }
  550.                  return true;
  551.              }
  552.          };
  553.  
  554.          new function () {
  555.              // "root/a/b/d$"
  556.              var c = new Context('Interpreter.xml');
  557.              var root = new ElementExpression('root');
  558.              var aEle = new ElementExpression('a');
  559.              var bEle = new ElementExpression('b');
  560.              var dEle = new ElementsTerminalExpression('d');
  561.  
  562.              root.addEle(aEle);
  563.              aEle.addEle(bEle);
  564.              bEle.addEle(dEle);
  565.  
  566.              var ss = root.interpret(c);
  567.  
  568.              for (var i = 0, len = ss.length; i < len; i++) {
  569.                  console.log('d的值是 = ' + ss[i]);
  570.              }
  571.          }();
  572.  
  573.          new function () {
  574.              // a/b/d$.id$
  575.              var c = new Context('Interpreter.xml');
  576.              var root = new ElementExpression('root');
  577.              var aEle = new ElementExpression('a');
  578.              var bEle = new ElementExpression('b');
  579.              var dEle = new ElementsExpression('d');
  580.              var prop = new PropertysTerminalExpression('id');
  581.  
  582.              root.addEle(aEle);
  583.              aEle.addEle(bEle);
  584.              bEle.addEle(dEle);
  585.              dEle.addEle(prop);
  586.  
  587.              var ss = root.interpret(c);
  588.  
  589.              for (var i = 0, len = ss.length; i < len; i++) {
  590.                  console.log('d的属性id的值是 = ' + ss[i]);
  591.              }
  592.          }();
  593.  
  594.          // 解析器
  595.  
  596.          /**
  597.           * 解析器的实现思路
  598.           * 1.把客户端传递来的表达式进行分解，分解成为一个一个的元素，并用一个对应的解析模型来封装这个元素的一些信息。
  599.           * 2.根据每个元素的信息，转化成相对应的解析器对象。
  600.           * 3.按照先后顺序，把这些解析器对象组合起来，就得到抽象语法树了。
  601.           *
  602.           * 为什么不把1和2合并,直接分解出一个元素就转换成相应的解析器对象？
  603.           * 1.功能分离，不要让一个方法的功能过于复杂。
  604.           * 2.为了今后的修改和扩展，现在语法简单，所以转换成解析器对象需要考虑的东西少，直接转换也不难，但要是语法复杂了，直接转换就很杂乱了。
  605.           */
  606.  
  607.          /**
  608.           * 用来封装每一个解析出来的元素对应的属性
  609.           */
  610.          function ParserModel() {
  611.              // 是否单个值
  612.              this.singleValue;
  613.              // 是否属性，不是属性就是元素
  614.              this.propertyValue;
  615.              // 是否终结符
  616.              this.end;
  617.          }
  618.  
  619.          ParserModel.prototype = {
  620.              isEnd: function () {
  621.                  return this.end;
  622.              },
  623.              setEnd: function (end) {
  624.                  this.end = end;
  625.              },
  626.              isSingleValue: function () {
  627.                  return this.singleValue;
  628.              },
  629.              setSingleValue: function (oneValue) {
  630.                  this.singleValue = oneValue;
  631.              },
  632.              isPropertyValue: function () {
  633.                  return this.propertyValue;
  634.              },
  635.              setPropertyValue: function (propertyValue) {
  636.                  this.propertyValue = propertyValue;
  637.              }
  638.          };
  639.  
  640.          var Parser = function () {
  641.              var BACKLASH = '/';
  642.              var DOT = '.';
  643.              var DOLLAR = '$';
  644.              // 按照分解的先后记录需要解析的元素的名称
  645.              var listEle = null;
  646.  
  647.              // 开始实现第一步-------------------------------------
  648.  
  649.              /**
  650.               * 传入一个字符串表达式，通过解析，组合成为一个抽象语法树
  651.               * @param  {String} expr [描述要取值的字符串表达式]
  652.               * @return {Object}      [对应的抽象语法树]
  653.               */
  654.              function parseMapPath(expr) {
  655.                  // 先按照“/”分割字符串
  656.                  var tokenizer = expr.split(BACKLASH);
  657.                  // 用来存放分解出来的值的表
  658.                  var mapPath = {};
  659.                  var onePath, eleName, propName;
  660.                  var dotIndex = -1;
  661.  
  662.                  for (var i = 0, len = tokenizer.length; i < len; i++) {
  663.                      onePath = tokenizer[i];
  664.  
  665.                      if (tokenizer[i + 1]) {
  666.                          // 还有下一个值，说明这不是最后一个元素
  667.                          // 按照现在的语法，属性必然在最后，因此也不是属性
  668.                          setParsePath(false, onePath, false, mapPath);
  669.                      } else {
  670.                          // 说明到最后了
  671.                          dotIndex = onePath.indexOf(DOT);
  672.  
  673.                          if (dotIndex >= 0) {
  674.                              // 说明是要获取属性的值，那就按照“.”来分割
  675.                              // 前面的就是元素名称，后面的是属性的名字
  676.                              eleName = onePath.substring(0, dotIndex);
  677.                              propName = onePath.substring(dotIndex + 1);
  678.  
  679.                              // 设置属性前面的那个元素，自然不是最后一个，也不是属性
  680.                              setParsePath(false, eleName, false, mapPath);
  681.                              // 设置属性，按照现在的语法定义，属性只能是最后一个
  682.                              setParsePath(true, propName, true, mapPath);
  683.                          } else {
  684.                              // 说明是取元素的值，而且是最后一个元素的值
  685.                              setParsePath(true, onePath, false, mapPath);
  686.                          }
  687.  
  688.                          break;
  689.                      }
  690.                  }
  691.  
  692.                  return mapPath;
  693.              }
  694.  
  695.              /**
  696.               * 按照分解出来的位置和名称来设置需要解析的元素名称
  697.               * @param {Boolean} end           [是否最后一个]
  698.               * @param {String} ele           [元素名称]
  699.               * @param {Boolean} propertyValue [是否取属性]
  700.               * @param {Object} mapPath       [设置需要解析的元素名称，还有该元素对应的解析模型的表]
  701.               */
  702.              function setParsePath(end, ele, propertyValue, mapPath) {
  703.                  var pm = new ParserModel();
  704.                  pm.setEnd(end);
  705.                  // 如果带有“$”符号就说明不是一个值
  706.                  pm.setSingleValue(!(ele.indexOf(DOLLAR) >= 0));
  707.                  pm.setPropertyValue(propertyValue);
  708.                  // 去掉"$"
  709.                  ele = ele.replace(DOLLAR, '');
  710.                  mapPath[ele] = pm;
  711.                  listEle.push(ele);
  712.              }
  713.  
  714.              // 开始实现第二步-------------------------------------
  715.  
  716.              /**
  717.               * 把分解出来的元素名称根据对应的解析模型转换成为相应的解释器对象
  718.               * @param  {Object} mapPath [分解出来的需解析的元素名称，还有该元素对应的解析模型]
  719.               * @return {Array}         [把每个元素转换成为相应的解释器对象后的数组]
  720.               */
  721.              function mapPath2Interpreter(mapPath) {
  722.                  var list = [];
  723.                  var pm, key;
  724.                  var obj = null;
  725.  
  726.                  // 一定要按照分解的先后顺序来转换成解释器对象
  727.                  for (var i = 0, len = listEle.length; i < len; i++) {
  728.                      key = listEle[i];
  729.                      pm = mapPath[key];
  730.  
  731.                      // 不是最后一个
  732.                      if (!pm.isEnd()) {
  733.  
  734.                          if (pm.isSingleValue())
  735.                          // 是一个值，转化
  736.                              obj = new ElementExpression(key);
  737.                          else
  738.                          // 是多个值，转化
  739.                              obj = new ElementsExpression(key);
  740.  
  741.                      } else {
  742.                          // 是最后一个
  743.  
  744.                          // 是属性值
  745.                          if (pm.isPropertyValue()) {
  746.                              if (pm.isSingleValue())
  747.                                  obj = new PropertyTerminalExpression(key);
  748.                              else
  749.                                  obj = new PropertysTerminalExpression(key);
  750.  
  751.                              // 取元素的值
  752.                          } else {
  753.                              if (pm.isSingleValue())
  754.                                  obj = new ElementTerminalExpression(key);
  755.                              else
  756.                                  obj = new ElementsTerminalExpression(key);
  757.                          }
  758.                      }
  759.  
  760.                      list.push(obj);
  761.                  }
  762.  
  763.                  return list;
  764.              }
  765.  
  766.              // 开始实现第三步-------------------------------------
  767.  
  768.              /**
  769.               * 构建抽象语法树
  770.               * @param  {[type]} list [把每个元素转换成为相应的解释器对象后的数组]
  771.               * @return {[type]}      [description]
  772.               */
  773.              function buildTree(list) {
  774.                  // 第一个对象，也是返回去的对象，就是抽象语法树的根
  775.                  var returnReadXMLExpr = null;
  776.                  // 定义上一个对象
  777.                  var preReadXmlExpr = null;
  778.                  var readXml, ele, eles;
  779.  
  780.                  for (var i = 0, len = list.length; i < len; i++) {
  781.                      readXml = list[i];
  782.                      // 说明是第一个元素
  783.                      if (preReadXmlExpr === null) {
  784.                          preReadXmlExpr = readXml;
  785.                          returnReadXMLExpr = readXml;
  786.  
  787.                          // 把元素添加到上一个对象下面，同时把本对象设置成为oldRe
  788.                          // 作为下一个对象的父节点
  789.                      } else {
  790.                          if (preReadXmlExpr instanceof ElementExpression) {
  791.                              ele = preReadXmlExpr;
  792.                              ele.addEle(readXml);
  793.                              preReadXmlExpr = readXml;
  794.                          } else if (preReadXmlExpr instanceof ElementsExpression) {
  795.                              eles = preReadXmlExpr;
  796.                              eles.addEle(readXml);
  797.                              preReadXmlExpr = readXml;
  798.                          }
  799.                      }
  800.                  }
  801.  
  802.                  return returnReadXMLExpr;
  803.              }
  804.  
  805.              return {
  806.                  // 公共方法
  807.                  parse: function (expr) {
  808.                      listEle = [];
  809.  
  810.                      var mapPath = parseMapPath(expr);
  811.                      var list = mapPath2Interpreter(mapPath);
  812.  
  813.                      return buildTree(list);
  814.                  }
  815.              };
  816.          }();
  817.  
  818.          new function () {
  819.              // 准备上下文
  820.              var c = new Context('Interpreter.xml');
  821.              // 通过解析其获取抽象语法树
  822.              var readXmlExpr = Parser.parse('root/a/b/d$.id$');
  823.              // 请求解析，获取返回值
  824.              var ss = readXmlExpr.interpret(c);
  825.  
  826.              console.log('------------parsing--------------');
  827.              for (var i = 0, len = ss.length; i < len; i++) {
  828.                  console.log('d的属性id的值是 = ' + ss[i]);
  829.              }
  830.              console.log('---------------parsed--------------');
  831.  
  832.              // 如果要使用同一个上下文，连续进行解析，需要重新初始化上下文对象
  833.              c.reInit();
  834.              var readxmlExpr2 = Parser.parse('root/a/b/d$');
  835.              var ss2 = readxmlExpr2.interpret(c);
  836.              console.log('------------parsing--------------');
  837.              for (i = 0, len = ss2.length; i < len; i++) {
  838.                  console.log('d的值是 = ' + ss2[i]);
  839.              }
  840.              console.log('---------------parsed--------------');
  841.  
  842.              c.reInit();
  843.              var readxmlExpr3 = Parser.parse('root/a/b/c');
  844.              var ss3 = readxmlExpr3.interpret(c);
  845.              console.log('------------parsing--------------');
  846.              console.log('c的name属性值是 = ' + ss3);
  847.              console.log('---------------parsed--------------');
  848.  
  849.              c.reInit();
  850.              var readxmlExpr4 = Parser.parse('root/a/b/c.name');
  851.              var ss4 = readxmlExpr4.interpret(c);
  852.              console.log('------------parseing--------------');
  853.              console.log('c的name属性值是 = ' + ss4);
  854.              console.log('---------------parsed--------------');
  855.          }();
  856.  
  857.          // 这样就实现了类似XPath的部分功能
  858.          // 没错，就类似于jQuery选择器的部分功能
  859.      }());
  860.  
  861.      /**
  862.       * 1.功能
  863.       * 解释器模式使用解释器对象来表示和处理相应的语法规则，一般一个解释器处理一条语法规则。理论上来说，只要能用解释器对象把符合语法的表达式表示出来，而且能够构成抽象的语法树，就可以使用解释器模式来处理。
  864.       *
  865.       * 2.语法规则和解释器
  866.       * 语法规则和解释器之间是有对应关系的，一般一个解释器处理一条语法规则，但是反过来并不成立，一条语法规则是可以有多种解释和处理的，也就是一条语法规则可以对应多个解释器。
  867.       *
  868.       * 3.上下文的公用性
  869.       * 上下文在解释器模式中起着非常重要的作用。由于上下文会被传递到所有的解释器中。因此可以在上下文中存储和访问解释器的状态，比如，前面的解释器可以存储一些数据在上下文中，后面的解释器就可以获取这些值。
  870.       * 另外还可以通过上下文传递一些在解释器外部，但是解释器需要的数据，也可以是一些全局的，公共的数据。
  871.       * 上下文还有一个功能，就是可以提供所有解释器对象的公共功能，类似于对象组合，而不是使用继承来获取公共功能，在每个解释器对象中都可以调用
  872.       *
  873.       * 4.谁来构建抽象语法树
  874.       * 在前面的示例中，是自己在客户端手工构建抽象语法树，是很麻烦的，但是在解释器模式中，并没有涉及这部分功能，只是负责对构建好的抽象语法树进行解释处理。后面会介绍可以提供解析器来实现把表达式转换成为抽象语法树。
  875.       * 还有一个问题，就是一条语法规则是可以对应多个解释器对象的，也就是说同一个元素，是可以转换成多个解释器对象的，这也就意味着同样一个表达式，是可以构成不用的抽象语法树的，这也造成构建抽象语法树变得很困难，而且工作量非常大。
  876.       *
  877.       * 5.谁负责解释操作
  878.       * 只要定义好了抽象语法树，肯定是解释器来负责解释执行。虽然有不同的语法规则，但是解释器不负责选择究竟用哪个解释器对象来解释执行语法规则，选择解释器的功能在构建抽象语法树的时候就完成了。
  879.       *
  880.       * 6.解释器模式的调用顺序
  881.       * 1)创建上下文对象
  882.       * 2）创建多个解释器对象，组合抽象语法树
  883.       * 3）调用解释器对象的解释操作
  884.       * 3.1)通过上下文来存储和访问解释器的状态。
  885.       * 对于非终结符解释器对象，递归调用它所包含的字解释器对象。
  886.       *
  887.       * 相关模式
  888.       *
  889.       * 解释器模式和组合模式
  890.       * 这两个模式可以组合使用。
  891.       * 通常解释器模式都会使用组合模式来实现，这样能够方便地构建抽象语法树，一般非终结符解释器就相当于组合模式中的组合对象；终结符解释器就相当于叶子对象。
  892.       *
  893.       * 解释器模式和迭代器模式
  894.       * 这两个模式可以组合使用。
  895.       * 由于解释器模式通常使用组合模式来实现，因此在遍历整个对象结构的时候，自然可以使用迭代器模式。
  896.       *
  897.       * 解释器和享元模式
  898.       * 这两个模式可以组合使用。
  899.       * 在使用解释器模式的时候，可能会造成多个细粒度对象，比如，会有各种各样的终结符解释器，而这些终结符解释器对不同的表达式来说是一样的，是可以共用的，因此可以引入享元模式来共享这些对象。
  900.       *
  901.       * 解释器模式和访问者模式
  902.       * 这两个模式可以组合使用。
  903.       * 在解释器模式中，语法规则和解释器对象是有对应关系的。语法规则的变动意味着功能的变化，自然会导致使用不用的解释器对象；而且一个语法规则可以被不同的解释器解释执行。
  904.       * 因此在构建抽象语法树的时候，如果每个节点所对应的解释器对象是固定的，这就意味着该节点对应的功能是固定的，那么就不得不根据需要来构建不用抽象语法树，
  905.       * 为了让构建的抽象语法树较为通用，那就要求解释器的功能不要那么固定，要能很方便的改变解释器的功能，这个时候问题就变成了如何能够很方便地更改树形结构中节点对象的功能了，访问者模式可以很好的实现这个功能。
  906.       */
  907.  }());
  908.  
  909.  (function () {
  910.      // http://blog.csdn.net/dead_of_winter/article/details/2158492
  911.  
  912.      /**
  913.       * 解释器模式在js中有两个最典型的应用json和正则表达式，对js程序员来说，这应该是很熟悉的两种东西。json用于序列化对象型数据，这个js的对象文字量形式在包括C++，Java在内的各种语言中都有实现的类库，在一些ajax应用中，java或者C#中的对象被序列化为json格式，通过相应客户端的http请求传递给客户端的js程序，js几乎不需要任何处理，仅仅使用eval就可以把json格式的数据还原成js对象（因为json恰巧是来自js），这在解释器模式的实现中是很少见的。现在，不仅仅使与js相关的应用，即使在其他语言的应用中，json也是一种很受欢迎的数据交换格式。正则表达式是js的内置对象，它可以说是最著名的解释器模式了，几乎所有语言中都有它的实现，现在它已经几乎是字符串匹配的事实标准。它能处理字符串的各种格式，有效地避免了过于复杂的string对象接口或者大段的字符串分析代码，这对开发效率至关重要。js的实现是一个比较强的版本，相比java和C#等语言，js允许函数参数为它提供了更大的灵活性。
  914.       *
  915.       *
  916.       * 词法分析·状态机的实现
  917.       *
  918.       * 通常解释器模式需要将所定义的"语言"字符流转换成适合的程序数据结构，再对这个结构进行分析。对于比较简单的情况，转换和分析可以在一步完成。为了很好好的完成这项工作，我们需要实现一个状态机。
  919.       * 状态机原本不是软件和程序中的术语，在数字逻辑中有限状态机是指输出取决于过去输入部分和当前输入部分的时序逻辑电路。这里甚至无需强调有限状态机，可以简单理解状态机为一个黑箱子，向其中投入指令后即可进行操作和装换状态，它有一个最终状态，当到达最终状态时，即可完成任务。
  920.       * 词法分析有限状态机任务很简单，从输入字符流中读入一个一个的字符，当辨认出输入的字符能构成一个独立的语法单元（token）时，便将这个token放入待分析的词句流中。
  921.       * 这里给出一个简单的例子：正斜杠转义的实现。通常字符串转义都是以反斜杠/实现的，假如有一个字符串，现在我们要把正斜杠用作转义符以做一些特殊用途，其他字符原样放置。那么正斜杠/和它后面的字符必须被看成一个整体，其它每个字符都是一个整体。
  922.       * 这个状态机只有两个状态 第一个状态是读入普通字符状态 第二个状态是读入正斜杠以后的状态
  923.       */
  924.  
  925.          // 在js中 充分利用语言特性 将每个状态实现为一个函数 它接受一个状态改变参数 然后返回下一个状态
  926.          // 这是一个标准的状态机处理词法分析的例子，事实上，有些简单的解释器模式，仅仅通过词法分析即可实现，功能可以写在状态改变函数中，而无需对产生的token流进行处理。
  927.  
  928.      function state_machine() {
  929.          this.state = _1;
  930.          this.result = [];
  931.          function _1(c) {
  932.              if (c != '/') {
  933.                  this.result.push(c);
  934.                  return _1;
  935.              } else {
  936.                  return _2;
  937.              }
  938.          }
  939.  
  940.          function _2(c) {
  941.              this.result.push('/' + c);
  942.              return _1;
  943.          }
  944.  
  945.          this.change = function (c) {
  946.              this.state = this.state(c);
  947.          };
  948.      }
  949.  
  950.      var sm = new state_machine();
  951.      var queue = ("a//sd/jh/ds").split('');
  952.  
  953.      for (var i = 0; i < queue.length; i++)
  954.          sm.change(queue[i]);
  955.  
  956.      console.log(sm.result);
  957.  
  958.      /**
  959.       * 函数式语言特性与状态机
  960.       *
  961.       * 作为函数式语言，js实现解释器模式有非常有趣的方式：以不定个数的参数形式传入函数进行处理，这样可以方便的扩展功能，同时可以使用户更自由的使用解释器提供的接口。
  962.       * 下面一段代码是一个用于日期对象的格式化的类 它是状态机词法分析的一个稍微复杂的例子，同时它以函数参数的方式为用户提供了扩展功能。
  963.       */
  964.  
  965.      /*
  966.      DateEx类
  967.      说明：以参数形式继承自Date对象 为Date对象扩展方法
  968.      方法：
  969.          format(formatString,[fun],......)
  970.          参数：
  971.              formatString：格式字符串 将日期转换成所规定的格式字符串
  972.                  格式说明：
  973.                      %[x]：
  974.                          [x]代表日期的一个部分
  975.                      %y:年
  976.                      %m:月
  977.                      %d:日
  978.                      %w:星期
  979.                      %h:小时
  980.                      %i:分
  981.                      %s:秒
  982.  
  983.                      %[num][x]：
  984.                          [num]代表长度 [x]意义同上 如果长度不足则用0补齐 如果长度超出[num]则将高位截断
  985.  
  986.                      %f[x]：
  987.                          以自定义函数处理%[x]得到的值，自定义函数在参数列表[fun]中给出，参数中[fun]的个数应与%f[x]的数目一致
  988.  
  989.              fun：可选的，处理函数，当格式字符串中有格式符%f出现时，则在fun中取相应的函数处理
  990.      */
  991.      function DateEx(date) {
  992.          date = date || new Date();
  993.          date.format = function (formatString) {
  994.              var f;
  995.              var j = 0;
  996.  
  997.              function fbuilder(n) {
  998.                  return function (v) {
  999.                      var s = v.toString();
  1000.                      if (s.length >= n) return s.slice(s.length - n, s.length);
  1001.                      if (s.length < n) return new Array(n - s.length + 1).join(0) + s;
  1002.                  };
  1003.              }
  1004.  
  1005.              var args = arguments;
  1006.              var resault = new String();
  1007.              var _1 = function (c)//状态1 是读入格式字符串的状态
  1008.              {
  1009.                  if (c != "%")//对于非%字符按原样输出
  1010.                  {
  1011.                      resault += c;
  1012.                      return _1;
  1013.                  }
  1014.                  else//读到%时进入状态2 否则延续状态1
  1015.                  {
  1016.                      return _2;
  1017.                  }
  1018.              };
  1019.              var _2 = function (c)//状态2 是读入特殊格式字符串的状态
  1020.              {
  1021.                  if (c.match(/d/) != null)//对于数字 构造相应处理函数 返回状态3
  1022.                  {
  1023.                      f = fbuilder(Number(c));
  1024.                      return _3;
  1025.                  }
  1026.                  else if (c == "f")//对于格式符f 从参数中获取相应处理函数 返回状态3
  1027.                  {
  1028.                      f = args[++j];
  1029.                      return _3;
  1030.                  }
  1031.                  else//没有特殊格式符 直接进入状态3
  1032.                  {
  1033.                      f = function (v) {return v;}
  1034.                      return _3(c);
  1035.                  }
  1036.  
  1037.              };
  1038.              var _3 = function (c) {
  1039.                  if (c == "%")//格式符% 连续2个%将被转义为一个% 返回状态1
  1040.                  {
  1041.                      resault += c;
  1042.                      return _1;
  1043.                  }
  1044.                  else if (c == "y")//格式符y 取出年份 返回状态1
  1045.                  {
  1046.                      resault += f(date.getFullYear());
  1047.  
  1048.                      return _1;
  1049.                  }
  1050.                  else if (c == "m")//格式符m 取出月份 返回状态1
  1051.                  {
  1052.                      resault += f(date.getMonth() + 1);
  1053.                      return _1;
  1054.                  }
  1055.                  else if (c == "d")//格式符d 取出日期 返回状态1
  1056.                  {
  1057.                      resault += f(date.getDate());
  1058.                      return _1;
  1059.                  }
  1060.                  else if (c == "w")//格式符w 取出星期 返回状态1
  1061.                  {
  1062.                      resault += f(date.getDay());
  1063.                      return _1;
  1064.                  }
  1065.                  else if (c == "h")//格式符h 取出小时 返回状态1
  1066.                  {
  1067.                      resault += f(date.getHours());
  1068.                      return _1;
  1069.                  }
  1070.                  else if (c == "i")//格式符i 取出分 返回状态1
  1071.                  {
  1072.                      resault += f(date.getMinutes());
  1073.                      return _1;
  1074.                  }
  1075.                  else if (c == "s")//格式符s 取出秒 返回状态1
  1076.                  {
  1077.                      resault += f(date.getSeconds());
  1078.                      return _1;
  1079.                  }
  1080.                  else return _1//没有合法格式符 忽略 返回状态1
  1081.              };
  1082.              var status = _1;
  1083.              for (var i = 0; i < formatString.length; i++) {
  1084.                  status = status(formatString.charAt(i));
  1085.              }
  1086.              return resault;
  1087.          }
  1088.          return date;
  1089.      }
  1090.  
  1091.      var weekdays = "日一二三四五六";
  1092.      console.log(new DateEx().format("%2y-%2m-%2d 星期%fw %2h:%2i:%2s %%", function (v) {return weekdays.charAt(v);}))
  1093.  
  1094.      /**
  1095.       * 动态语言特性·eval与解释器模式
  1096.       *
  1097.       * js的另一个非常有趣特点是它本身是一门解释型语言，它允许用eval和Function等方式调用其本身的解释器引擎，这样给解释器的实现带来了很大的方便，可以将某段自定义语言（如代数运算或者布尔运算不分）作为一个独立的token用eval直接执行，这种形式的解释器是静态语言无法比拟的
  1098.       */
  1099.  }());
  1100.  
  1101.  (function () {
  1102.      // http://www.dofactory.com/javascript-interpreter-pattern.aspx
  1103.  
  1104.      // 将罗马数字表达式转换为阿拉伯数字
  1105.  
  1106.      var Context = function (input) {
  1107.          this.input = input;
  1108.          this.output = 0;
  1109.      };
  1110.  
  1111.      Context.prototype = {
  1112.          startsWith: function (str) {
  1113.              return this.input.substr(0, str.length) === str;
  1114.          }
  1115.      };
  1116.  
  1117.      var Expression = function (name, one, four, five, nine, multiplier) {
  1118.          this.name = name;
  1119.          this.one = one;
  1120.          this.four = four;
  1121.          this.five = five;
  1122.          this.nine = nine;
  1123.          this.multiplier = multiplier;
  1124.      };
  1125.  
  1126.      Expression.prototype = {
  1127.          interpret: function (context) {
  1128.              if (context.input.length == 0) {
  1129.                  return;
  1130.              }
  1131.              else if (context.startsWith(this.nine)) {
  1132.                  context.output += (9 * this.multiplier);
  1133.                  context.input = context.input.substr(2);
  1134.              }
  1135.              else if (context.startsWith(this.four)) {
  1136.                  context.output += (4 * this.multiplier);
  1137.                  context.input = context.input.substr(2);
  1138.              }
  1139.              else if (context.startsWith(this.five)) {
  1140.                  context.output += (5 * this.multiplier);
  1141.                  context.input = context.input.substr(1);
  1142.              }
  1143.  
  1144.              while (context.startsWith(this.one)) {
  1145.                  context.output += (1 * this.multiplier);
  1146.                  context.input = context.input.substr(1);
  1147.              }
  1148.          }
  1149.      };
  1150.  
  1151.      void function run() {
  1152.  
  1153.          var roman = "MCMXXVIII"
  1154.          var context = new Context(roman);
  1155.          var tree = [];
  1156.  
  1157.          tree.push(new Expression("thousand", "M", " ", " ", " ", 1000));
  1158.          tree.push(new Expression("hundred", "C", "CD", "D", "CM", 100));
  1159.          tree.push(new Expression("ten", "X", "XL", "L", "XC", 10));
  1160.          tree.push(new Expression("one", "I", "IV", "V", "IX", 1));
  1161.  
  1162.          for (var i = 0, len = tree.length; i < len; i++) {
  1163.              tree[i].interpret(context);
  1164.          }
  1165.  
  1166.          console.log(roman + " = " + context.output);
  1167.      }();
  1168.  }());
  1169.  
  1170.  </script>
  1171.  </body>
  1172.  </html>

javascript设计模式 - 解释器模式(interpreter)的更多相关文章

  1. 大话设计模式--解释器模式 interpreter -- C++实现实例

    1. 解释器模式: 给定一个语言,定义它的文法的一种表示 并 定义一个解释器,这个解释器使用该表示文法 来解释语言中的句子. 如果一种特定类型的问题发生的频率很高,那么可能就值得将该问题的各个实例表述 ...

  2. C#设计模式——解释器模式(Interpreter Pattern)

    一.概述 在软件开发特别是DSL开发中常常需要使用一些相对较复杂的业务语言,如果业务语言使用频率足够高,且使用普通的编程模式来实现会导致非常复杂的变化,那么就可以考虑使用解释器模式构建一个解释器对复杂 ...

  3. 设计模式:解释器模式(Interpreter)

    为人处事是一门大学问,察言观色.听懂弦外之音都是非常重要的,老板跟你说“XX你最近表现平平啊,还得要多努力”,如果你不当回事,平常对待,可能下次就是“XX,恩,你人还是不错,平常工作也很努力,但是我想 ...

  4. 深入浅出设计模式——解释器模式（Interpreter Pattern）

    模式动机 如果在系统中某一特定类型的问题发生的频率很高,此时可以考虑将这些问题的实例表述为一个语言中的句子,因此可以构建一个解释器,该解释器通过解释这些句子来解决这些问题.解释器模式描述了如何构成一个 ...

  5. 乐在其中设计模式(C#) - 解释器模式(Interpreter Pattern)

    原文:乐在其中设计模式(C#) - 解释器模式(Interpreter Pattern) [索引页][源码下载] 乐在其中设计模式(C#) - 解释器模式(Interpreter Pattern) 作 ...

  6. 解释器模式 Interpreter 行为型 设计模式（十九）

      解释器模式(Interpreter)   考虑上图中计算器的例子 设计可以用于计算加减运算(简单起见,省略乘除),你会怎么做?    你可能会定义一个工具类,工具类中有N多静态方法 比如定义了两个 ...

  7. C#设计模式：解释器模式(Interpreter Pattern)

    一,C#设计模式:解释器模式(Interpreter Pattern) 1,解释器模式的应用场合是Interpreter模式应用中的难点,只有满足“业务规则频繁变化,且类似的模式不断重复出现,并且容易 ...

  8. 二十四种设计模式：解释器模式(Interpreter Pattern)

    解释器模式(Interpreter Pattern) 介绍给定一个语言, 定义它的文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子. 示例有一个Message实体类,某个类对它的 ...

  9. JAVA 设计模式 解释器模式

    用途 解释器模式 (Interpreter) 定义一个语言,定义它的文法的一种表示. 并定义一个解释器,这个解释器使用该表示来解释语言中的句子. 解释器模式是一种行为型模式. 结构

随机推荐

  1. （转）使用 python Matplotlib 库绘图

    运行一个简单的程序例子: import matplotlib.pyplot as plt plt.plot([1,2,3]) plt.ylabel('some numbers') plt.show() ...

  2. 【BZOJ4709】[Jsoi2011]柠檬 斜率优化+单调栈

    [BZOJ4709][Jsoi2011]柠檬 Description Flute 很喜欢柠檬.它准备了一串用树枝串起来的贝壳,打算用一种魔法把贝壳变成柠檬.贝壳一共有 N (1 ≤ N ≤ 100,0 ...

  3. 【BZOJ4712】洪水 树链剖分优化DP+线段树

    [BZOJ4712]洪水 Description 小A走到一个山脚下,准备给自己造一个小屋.这时候,小A的朋友(op,又叫管理员)打开了创造模式,然后飞到山顶放了格水.于是小A面前出现了一个瀑布.作为 ...

  4. Java基础语法 - 面向对象 - static 关键字

    使用static关键字修饰的变量.常量和方法分别被称作静态变量.静态常量和静态方法,也被称作类的静态成员 静态变量 使用static修饰过的类变量称为静态变量 该变量需要使用类名.变量名进行调用,不能 ...

  5. numpy.random.random & numpy.ndarray.astype & numpy.arange

    今天看到这样一句代码: xb = np.random.random((nb, d)).astype('float32') #创建一个二维随机数矩阵(nb行d列) xb[:, 0] += np.aran ...

  6. celery中的生产者消费者问题

    celery中的生产者消费者问题 在task1.py文件中: # demo1:task.py and celery.py in one file# run it byfrom celery impor ...

  7. 阿里巴巴 JAVA 开发手册

    阿里巴巴 JAVA 开发手册 1.0.0 阿里巴巴集团技术部 2016.12.7 首次向 Java 业界公开 一. 编程规约(一) 命名规约1. [强制]所有编程相关命名均不能以下划线或美元符号开始, ...

  8. ios开发之手势动作状态细分state，同一视图加入两个手势

    1.比方拖拽一个视图.形成类似scrollView的翻页形式 在拖拽的方法里推断拖拽的状态state属性,依据状态不同运行自己须要的效果. 2.同一视图加入两个手势,须要使用手势的代理方法.同意此操作 ...

  9. Linux学习笔记（11）linux网络管理与配置之一——配置路由与默认网关，双网卡绑定（5-6）

    Linux学习笔记(11)linux网络管理与配置之一——配置路由与默认网关,双网卡绑定(5-6) 大纲目录 0.常用linux基础网络命令 1.配置主机名 2.配置网卡信息与IP地址 3.配置DNS ...

  10. Windows下QT MySQL驱动编译

    在Windows环境中使用Qt进行关于MySQL数据库的操作时,会出现如下问题: QSqlDatabase: QMYSQL driver not loaded QSqlDatabase: availa ...