首先是入口方法
/*tmpl:模板文本 c:用户自定义配置 def:定义编译时执行的数据*/
doT.template = function(tmpl, c, def) { }
然后进入第一局代码
c = c || doT.templateSettings;
doT.templateSettings包含的代码：
templateSettings: { evaluate: /\{\{([\s\S]+?(\}?)+)\}\}/g, interpolate: /\{\{=([\s\S]+?)\}\}/g, encode: /\{\{!([\s\S]+?)\}\}/g, use: /\{\{#([\s\S]+?)\}\}/g, useParams: /(^|[^\w$])def(?:\.|\[[\‘\"])([\w$\.]+)(?:[\‘\"]\])?\s*\:\s*([\w$\.]+|\"[^\"]+\"|\‘[^\‘]+\‘|\{[^\}]+\})/g, define: /\{\{##\s*([\w\.$]+)\s*(\:|=)([\s\S]+?)#\}\}/g, defineParams:/^\s*([\w$]+):([\s\S]+)/,//xxx(\w):xxx(.) conditional: /\{\{\?(\?)?\s*([\s\S]*?)\s*\}\}/g, iterate: /\{\{~\s*(?:\}\}|([\s\S]+?)\s*\:\s*([\w$]+)\s*(?:\:\s*([\w$]+))?\s*\}\})/g, varname: ‘it‘, strip: true, append: true, selfcontained: false },
先不急着看正则是什么意思，理清思路先，继续往下看代码
var cse = c.append ? startend.append : startend.split,
这里定义了一个叫cse的变量，如果c.append为true，则它的值是startend.append，否则它的值是startend.split，看看startend是什么
var startend = { append: { start: "‘+(", end: ")+‘", endencode: "||‘‘).toString().encodeHTML()+‘" }, split: { start: "‘;out+=(", end: ");out+=‘", endencode: "||‘‘).toString().encodeHTML();out+=‘"} },
OK，先不管它的作用，接着往下看
needhtmlencode, sid = 0, indv,
str = (c.use || c.define) ? resolveDefs(c, tmpl, def || {}) : tmpl;
在定义了cse这个变量后，相继又定义了needhtmlencode,sid,indv,str，其中str又牵涉到了resolveDefs这个函数：
function resolveDefs(c, block, def) { return ((typeof block === ‘string‘) ? block : block.toString()) .replace(c.define || skip, function(m, code, assign, value) {//code:def.def.def.xxx(\w) assign:‘:‘|‘=‘ value:xxx(.) if (code.indexOf(‘def.‘) === 0) { code = code.substring(4);//获取def后面的部分 } if (!(code in def)) { if (assign === ‘:‘) { if (c.defineParams) value.replace(c.defineParams, function(m, param, v) {//如果def后面部分没有在传入的属性里面，则检测value部分 def[code] = {arg: param, text: v};//def.xx: xx:xx }); if (!(code in def)) def[code]= value;//def.xx:xx } else { new Function("def", "def[‘"+code+"‘]=" + value)(def);//否则将value赋值给def } } return ‘‘; }) .replace(c.use || skip, function(m, code) { if (c.useParams) code = code.replace(c.useParams, function(m, s, d, param) { if (def[d] && def[d].arg && param) { var rw = (d+":"+param).replace(/‘|\\/g, ‘_‘); def.__exp = def.__exp || {}; def.__exp[rw] = def[d].text.replace(new RegExp("(^|[^\\w$])" + def[d].arg + "([^\\w$])", "g"), "$1" + param + "$2"); return s + "def.__exp[‘"+rw+"‘]"; } }); var v = new Function("def", "return " + code)(def); return v ? resolveDefs(c, v, def) : v; }); }
这个才一百多行代码的doT文件还真是耐嚼啊，分析一下这个函数的作用
1.首先将block转化为string类型
2.调用字符串替换方法，正则为c.define || skip，分析一下c.define这个正则
c.define: /\{\{##\s*([\w\.$]+)\s*(\:|=)([\s\S]+?)#\}\}/g
最外层匹配内容为{{##一些字符串#}}，里面的内容依次是，\s*去掉一些乱打的空格，第一个捕获项([\w\.$]+)，匹配abc123_.abc123_.这种形式的内容，然后\s*去掉一些空格，第二个捕获项(\:|=)，匹配‘:‘或者‘=‘，第三个捕获项([\s\S]+?)什么都匹配
得出结论，c.define匹配的内容是{{##(数字字母下划线和点组成的随意组合)(:|=)(乱起八糟的一些东西)#}}，三个括号分别代表不同的匹配项，
再看看匿名函数的形参，m对应的是被匹配的整个内容，code，assign，value分别代表三个不同的捕获项
还有个skip:/$^/;结束后马上开始？只有空字符才这样吧……意思是什么都不匹配，什么都没匹配意思是跳过了
3.if语句，如果code是以def.开头，则将def.后面的内容截取下来，赋值给code
4.if语句，如果code在def中没有定义，则继续执行
如果assign部分是‘:‘的话继续执行
如果c.defineParams有定义，则将value部分进行字符串替换，正则是c.defineParams
c.defineParams:/^\s*([\w$]+):([\s\S]+)/
^\s*去掉开始的空格，([\w$]+)第一个捕获项，匹配多个数字字母下划线，然后碰到:，([\s\S]+)第二个捕获项，什么都匹配
匹配类(数字字母下划线):(乱起八糟的一些东西)，匿名函数的形参m代表整个匹配项，param代表第一个捕获项，v代表第二个捕获项
匿名函数内部定义code，内容为{arg: param, text: v};
如果经过上面的代码code依然在def中没有定义，则将value作为值，在def中定义code
否则（如果assign是‘=‘）
调用，new Function("def", "def[‘"+code+"‘]=" + value)(def);直接将value赋值给def[code]，为什么用构造函数？因为这样value就能被求出来啦，就跟eval一样
总结一下，从2到4，做的事情是定义def.code的code部分，规则总结如下：
(1)def.code:a:b；def[code]={arg:a, text:b}
(2)def.code:a; def[code]=a;
(3)def.code=a;(这里a是表达式) def[code]=eval(a);
如果def中本就有code这个属性，那么上述三个过程都不会发生
5.经过上面的步骤，已经解析了{{## #}}了，并且都已经被替换为空，def对象中也会有相应属性
继续进行字符串替换，正则是c.use || skip，skip不用说了，直接看c.use
c.use:/\{\{#([\s\S]+?)\}\}/g
外壳：{{# }}，([\s\S]+?)，捕获项，而且啥都行，对应匿名函数参数，m是整个匹配项，code代表第一个捕获项，
if语句，如果c.useParams存在的话，对code进行字符串替换，并且正则就是c.useParams
c.useParams：/(^|[^\w$])def(?:\.|\[[\‘\"])([\w$\.]+)(?:[\‘\"]\])?\s*\:\s*([\w$\.]+|\"[^\"]+\"|\‘[^\‘]+\‘|\{[^\}]+\})/g,
长啊……
(^|[^\w$])第一个捕获项，开始字符或者非数字字母下划线结尾符，
def，
(?:\.|\[[\‘\"])非捕获项，匹配.或者[‘或者["，
第二个捕获项([\w$\.]+)，匹配abc123_.abc123_.abc123_.，
(?:[\‘\"]\])?，匹配‘]或者"]，非贪婪匹配
\s*\:\s*，去掉空格，匹配：，
([\w$\.]+|\"[^\"]+\"|\‘[^\‘]+\‘|\{[^\}]+\})，第三个捕获项，匹配abc123_.abc123_.或者"xxxxxx"或者‘xxxxxx‘，或者{xxxxxxx}
整个正则代表： (一些可能的特殊字符)def.(数字字母下划线和点的组合)[或者用[‘‘]|["包起来"]]:(数字字母下划线和点的组合|"乱七八糟"|‘乱七八糟‘|{乱七八糟})
m,s,d,param分别对应整个匹配项和三个捕获项
if语句，如果def[d]和def[d].arg和param都存在的话，拼接为d:param,并将其中的‘和\都替换为_，赋值给rw变量
定义def.__exp[rw]为将def[d].text中的 特殊字符+def[d].arg+特殊字符 替换为 特殊字符+param+特殊字符 的形式
返回s + "def.__exp[‘"+rw+"‘]"
小结：def.d:param中,将d.text中符合arg的部分替换为param,并将d:param（\和‘替换为_）作为唯一标识rw，赋值给def.__exp，返回s + "def.__exp[‘"+rw+"‘]"并将def.d:param替换，如果def[d]不存在的话就会被替换为undefined，
然后把已经解析完{{# }}形式的code（实际上是s + "def.__exp[‘"+rw+"‘]"）运行一下，并把def作为参数传入，结果用变量V存储
这里，我们可以知道
{{## #}}相当于定义模板，而{{# }}相当于解析模板
如果v为真，则递归调用resolveDefs，直到没有上面两种标签为止，最终，我们把去掉了上面两种标签的字符串存储到str变量中
这个函数可以说理解完了，作用是将{{## #}}中模板定义部分提取出来，并放到def对象中，然后解析{{# }}，根据def中的定义，将其解析成普通文本
回到template方法中
str = ("var out=‘" + (c.strip ? str.replace(/(^|\r|\n)\t* +| +\t*(\r|\n|$)/g,‘ ‘)
.replace(/\r|\n|\t|\/\*[\s\S]*?\*\//g,‘‘): str)
未完待续
呵呵呵