$ParseProvider简介
此服务提供者也是angularjs中用的比较多的，下面我们来详细的说下这个provider。
function $ParseProvider() {
var cache = {};
var $parseOptions = {
csp: false,
unwrapPromises: false,
logPromiseWarnings: true
};
this.unwrapPromises = function(value) {
if (isDefined(value)) {
$parseOptions.unwrapPromises = !!value;
return this;
} else {
return $parseOptions.unwrapPromises;
}
};
this.logPromiseWarnings = function(value) {
if (isDefined(value)) {
$parseOptions.logPromiseWarnings = value;
return this;
} else {
return $parseOptions.logPromiseWarnings;
}
};
this.$get = ['$filter', '$sniffer', '$log', function($filter, $sniffer, $log) {
.........
}];
}
记住，不管是哪个provider，我们都要先看它的$get属性。
this.$get = ['$filter', '$sniffer', '$log', function($filter, $sniffer, $log) {
$parseOptions.csp = $sniffer.csp;
promiseWarning = function promiseWarningFn(fullExp) {
if (!$parseOptions.logPromiseWarnings || promiseWarningCache.hasOwnProperty(fullExp)) return;
promiseWarningCache[fullExp] = true;
$log.warn('[$parse] Promise found in the expression `' + fullExp + '`. ' +
'Automatic unwrapping of promises in Angular expressions is deprecated.');
};
return function(exp) {
var parsedExpression;
switch (typeof exp) {
case 'string':
if (cache.hasOwnProperty(exp)) {
return cache[exp];
}
var lexer = new Lexer($parseOptions);
var parser = new Parser(lexer, $filter, $parseOptions);
parsedExpression = parser.parse(exp, false);
if (exp !== 'hasOwnProperty') {
cache[exp] = parsedExpression;
}
return parsedExpression;
case 'function':
return exp;
default:
return noop;
}
};
}];
在switch语句中可以看出，如果解析的是函数，则直接返回，如果是字符串，则需要对字符串进行解析。
代码中有两个关键类：
lexer，负责解析字符串，然后生成token，有点类似编译原理中的词法分析器
parser，负责对lexer生成的token，生成执行表达式，其实就是返回一个方法
switch中会先创建一个lexer实例对象，然后把lexer实例的对象传给parser的构造函数，生成parser实例对象，最后调用parser.parse方法生成执行表达式，实质是一个方法。
接下来，我们来看看parser.parse方法：
parse: function (text, json) {
this.text = text;
this.json = json;
this.tokens = this.lexer.lex(text);
if (json) {
this.assignment = this.logicalOR;
this.functionCall =
this.fieldAccess =
this.objectIndex =
this.filterChain = function() {
this.throwError('is not valid json', {text: text, index: 0});
};
}
var value = json ? this.primary() : this.statements();
if (this.tokens.length !== 0) {
this.throwError('is an unexpected token', this.tokens[0]);
}
value.literal = !!value.literal;
value.constant = !!value.constant;
return value;
},
里面的重点是this.tokens = this.lexer.lex(text);这句，它通过lexer解析字符串，生成token。
然后，执行var value = json ? this.primary() : this.statements();这句代码，默认情况下，json是false，所以会执行this.statements()方法，这里将会生成执行表达式。我们来看下parse的statements方法的源码：
statements: function() {
var statements = [];
while (true) {
if (this.tokens.length > 0 && !this.peek('}', ')', ';', ']'))
statements.push(this.filterChain());
if (!this.expect(';')) {
// optimize for the common case where there is only one statement.
// TODO(size): maybe we should not support multiple statements?
return (statements.length === 1)
? statements[0]
: function(self, locals) {
var value;
for (var i = 0; i < statements.length; i++) {
var statement = statements[i];
if (statement) {
value = statement(self, locals);
}
}
return value;
};
}
}
},
上面的代码中，有一个无限循环的while循环，此循环，会在return语句后，停止。
在while循环中，生成执行表达式的是filterChain方法返回的值，它被push到statements数组中。
最后，我们看return语句，也就是statements方法的返回值。如果表达式数组的长度为1，则返回第一个执行表达式，否则返回一个包装函数，里面是一个循环，循环处理所有的执行表达式，但是只返回最后一个表达式的值。
接下来，我们来看看lex方法：
lex: function (text) {
this.text = text;
this.index = 0;
this.ch = undefined;
this.lastCh = ':'; // can start regexp
this.tokens = [];
var token;
var json = [];
while (this.index < this.text.length) {
this.ch = this.text.charAt(this.index);
if (this.is('"\'')) {
this.readString(this.ch);
} else if (this.isNumber(this.ch) || this.is('.') && this.isNumber(this.peek())) {
this.readNumber();
} else if (this.isIdent(this.ch)) {
this.readIdent();
// identifiers can only be if the preceding char was a { or ,
if (this.was('{,') && json[0] === '{' &&
(token = this.tokens[this.tokens.length - 1])) {
token.json = token.text.indexOf('.') === -1;
}
} else if (this.is('(){}[].,;:?')) {
this.tokens.push({
index: this.index,
text: this.ch,
json: (this.was(':[,') && this.is('{[')) || this.is('}]:,')
});
if (this.is('{[')) json.unshift(this.ch);
if (this.is('}]')) json.shift();
this.index++;
} else if (this.isWhitespace(this.ch)) {
this.index++;
continue;
} else {
var ch2 = this.ch + this.peek();
var ch3 = ch2 + this.peek(2);
var fn = OPERATORS[this.ch];
var fn2 = OPERATORS[ch2];
var fn3 = OPERATORS[ch3];
if (fn3) {
this.tokens.push({index: this.index, text: ch3, fn: fn3});
this.index += 3;
} else if (fn2) {
this.tokens.push({index: this.index, text: ch2, fn: fn2});
this.index += 2;
} else if (fn) {
this.tokens.push({
index: this.index,
text: this.ch,
fn: fn,
json: (this.was('[,:') && this.is('+-'))
});
this.index += 1;
} else {
this.throwError('Unexpected next character ', this.index, this.index + 1);
}
}
this.lastCh = this.ch;
}
return this.tokens;
},
上面的代码主要就是分析传入到lex内的字符串text，主要通过一个while循环，依次检查当前字符是否是数字，是否是变量标识等，假如是数字的话，则转到lexer的
readNumber方法。最后，反正生成了一个token给Parser构造方法生成一个Parser实例对象parser。然后通过这个实例对象parser的parse来解析字符串表达式，生成执行表达式（其实就是一个方法）。
好了，说完了生成执行表达式的代码，其实parse的任务已经完成了。
在上一课的$RootScopeProvider源码解析中，有讲到，$RootScopeProvider的$watch函数中的compileToFn方法调用了$parse方法，而本课主要来讲解$parse如何通过解析字符串来生成执行表达式。
通过，这两课的讲解，大家知道了，angular内置的服务提供者，都带有$get属性，并且真正的定义也在$get属性值中。$RootScopeProvider服务提供者，是用来实例化一个根作用域对象的。
$ParseProvider服务提供者，是用来实例化一个解析器对象的，它主要用来解析页面中的angular表达式的。
加油！