这次的代码逻辑很复杂，用了大量的递归，自己写完了也有一种侥幸的感觉，所以抽空还是要重新回头看看这段代码
抽象语法树构建的时候，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;
}
然后是进入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树已经生成了想要的样子了：
接下来要编译这个树。
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;
}
}
生成的函数也可以了：
测试案例当然也通过了。
解析一个厉害的数组
解析空数组完成了以后大概流程也就疏通了。
现在要解析一个牛逼的数组：
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;
}
}
