这次的代码逻辑很复杂，用了大量的递归，自己写完了也有一种侥幸的感觉，所以抽空还是要重新回头看看这段代码

抽象语法树构建的时候，tokens其实是一个队列，先进先出，从前往后一个个消化，解析完了就没了。不像词法分析的时候一样，词法分析的是有一个游标的，构建树是没有的。

先从解析一个空数组开始

it('编译空数组',function() {
    var fn=parse('[]');
    expect(fn()).toEqual([]);
  })

这时候lexer分析出来是两个token：'['和']'。

Lexer.prototype.lex=function(expression){
  this.tokens=[];
  this.text = expression;
  this.index = 0;
  while (this.index<this.text.length) {
    var currentChar = this.text.charAt(this.index);
    if(this.isNumber(currentChar)){
      this.readNumber();
    }else if (currentChar==="'"||currentChar==="\"") {
      this.readString(currentChar);
    }else if (this.isIdent(currentChar)) {
      this.readIdent()
    }else if (currentChar==="["||currentChar==="]") {//新加的部分
      this.tokens.push({
        text:currentChar  //这个token也是没有值的
      })
    } else{
      throw "现在只支持数字，不支持别的字符"
    }
  }
  return this.tokens;
}

拿到了两个token

然后是进入AST步骤，在primary方法里，判断一下第一个token是不是[，如果是的话，就要生成一个数组节点。
先写一个判断第一个token的方法：

ASTBuilder.prototype.expect=function(tokenText){
  if(this.tokens[0].text===tokenText||!tokenText){
    return this.tokens.shift();
  }else{
    return false;
  }
}

在定义一个生成数组节点的方法：

ASTBuilder.prototype.arrayDeclaration=function(){
  //返回一个数组节点
}

现在可以改造一下primary方法：

if (this.expect('[')) {
    return this.arrayDeclaration();//如果第一个token是[，则产生一个数组节点
  }else if(ASTBuilder.constants.hasOwnProperty(this.tokens[0].text)){
    return {type:ASTBuilder.Literal,value:ASTBuilder.constants[this.tokens[0].text]}
  }else{
    return this.constant();
  }

数组节点的产生方法目前是空的，现在补全：

ASTBuilder.prototype.arrayDeclaration=function(){
  //返回一个数组节点
  this.consume(']');
  return {type:ASTBuilder.ArrayExpression}
}

这个consume方法和expect方法类似，因为之前except已经把[这个token给使用了，所以产生数组的时候要把]这个token也给消化掉。

ASTBuilder.prototype.consume=function(tokenText){
  var token = this.expect(tokenText);
  if(!token){
    throw "没有相应的token："+tokenText;
  }
  return token;
}

现在AST树已经生成了想要的样子了：

image.png

接下来要编译这个树。

Compiler.prototype.recurse=function(ast){
  switch (ast.type) {
    case ASTBuilder.Program:
      this.state.body.push('return ',this.recurse(ast.body),' ;');
      break;
    case ASTBuilder.Literal:
      return this.escape(ast.value);
      break;
    case ASTBuilder.ArrayExpression:
      return '[]'//现在是编译简单的空数组，直接写死，一会再修改
      break;
  }
}

生成的函数也可以了：

image.png

测试案例当然也通过了。

解析一个厉害的数组

解析空数组完成了以后大概流程也就疏通了。
现在要解析一个牛逼的数组：

it('编译牛逼的数组',function(){
      var fn=parse("[123,'true','hello']");
      expect(fn()).toEqual([]);
  })

这个数组里啥都有。想想怎么搞。首先是能想到，Lexer在词法分析的时候遇到逗号是不支持的。解决一下：

}else if (currentChar==="["||currentChar==="]"||currentChar===",") {
      this.tokens.push({
        text:currentChar
      })
      this.index++;
    } 

现在可以解析到7个token，生成语法树的时候怎么办？在array类型的节点里，有一个属性是elements，包括着数组元素。
在arrayDeclatration方法里面做完善：如果遇到[，但是下一个不是]，那么就不断的把token转换成节点，推入一个数组中，直到遇到]，然后把这个数组添加到arry节点的elements属性上。
这时候要写一个peek方法，这个方法就是用来看看下一个token是什么。

ASTBuilder.prototype.peek=function(tokenText){
  if(this.tokens.length>0){
      if(this.tokens[0].text===tokenText||!tokenText){
        return this.tokens[0];
      }
  }
}

接下来就是arrayDeclatration方法：

ASTBuilder.prototype.arrayDeclaration=function(){
  var elements=[];
  if(!this.peek(']')){
    do{
      elements.push(this.primary());
    }while(this.expect(','))
  }
  this.consume(']');
  return {type:ASTBuilder.ArrayExpression,elements:elements}
}

但是现在是一个死循环，因为tokens队列中的token一直没消化掉。
之后再做一下处理：

ASTBuilder.prototype.primary=function(){
  if (this.expect('[')) {
    return this.arrayDeclaration();
  }else if(ASTBuilder.constants.hasOwnProperty(this.tokens[0].text)){
    return {type:ASTBuilder.Literal,value:this.consume().text]}
  }else{
    return this.constant();
  }
}

ASTBuilder.prototype.constant = function () {
  return {
    type:ASTBuilder.Literal,
    value:this.consume().value
  }
};

现在试试跑起来怎么样：

确实拿到了一个数组节点，包括三个元素

接下来就是要进入compile阶段了。
在递归方法中，如果遇到数组节点，就要遍历这个节点的elements属性，把所有内容都变成一个字符串：

Compiler.prototype.recurse=function(ast){
  switch (ast.type) {
    case ASTBuilder.Program:
      this.state.body.push('return ',this.recurse(ast.body),' ;');
      break;
    case ASTBuilder.Literal:
      return this.escape(ast.value);
      break;
    case ASTBuilder.ArrayExpression:
      var elements=[];
      for(var i=0;i<ast.elements.length;i++){
        elements.push(this.recurse(ast.elements[i]));
      }
      return '['+elements.join(',')+']';
      break;
  }
}

编译成功