_.templateSettings = {

	// 执行JavaScript语句，并将结果插入。

	evaluate: /<%([\s\S]+?)%>/g,

	// 插入变量的值。

	interpolate: /<%=([\s\S]+?)%>/g,

	// 插入变量的值，并进行HTML转义。

	escape: /<%-([\s\S]+?)%>/g

};

var noMatch = /(.)^/;

var escapes = {

	"'": "'",

	'\\': '\\',

	'\r': 'r',

	'\n': 'n',

	'\u2028': 'u2028',

	'\u2029': 'u2029'

};

// 匹配需要转义字符的正则表达式。

var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;

// 返回字符对应的转义后的字符。

var escapeChar = function (match) {

	return '\\' + escapes[match];

};

let str = 'abc';

str.replace(/a/g, function() {

    console.log(arguments);

});

let str = 'abcabc';

str.replace(/a/g, function() {

    console.log(arguments);

});

let str = 'abcabcabc';

str.replace(/(ab)|(c)/g, function() {

    console.log(arguments);

});

_.template = function (text, settings, oldSettings) {

	// 如果第二个参数为null或undefined。。等，那么使用oldSettings作为settings。

	if (!settings && oldSettings) settings = oldSettings;

	// 如果三个参数齐整，那么使用整合后的对象作为settings。

	settings = _.defaults({}, settings, _.templateSettings);

	// Combine delimiters into one regular expression via alternation.

	// 匹配占位符的正则表达式，将配置项中的三个正则合并，每一个正则都是一个捕获组，如果配置项没有包含的话，就默认不匹配任何值。

	var matcher = RegExp([

		(settings.escape || noMatch).source,

		(settings.interpolate || noMatch).source,

		(settings.evaluate || noMatch).source

	].join('|') + '|$', 'g');

	// Compile the template source, escaping string literals appropriately.

	var index = 0;

	var source = "__p+='";

	// function回调作为string.replace的第二个参数会传递至少三个参数，如果有多余捕获的话，也会被作为参数依次传入。

	// string.replace只会返回替换之后的字符串，但是不会对原字符串进行修改，下面的操作实际上没有修改text，只是借用string.replace的回调函数完成新函数的构建。

	text.replace(matcher, function (match, escape, interpolate, evaluate, offset) {

		// 截取没有占位符的字符片段，并且转义其中需要转义的字符。

		source += text.slice(index, offset).replace(escapeRegExp, escapeChar);

		// 跳过占位符，为下一次截取做准备。

		index = offset + match.length;

		// 转义符的位置使用匹配到的占位符中的变量的值替代，构造一个函数的内容。

		if (escape) {

			// 不为空时将转义后的字符串附加到source。

			source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";

		} else if (interpolate) {

			source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";

		} else if (evaluate) {

			// 由于是直接执行语句，所以直接把evaluate字符串添加到构造函数的字符串中去就好。

			source += "';\n" + evaluate + "\n__p+='";

		}

		// Adobe VMs need the match returned to produce the correct offset.

		// 正常来说没有修改原字符串text，所以不返回值没有关系，但是这里返回了原匹配项，

		// 根据注释的意思，可能是为了防止特殊环境下能够有一个正常的offset偏移量。

		return match;

	});

	source += "';\n";

	// source拼凑出了一个函数定义的所有内容，为后面使用Function构造函数做准备。

	// If a variable is not specified, place data values in local scope.

	// 指定作用域，以取得传入对象数据的所有属性。

	if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';

	source = "var __t,__p='',__j=Array.prototype.join," +

		"print=function(){__p+=__j.call(arguments,'');};\n" +

		source + 'return __p;\n';

	var render;

	try {

		// 通过new Function()形式构造函数对象。

		// new Function(param1, ..., paramN, funcBody)

		render = new Function(settings.variable || 'obj', '_', source);

	} catch (e) {

		e.source = source;

		throw e;

	}

	var template = function (data) {

		return render.call(this, data, _);

	};

	// Provide the compiled source as a convenience for precompilation.

	var argument = settings.variable || 'obj';

	// 为template函数添加source属性以便于进行预编译，以便于发现不可重现的错误。

	template.source = 'function(' + argument + '){\n' + source + '}';

	return template;

};

具体注释都已经写在代码中。

可以发现，在_.template函数中，将配置项中的三个正则合并成了一个，并且每一个正则都构成了一个捕获组，这样回调就会接受6个参数，最后一个参数被作者忽略了。在回调中，作者分别对三种匹配项进行了处理，然后拼接到了source字符串中。

构造完source字符串之后，作者就使用了new Function()的语法构造了一个render函数，通过研究source字符串可以发现，render实际上相当于函数：

function render(settings.variable || 'obj', _) {

    var __t,

        __p = '',

        __j = Array.prototype.join,

        print = function(){

            __p+=__j.call(arguments,'');

        };

    // 如果配置了variable属性就不需要使用with块了。

    with(obj || {}) {

        __p += '...' + ((__t=(" + /*需要转义的变量*/ + "))==null?'':_.escape(__t)) + ((__t=(" + /*变量*/ + "))==null?'':__t) + ... ;

        /*需要执行的JavaScript字符串*/;

    }

    return __p;

}