压缩html源文件,js代码压缩还原详解
//优化AST树，使生成的代码尽可能短
//@raphealguo
//官网记录了优化的内容，但是不一定在squeeze_1里边做的，这里只是列出来方便比对，
//这里分别用序号标明各个规则，在下边源码注释中会使用规则X的字眼来引用。
/*
1. foo[“bar”] ==> foo.bar
2. remove block brackets {}
3. join consecutive var declarations: var a = 10; var b = 20; ==> var a=10,b=20;
4. resolve simple constant expressions: 1 +2 * 3 ==> 7. We only do the replacement if the result occupies less bytes; for example 1/3 would translate to 0.333333333333, so in this case we don’t replace it.
5. consecutive statements in blocks are merged into a sequence; in many cases, this leaves blocks with a single statement, so then we can remove the block brackets.
6. various optimizations for IF statements:
7. if (foo) bar(); else baz(); ==> foo?bar():baz();
8. if (!foo) bar(); else baz(); ==> foo?baz():bar();
9. if (foo) bar(); ==> foo&&bar();
10. if (!foo) bar(); ==> foo||bar();
11. if (foo) return bar(); else return baz(); ==> return foo?bar():baz();
12. if (foo) return bar(); else something(); ==> {if(foo)return bar();something()}
13. remove some unreachable code and warn about it (code that follows a return, throw, break or continue statement, except function/variable declarations).
14. act a limited version of a pre-processor (c.f. the pre-processor of C/C++) to allow you to safely replace selected global symbols with specified values. When combined with the optimisations above this can make UglifyJS operate slightly more like a compilation process, in that when certain symbols are replaced by constant values, entire code blocks may be optimised away as unreachable.
*/
varwarn= function(){};
//比较ast1跟ast2两棵树 最后生成的代码谁比较短，谁短用谁
functionbest_of(ast1,ast2) {
returngen_code(ast1).length>gen_code(ast2[0] == "stat" ?ast2[1] :ast2).length?ast2:ast1;
};
//当前块里边的最后一条语句
functionlast_stat(b) {
if (b[0] == "block" &&b[1] &&b[1].length> 0)
returnb[1][b[1].length- 1];
returnb;
}
functionaborts(t) {
if (t) switch (last_stat(t)[0]) {
case "return":
case "break":
case "continue":
case "throw":
return true;
}
};
//看看表达式运算结果是否为布尔类型
functionboolean_expr(expr) {
return ( (expr[0] == "unary-prefix"
&&member(expr[1], [ "!", "delete" ])) ||
(expr[0] == "binary"
&&member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "=", ">" ])) ||
(expr[0] == "binary"
&&member(expr[1], [ "&&", "||" ])
&&boolean_expr(expr[2])
&&boolean_expr(expr[3])) ||
//三元运算符
(expr[0] == "conditional"
&&boolean_expr(expr[2])
&&boolean_expr(expr[3])) ||
//赋值语句
(expr[0] == "assign"
&&expr[1] === true
&&boolean_expr(expr[3])) ||
//逗号表达式
(expr[0] == "seq"
&&boolean_expr(expr[expr.length- 1]))
);
};
//看看树枝是不是空树枝
functionempty(b) {
return !b|| (b[0] == "block" && (!b[1] ||b[1].length== 0));
};
//看看当前AST节点是不是string类型
functionis_string(node) {
return (node[0] == "string" ||
//typeof得到结果也是字符串node[0] == "unary-prefix" &&node[1] == "typeof" ||
//字符串a+字符串b得到字符串node[0] == "binary" &&node[1] == "+" &&
(is_string(node[2]) ||is_string(node[3])));
};
//尝试将表达式节点化简
varwhen_constant= (function(){
var$NOT_CONSTANT= {};
// this can only evaluate constant expressions. If it finds anything
// not constant, it throws $NOT_CONSTANT.
//尽可能的把表达式化成计算结果
//a = 3*4 => a = 12;
//但是不一定这样优化会有效，例如：
//a = 1/3 => a = 0.33333可能会变得更长
functionevaluate(expr) {
switch (expr[0]) {
case "string":
case "num":
returnexpr[1];//单个数字跟字符串不用化简了
case "name":
case "atom":
switch (expr[1]) {//这里要对字符串转真正的Javascript值才能参与计算
case "true": return true;
case "false": return false;
case "null": return null;
}
break;
case "unary-prefix"://一元操作符
switch (expr[1]) {
case "!": return !evaluate(expr[2]);
case "typeof": return typeofevaluate(expr[2]);
case "~": return ~evaluate(expr[2]);
case "-": return -evaluate(expr[2]);
case "+": return +evaluate(expr[2]);
}
break;
case "binary"://二元操作符
varleft=expr[2],right=expr[3];
switch (expr[1]) {
case "&&" : returnevaluate(left) &&evaluate(right);
case "||" : returnevaluate(left) ||evaluate(right);
case "|" : returnevaluate(left) |evaluate(right);
case "&" : returnevaluate(left) &evaluate(right);
case "^" : returnevaluate(left) ^evaluate(right);
case "+" : returnevaluate(left) +evaluate(right);
case "*" : returnevaluate(left) *evaluate(right);
case "/" : returnevaluate(left) /evaluate(right);
case "%" : returnevaluate(left) %evaluate(right);
case "-" : returnevaluate(left) -evaluate(right);
case "<
case ">>" : returnevaluate(left) >>evaluate(right);
case ">>>" : returnevaluate(left) >>>evaluate(right);
case "==" : returnevaluate(left) ==evaluate(right);
case "===" : returnevaluate(left) ===evaluate(right);
case "!=" : returnevaluate(left) !=evaluate(right);
case "!==" : returnevaluate(left) !==evaluate(right);
case "
case "<=" : returnevaluate(left) <=evaluate(right);
case ">" : returnevaluate(left) >evaluate(right);
case ">=" : returnevaluate(left) >=evaluate(right);
case "in" : returnevaluate(left)in evaluate(right);
case "instanceof" : returnevaluate(left)instanceof evaluate(right);
}
}
//其他情况都抛出错误，告诉外界没法化简
throw$NOT_CONSTANT;
};
return function(expr,yes,no) {
try {
//参数将表达式expr化成val
varval=evaluate(expr),ast;
//如果能够成功 就到这里
switch (typeofval) {
//运算的结果只能是null|string|number|boolean
case "string":ast= [ "string",val]; break;
case "number":ast= [ "num",val]; break;
case "boolean":ast= [ "name", String(val) ]; break;//这里是因为计算后的结果可能是 true false 但是对于AST叶子来说 应该是一个name的节点才对
default:
if (val=== null) {ast= [ "atom", "null" ]; break; }
//没有认出的类型 抛出错误
throw new Error("Can't handle constant of type: " + (typeofval));
}
returnyes.call(expr,ast,val);
} catch(ex) {
if (ex===$NOT_CONSTANT) {//如果是真的化简失败
if (expr[0] == "binary"
&& (expr[1] == "===" ||expr[1] == "!==")
&& ((is_string(expr[2]) &&is_string(expr[3]))
|| (boolean_expr(expr[2]) &&boolean_expr(expr[3])))) {
//"a" === "b" "a" !== "b"
//true === true false !== true
//这两种都可以把
// === 变成 ==
// !== 变成 !=expr[1] =expr[1].substr(0, 2);
}
else if (no&&expr[0] == "binary"
&& (expr[1] == "||" ||expr[1] == "&&")) {
// the whole expression is not constant but the lval may be...
// || &&的短路操作
try {
//看看 expr[2] && expr[3] 跟 expr[2] && expr[3]
varlval=evaluate(expr[2]);//如果expr[2]能够化简！
//如果 expr[1] == "&&"
//那么expr就是expr[3] 否则还是说expr[2]expr= ((expr[1] == "&&" && (lval?expr[3] :lval)) ||
//如果 expr[1] == "||"
//如果 expr[2] == true
//那么expr就是expr[2] 否则是expr[3]
(expr[1] == "||" && (lval?lval:expr[3])) ||expr);
} catch(ex2) {
//不能化简第一个操作数 那就没办法了~
// IGNORE... lval is not constant
}
}
returnno?no.call(expr,expr) : null;
}
else throwex;
}
};
})();
functionwarn_unreachable(ast) {
if (!empty(ast))warn("Dropping unreachable code: " +gen_code(ast, true));
};
//预处理if树枝
/*
把
if (x) {
blah();
return y;
}
foobar();
变成：
if (x) {
blah();
return y;
} else {
foobar();
}
为什么？因为对于IF/ELSE的结构，在squeeze_1会有很多特殊的处理，这里把它强制转成带else分支可能在后续的压缩过程可以得到更好的优化
*/
functionprepare_ifs(ast) {
varw=ast_walker(),walk=w.walk;
//下边已经解释prepare_ifs要做的事情了
// In this first pass, we rewrite ifs which abort with no else with an
// if-else. For example:
//
// if (x) {
// blah();
// return y;
// }
// foobar();
//
// is rewritten into:
//
// if (x) {
// blah();
// return y;
// } else {
// foobar();
// }
functionredo_if(statements) {statements=MAP(statements,walk);
//扫描当前语句块里边的if树枝
//if的AST树枝是：["if", cond, body, belse]
for (vari= 0;i
varfi=statements[i];
if (fi[0] != "if") continue;
if (fi[3]) continue;//如果有else分支，那不用动
vart=fi[2];
/*
function aborts(t) {
if (t) switch (last_stat(t)[0]) {
case "return":
case "break":
case "continue":
case "throw":
return true;
}
};
*/
//看看语句块的最后一句是不是跳转出if
if (!aborts(t)) continue;
//为什么这里要walk呢？
//因为有可能 if((function(){if(xxx){xxx}})()) 在cond里边也可能有if语句
varconditional=walk(fi[1]);
//把后边的语句变成一个else的树枝
vare_body=redo_if(statements.slice(i+ 1));
//如果超过一行语句 需要生成一个block
vare=e_body.length== 1 ?e_body[0] : [ "block",e_body];
//返回优化后的AST树
returnstatements.slice(0,i).concat([ [fi[0], // "if"conditional, // conditionalt, // then 为什么t不用walk? @unkownede// else
] ]);
}
returnstatements;
};
functionredo_if_lambda(name,args,body) {body=redo_if(body);
return [ this[0],name,args,body];
};
functionredo_if_block(statements) {
return [ this[0],statements!= null ?redo_if(statements) : null ];
};
returnw.with_walkers({
"defun":redo_if_lambda,
"function":redo_if_lambda,
"block":redo_if_block,
"splice":redo_if_block,
"toplevel": function(statements) {
return [ this[0],redo_if(statements) ];
},
"try": function(t,c,f) {
return [
this[0],redo_if(t),c!= null ? [c[0],redo_if(c[1]) ] : null,f!= null ?redo_if(f) : null
];
}
}, function() {
returnwalk(ast);
});
}
//优化AST树！使得生成的代码最小化
functionsqueeze_1(ast,options) {
//覆盖默认参数options=defaults(options, {make_seqs: true,dead_code: true,no_warnings: false,keep_comps: true,unsafe: false
});
//拿到遍历器
varw=ast_walker(),walk=w.walk,scope;
//对表达式取非
functionnegate(c) {
//得到一个非的表达式
varnot_c= [ "unary-prefix", "!",c];
switch (c[0]) {
case "unary-prefix":
//!c的非就是c
returnc[1] == "!" &&boolean_expr(c[2]) ?c[2] :not_c;
case "seq":
//a,b,!c的非就是：a,b,cc=slice(c);c[c.length- 1] =negate(c[c.length- 1]);
returnc;
case "conditional":
//a ? b : c的非就是 a ? !b : !c;
returnbest_of(not_c, [ "conditional",c[1],negate(c[2]),negate(c[3]) ]);
case "binary":
//二元操作符的非
varop=c[1],left=c[2],right=c[3];
if (!options.keep_comps) switch (op) {
case "<=" : return [ "binary", ">",left,right];
case "=",left,right];
case ">=" : return [ "binary", "
case ">" : return [ "binary", "<=",left,right];
}
switch (op) {
case "==" : return [ "binary", "!=",left,right];
case "!=" : return [ "binary", "==",left,right];
case "===" : return [ "binary", "!==",left,right];
case "!==" : return [ "binary", "===",left,right];
//a && b 非就是 !a || !b
//a || b 的非就是 a && b
case "&&" : returnbest_of(not_c, [ "binary", "||",negate(left),negate(right) ]);
case "||" : returnbest_of(not_c, [ "binary", "&&",negate(left),negate(right) ]);
}
break;
}
//其他情况直接前边加!
returnnot_c;
};
//条件最短化
//c ? t : e
//if (c) {t} else {e}
functionmake_conditional(c,t,e) {
varmake_real_conditional= function() {
if (c[0] == "unary-prefix" &&c[1] == "!") {
//如果c前边有个!
//例如：if (!c) { A() } else{ B() } 化简成： c ? B() : A();
//例如：if (!c) { A() } else{ } 化简成： c || A();
returne? [ "conditional",c[2],e,t] : [ "binary", "||",c[2],t];
} else {
//例如：if (c) { A() } else{ B() } 化简成： c ? A() : B(); 或者 !c ? B() : A()
//例如：if (c) { A() } else{ } 化简成： c && A();
returne?best_of(
[ "conditional",c,t,e],
[ "conditional",negate(c),e,t]
) : [ "binary", "&&",c,t];
}
};
// shortcut the conditional if the expression has a constant value
returnwhen_constant(c, function(ast,val){warn_unreachable(val?e:t);
return (val?t:e);
},make_real_conditional);
};
//移除语句块
//只有语句块里边是1条/0条语句的时候才能移除
//while(true){ { a(); } }可以化简成为 while(true){ a(); }
//while(true){ { } }可以化简成为 while(true){ }
functionrmblock(block) {
if (block!= null &&block[0] == "block" &&block[1]) {
if (block[1].length== 1)block=block[1][0];
else if (block[1].length== 0)//返回一个空块block= [ "block" ];
}
returnblock;
};
function_lambda(name,args,body) {
return [ this[0],name,args,tighten(body, "lambda") ];
};
// this function does a few things:
// 1. discard useless blocks
// 2. join consecutive var declarations
// 3. remove obviously dead code
// 4. transform consecutive statements using the comma operator
// 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... }
//压缩语句块
functiontighten(statements,block_type) {statements=MAP(statements,walk);
//去除空白的blockstatements=statements.reduce(function(a,stat){
if (stat[0] == "block") {
if (stat[1]) {a.push.apply(a,stat[1]);
}
} else {a.push(stat);
}
returna;
}, []);statements= (function(a,prev){
//var a;var b;优化成 var a, b;statements.forEach(function(cur){
if (prev&& ((cur[0] == "var" &&prev[0] == "var") ||
(cur[0] == "const" &&prev[0] == "const"))) {prev[1] =prev[1].concat(cur[1]);
} else {a.push(cur);prev=cur;
}
});
returna;
})([]);
//--no-dead-code 默认 UglifyJS 将会删除不被用到的代码，传入该参数禁用此功能。
//dead_code 默认是true
/*
function A(){
var a;
return b;
//这之后的语句考虑忽略掉，但是要看看后边有没有函数声明跟变量声明
a = 1;
function B(){}
}
*/
if (options.dead_code)statements= (function(a,has_quit){statements.forEach(function(st){
if (has_quit) {
if (st[0] == "function" ||st[0] == "defun") {a.push(st);
}
else if (st[0] == "var" ||st[0] == "const") {
if (!options.no_warnings)warn("Variables declared in unreachable code");st[1] =MAP(st[1], function(def){
if (def[1] && !options.no_warnings)warn_unreachable([ "assign", true, [ "name",def[0] ],def[1] ]);
return [def[0] ];
});a.push(st);
}
else if (!options.no_warnings)warn_unreachable(st);
}
else {//当前作用域已经到了return语句了 那后边的可以考虑压缩忽略掉a.push(st);
if (member(st[0], [ "return", "throw", "break", "continue" ]))has_quit= true;
}
});
returna;
})([]);
//当调用 ast_squeeze() 将会合并多个语句块为一个语句块，如 "a=10; b=20; foo()" 将被转换为 "a=10,b=20,foo()"
//make_seqs默认为true
//命令参数"--no-seqs"可以让make_seqs = false
if (options.make_seqs)statements= (function(a,prev) {statements.forEach(function(cur){
//把连续的表达式语句合并成一个逗号表达式。
//stat;stat;stat; => stat,stat,stat;
if (prev&&prev[0] == "stat" &&cur[0] == "stat") {prev[1] = [ "seq",prev[1],cur[1] ];
} else {a.push(cur);prev=cur;
}
});
//块的最后一句是：
//
/*
stat;
return A;
可以优化成为
return stat, A;
*/
if (a.length>= 2
&&a[a.length-2][0] == "stat"
&& (a[a.length-1][0] == "return" ||a[a.length-1][0] == "throw")
&&a[a.length-1][1])
{a.splice(a.length- 2, 2,
[a[a.length-1][0],
[ "seq",a[a.length-2][1],a[a.length-1][1] ]]);
}
returna;
})([]);
// this increases jQuery by 1K. Probably not such a good idea after all..
// part of this is done in prepare_ifs anyway.
// if (block_type == "lambda") statements = (function(i, a, stat){
// while (i < statements.length) {
// stat = statements[i++];
// if (stat[0] == "if" && !stat[3]) {
// if (stat[2][0] == "return" && stat[2][1] == null) {
// a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ]));
// break;
// }
// var last = last_stat(stat[2]);
// if (last[0] == "return" && last[1] == null) {
// a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ]));
// break;
// }
// }
// a.push(stat);
// }
// return a;
// })(0, []);
returnstatements;
};
//对if进行优化
functionmake_if(c,t,e) {
//if (c) {t} else{e}
//尝试对c这个表达式化简~
returnwhen_constant(c, function(ast,val){
//如果c最后可以化简成表达式
//如果val == true || false之类的
//那就有可以去掉else或者then语句了
//@optimize
if (val) {
/*
if (true){
A();
}else{
B();
}
化简成：A();
*/t=walk(t);warn_unreachable(e);
returnt|| [ "block" ];
} else {
/*
if (false){
A();
}else{
B();
}
化简成：B();
*/e=walk(e);warn_unreachable(t);
returne|| [ "block" ];
}
}, function() {
//c没法化简 那就只能走make_real_if来压缩if树
returnmake_real_if(c,t,e);
});
};
//if (c) {t;} else { e; return ; }
//优化成 if (!c) { e;return; } t;
functionabort_else(c,t,e) {
varret= [ [ "if",negate(c),e] ];
if (t[0] == "block") {
if (t[1])ret=ret.concat(t[1]);
} else {ret.push(t);
}
returnwalk([ "block",ret]);
};
//压缩if树枝
functionmake_real_if(c,t,e) {
//if (c) { t } else {e}c=walk(c);t=walk(t);e=walk(e);
//if (cond()) {} else{}
//可以化简成 cond()
if (empty(e) &&empty(t))
return [ "stat",c];
if (empty(t)) {
//if (cond()) {} else{ B() }
//可以化简成 if (!cond()) { B() }c=negate(c);t=e;e= null;
} else if (empty(e)) {
//if (cond()) { A() } else{ }
//可以化简成 if (cond()) { A() }e= null;
} else {
// if we have both else and then, maybe it makes sense to switch them?
(function(){
vara=gen_code(c);
varn=negate(c);//对条件c求反
varb=gen_code(n);
//尝试把条件求反，如果得到的表达式更短
//那么反转if跟else块
if (b.length
vartmp=t;t=e;e=tmp;c=n;
}
})();
}
//按照目前得到的AST树枝是这样：
varret= [ "if",c,t,e];
//考虑分块操作两个句子的情况，只有一个句子的话丢给make_conditional去考虑
if (t[0] == "if" &&empty(t[3]) &&empty(e)) {
//嵌套IF的压缩
//if (c1) { if (c2) { A() } } else{} 尝试化成这样的AST： if (c1 && c2) { A()}
//看看哪个AST生成的代码短，谁短用谁。ret=best_of(ret,walk([ "if", [ "binary", "&&",c,t[1] ],t[2] ]));
}
else if (t[0] == "stat") {//如果if分支列表是一个语句
if (e) {
if (e[0] == "stat")
//else也是一个语句，那就搞成条件表达式ret=best_of(ret, [ "stat",make_conditional(c,t[1],e[1]) ]);
else if (aborts(e))//如果else最后有return等跳转控制的关键字ret=abort_else(c,t,e);
}
else {//else为空的情况，也搞成条件表达式ret=best_of(ret, [ "stat",make_conditional(c,t[1]) ]);
}
}
else if (e&&t[0] ==e[0] && (t[0] == "return" ||t[0] == "throw") &&t[1] &&e[1]) {
//if (c) { return A(); } else { return B(); }
//优化成：return c ? A() : B();ret=best_of(ret, [t[0],make_conditional(c,t[1],e[1] ) ]);
}
else if (e&&aborts(t)) {
//看到prepare_ifs做的操作被这里还原回去了~ret= [ [ "if",c,t] ];
if (e[0] == "block") {
if (e[1])ret=ret.concat(e[1]);
}
else {ret.push(e);
}ret=walk([ "block",ret]);
}
else if (t&&aborts(e)) {ret=abort_else(c,t,e);
}
returnret;
};
function_do_while(cond,body) {
returnwhen_constant(cond, function(cond,val){
if (!val) {//while(false){}变成空语句warn_unreachable(body);
return [ "block" ];
} else {//while(true){}变成for(;;){} 缩短4个字符！
return [ "for", null, null, null,walk(body) ];
}
});
};
//遍历AST树 此时遍历名已经混淆过~
returnw.with_walkers({
//对于表达式 expr[subscript] 的优化
"sub": function(expr,subscript) {
if (subscript[0] == "string") {
varname=subscript[1];
if (is_identifier(name))
//a["b"] ==> a.b
//这样可以省去3个字符
return [ "dot",walk(expr),name];
else if (/^[1-9][0-9]*$/.test(name) ||name=== "0")
//a[010] => a[8]
//表达式可能是八进制的，化成10禁止会更短
return [ "sub",walk(expr), [ "num",parseInt(name, 10) ] ];
}
},
"if":make_if,
"toplevel": function(body) {
return [ "toplevel",tighten(body) ];
},
"switch": function(expr,body) {
varlast=body.length- 1;
return [ "switch",walk(expr),MAP(body, function(branch,i){
varblock=tighten(branch[1]);
if (i==last&&block.length> 0) {
//最后一个case分支，最后一句的break;可以去掉
//留意break labelName;这种是不能省略的
varnode=block[block.length- 1];
if (node[0] == "break" && !node[1])block.pop();//忽略最后一句break;
}
return [branch[0] ?walk(branch[0]) : null,block];
}) ];
},
"function":_lambda,
"defun":_lambda,
"block": function(body) {
if (body) returnrmblock([ "block",tighten(body) ]);
},
"binary": function(op,left,right) {
returnwhen_constant([ "binary",op,walk(left),walk(right) ], functionyes(c){
returnbest_of(walk(c), this);
}, functionno() {
return function(){
if(op!= "==" &&op!= "!=") return;
//只有==跟!=才压缩
varl=walk(left),r=walk(right);
//!1 == right
if(l&&l[0] == "unary-prefix" &&l[1] == "!" &&l[2][0] == "num")left= ['num', +!l[2][1]];
//left == !2
else if (r&&r[0] == "unary-prefix" &&r[1] == "!" &&r[2][0] == "num")right= ['num', +!r[2][1]];
return ["binary",op,left,right];
}() || this;
});
},
"conditional": function(c,t,e) {
returnmake_conditional(walk(c),walk(t),walk(e));
},
"try": function(t,c,f) {
return [
"try",tighten(t),c!= null ? [c[0],tighten(c[1]) ] : null,f!= null ?tighten(f) : null
];
},
"unary-prefix": function(op,expr) {expr=walk(expr);
varret= [ "unary-prefix",op,expr];
if (op== "!")//!(a>=b) 优化成 a>', '<>>', '|', '^', '&' ];
//赋值语句一般是+= -= ，所以语法分析时候解析出来的op是去掉=的结果，
//但是如果是a = 1的话,op不好用一个空字符串来表示，所以用了true
//a = a + b; 优化成为 a += b
if (op=== true &&lvalue[0] === "name" &&rvalue[0] === "binary" &&
~okOps.indexOf(rvalue[1]) &&rvalue[2][0] === "name" &&rvalue[2][1] ===lvalue[1]) {
//原本是：["assign", true, ["name", "a"], ["binary", ["name", "a"], ["name", "b"]]]
//压缩成：["assign", "+", ["name", "a"], ["name", "b"]]
return [ this[0],rvalue[1],lvalue,rvalue[3] ]
}
return [ this[0],op,lvalue,rvalue];
},
"call": function(expr,args) {expr=walk(expr);
//把"string".toString();替换成"string"
if (options.unsafe&&expr[0] == "dot" &&expr[1][0] == "string" &&expr[2] == "toString") {
returnexpr[1];
}
return [ this[0],expr,MAP(args,walk) ];
},
"num": function (num) {
if (!isFinite(num))//如果是无穷大或者NaN
//Infinity => 1/0
//-Infinity => -1/0
//NaN => 0/0
return [ "binary", "/",num=== 1 / 0
? [ "num", 1 ] :num=== -1 / 0
? [ "unary-prefix", "-", [ "num", 1 ] ]
: [ "num", 0 ], [ "num", 0 ] ];
return [ this[0],num];
}
}, function() {
//遍历之前先处理一下IF
//这里还重复处理两次？@unkowned
returnwalk(prepare_ifs(walk(prepare_ifs(ast))));
});
};
//去除重复的指示性字符串，例如
/*
function (){
"use strict";
function (){
"use strict";
}
}
压缩成：
function (){
"use strict";
function (){
}
}
*/
functionsqueeze_2(ast,options) {
varw=ast_walker(),walk=w.walk,scope;
functionwith_scope(s,cont) {
varsave=scope,ret;scope=s;ret=cont();scope=save;
returnret;
};
functionlambda(name,args,body) {
return [ this[0],name,args,with_scope(body.scope,curry(MAP,body,walk)) ];
};
returnw.with_walkers({
"directive": function(dir) {
if (scope.active_directive(dir))
return [ "block" ];scope.directives.push(dir);
},
"toplevel": function(body) {
return [ this[0],with_scope(this.scope,curry(MAP,body,walk)) ];
},
"function":lambda,
"defun":lambda}, function(){
returnwalk(ast_add_scope(ast));
});
};