在 jQuery 管 DOM、Backbone 管结构的年代,Underscore.js 是那个默默处理数据的角色。它不碰 DOM,不做模板绑定,只提供一百多个函数式工具:遍历、映射、归约、去重、节流、深比较、模板渲染。很多今天看来理所当然的写法(_.map、_.debounce、_.extend),都是它普及开来的。
下面按 1.3.3 版本的文件顺序,梳理它的整体设计与关键实现。
// Underscore.js 1.3.3
// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
// Underscore is freely distributable under the MIT license.
// https://documentcloud.github.com/underscore
(function() {
// 全局对象:浏览器为 window,Node.js 为 global
var root = this;
// 保存 _ 被覆盖前的值,供 noConflict 使用
var previousUnderscore = root._;
// 一个空对象常量,作为 reduce 迭代中止的哨兵
var breaker = {};
// 缓存内置原型,避免深层查找
var ArrayProto = Array.prototype,
ObjProto = Object.prototype,
FuncProto = Function.prototype;
var slice = ArrayProto.slice,
unshift = ArrayProto.unshift,
toString = ObjProto.toString,
hasOwnProperty = ObjProto.hasOwnProperty;
// 优先使用宿主环境(ES5)原生实现,缺失时回退到 Underscore 自己的版本
var nativeForEach = ArrayProto.forEach,
nativeMap = ArrayProto.map,
nativeReduce = ArrayProto.reduce,
nativeFilter = ArrayProto.filter,
nativeEvery = ArrayProto.every,
nativeSome = ArrayProto.some,
nativeIndexOf = ArrayProto.indexOf,
nativeIsArray = Array.isArray,
nativeKeys = Object.keys,
nativeBind = FuncProto.bind;
// 对象式调用入口:返回一个包装器,其原型上挂载了所有 Underscore 方法
var _ = function(obj) {
return new wrapper(obj);
};
// 环境适配:Node.js 挂到 exports,浏览器挂到全局
if (typeof exports !== 'undefined') {
if (typeof module !== 'undefined' && module.exports) {
exports = module.exports = _;
}
exports._ = _;
} else {
root['_'] = _;
}
_.VERSION = '1.3.3';
}).call(this);
这里有两个贯穿全库的设计取向:
nativeMap 之类的原生方法缓存下来,运行时优先调用宿主实现,既拿到原生的性能,又能在老环境自动降级。_.map(arr, fn) 和 _(arr).map(fn) 都能用,后者靠文件末尾的包装器机制实现。each 是库里被复用最多的函数,很多其他方法内部直接委托给它。它同时处理数组和对象两种输入:
var each = _.each = _.forEach = function(obj, iterator, context) {
if (obj == null) return; // 空值直接跳过,不抛错
if (nativeForEach && obj.forEach === nativeForEach) {
obj.forEach(iterator, context); // 原生实现优先
} else if (obj.length === +obj.length) { // 判定为数组类
for (var i = 0, l = obj.length; i < l; i++) {
if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
}
} else { // 当作对象遍历
for (var key in obj) {
if (_.has(obj, key)) {
if (iterator.call(context, obj[key], key, obj) === breaker) return;
}
}
}
};
两个细节值得留意:obj.length === +obj.length 是一个经典的"类数组"判定(真数组的 length 转数字后与自身相等);而返回哨兵 breaker 就能提前中断遍历,这个模式在 find、any、every 里反复出现。
map 在此基础上收集返回值:
_.map = _.collect = function(obj, iterator, context) {
var results = [];
if (obj == null) return results;
if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
each(obj, function(value, index, list) {
results[results.length] = iterator.call(context, value, index, list);
});
if (obj.length === +obj.length) results.length = obj.length; // 保持稀疏数组的空洞
return results;
};
reduce 支持"不传初始值"的调用方式,靠 arguments.length 判断:
_.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
var initial = arguments.length > 2;
if (obj == null) obj = [];
each(obj, function(value, index, list) {
if (!initial) {
memo = value; // 没有初始值,用第一个元素开个头
initial = true;
} else {
memo = iterator.call(context, memo, value, index, list);
}
});
if (!initial) throw new TypeError('Reduce of empty array with no initial value');
return memo;
};
其余集合方法基本是同一套模式的变体:find 借助 any 提前中断并记录首个命中项;filter / reject 收集通过或未通过的元素;every 用 result = result && iterator(...) 短路;pluck 和 invoke 则分别是 map 的特化版本——一个取属性,一个调方法。
max / min 有一处小优化:纯数字数组直接走 Math.max.apply,否则用 computed 字段边遍历边比较:
_.max = function(obj, iterator, context) {
if (!iterator && _.isArray(obj) && obj[0] === +obj[0]) return Math.max.apply(Math, obj);
if (!iterator && _.isEmpty(obj)) return -Infinity;
var result = { computed: -Infinity };
each(obj, function(value, index, list) {
var computed = iterator ? iterator.call(context, value, index, list) : value;
computed >= result.computed && (result = { value: value, computed: computed });
});
return result.value;
};
sortBy 的写法也很典型——不重复实现排序,而是"映射成 {value, criteria} → 原生 sort → pluck 取出 value":
_.sortBy = function(obj, val, context) {
var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
return _.pluck(_.map(obj, function(value, index, list) {
return { value: value, criteria: iterator.call(context, value, index, list) };
}).sort(function(left, right) {
var a = left.criteria, b = right.criteria;
if (a === void 0) return 1; // undefined 排在最后
if (b === void 0) return -1;
return a < b ? -1 : a > b ? 1 : 0;
}), 'value');
};
这就是 decorate-sort-undecorate 模式,Python 社区称之为"德 decorated sort",是拿原生 sort 做多字段排序的通用套路。
flatten 通过 reduce 递归展开,shallow 控制深度:
_.flatten = function(array, shallow) {
return _.reduce(array, function(memo, value) {
if (_.isArray(value)) {
// shallow 时只摊平一层,否则递归到底
return memo.concat(shallow ? value : _.flatten(value));
}
memo[memo.length] = value;
return memo;
}, []);
};
uniq 的巧思在于用一个可选的 isSorted 参数切换两种去重策略:数组已排序时只需和"上一个"比较,否则退化为 include 全量查找。它同时支持 iterator——按转换后的值比较,但返回原始值:
_.uniq = _.unique = function(array, isSorted, iterator) {
// 用 iterator 生成比较基准,返回值仍取自原始数组
var initial = iterator ? _.map(array, iterator) : array;
var results = [];
if (array.length < 3) isSorted = true; // 元素很少时直接走快路径
_.reduce(initial, function(memo, value, index) {
if (isSorted ? _.last(memo) !== value || !memo.length : !_.include(memo, value)) {
memo.push(value);
results.push(array[index]);
}
return memo;
}, []);
return results;
};
zip 的实现堪称函数式的教科书示范——按最大长度循环,每轮用 pluck 取出各个数组同一位置的值:
_.zip = function() {
var args = slice.call(arguments);
var length = _.max(_.pluck(args, 'length')); // 以最长的数组为准
var results = new Array(length);
for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
return results;
};
而 intersection 是 filter + every + indexOf 的组合,difference 和 without 则互为表亲——后者只是前者的参数糖:
_.without = function(array) {
return _.difference(array, slice.call(arguments, 1));
};
_.difference = function(array) {
var rest = _.flatten(slice.call(arguments, 1), true); // 只摊一层
return _.filter(array, function(value) {
return !_.include(rest, value);
});
};
range 则通过参数个数智能判断调用意图:只传一个参数时视为 stop,start 归零。
这一组是 Underscore 被引用最多的部分,也是很多人对"为什么要节流"的最初认知来源。
bind 在原生 Function.prototype.bind 缺失时自己实现,并且额外支持了"用作构造函数"的语义:
_.bind = function bind(func, context) {
var bound, args;
if (func.bind === nativeBind && nativeBind) {
return nativeBind.apply(func, slice.call(arguments, 1));
}
if (!_.isFunction(func)) throw new TypeError;
args = slice.call(arguments, 2);
return bound = function() {
if (!(this instanceof bound)) return func.apply(context, sargs.concat(slice.call(arguments)));
ctor.prototype = func.prototype;
var self = new ctor;
var result = func.apply(self, args.concat(slice.call(arguments)));
if (Object(result) === result) return result;
return self;
};
};
throttle 保证"固定频率内最多执行一次",并在时间窗口结束时补一次调用,避免最后一次输入被丢掉:
_.throttle = function(func, wait) {
var context, args, timeout, throttling, more, result;
// 用 debounce 在最后一次调用后清理状态
var whenDone = _.debounce(function() { more = throttling = false; }, wait);
return function() {
context = this;
args = arguments;
var later = function() {
timeout = null;
if (more) func.apply(context, args); // 窗口内还有未执行的调用,补一次
whenDone();
};
if (!timeout) timeout = setTimeout(later, wait);
if (throttling) {
more = true; // 处于节流中,只记一个标记
} else {
result = func.apply(context, args); // 首次或窗口已过,立即执行
}
whenDone();
throttling = true;
return result;
};
};
debounce 的关注点不同——它关心"两次执行的间隔",每次新调用都会重置计时器,因此连续触发时函数一直不执行,直到用户停下来:
_.debounce = function(func, wait, immediate) {
var timeout;
return function() {
var context = this, args = arguments;
var later = function() {
timeout = null;
if (!immediate) func.apply(context, args);
};
// immediate 为 true 时"首次立即执行,之后静默"
if (immediate && !timeout) func.apply(context, args);
clearTimeout(timeout); // 关键:重置计时,把执行时间往后推
timeout = setTimeout(later, wait);
};
};
一句话区分:throttle 管频率,debounce 管间隔。滚动、拖拽、resize 用 throttle;搜索联想、表单校验用 debounce。
另外几个高频工具:once 用 ran 标记只执行一次;after 是一个计数器,被调用 times 次后才真正执行,常用来等待多个异步请求全部返回;compose 从右向左嵌套调用函数;memoize 用 hasher 生成缓存键,把结果存在闭包里。
_.isEqual 对外只有一行,真正的逻辑都在内部函数 eq 里。它按类型逐层拆解,顺序安排得相当讲究:
function eq(a, b, stack) {
// 1. 严格相等:注意区分 0 与 -0
if (a === b) return a !== 0 || 1 / a == 1 / b;
// 2. null / undefined 只与自身相等
if (a == null || b == null) return a === b;
// 3. 若是 Underscore 包装对象,先脱壳再比较
if (a._chain) a = a._wrapped;
if (b._chain) b = b._wrapped;
// 4. 尊重对象自定义的 isEqual
if (a.isEqual && _.isFunction(a.isEqual)) return a.isEqual(b);
if (b.isEqual && _.isFunction(b.isEqual)) return b.isEqual(a);
// 5. 类型必须一致
var className = toString.call(a);
if (className != toString.call(b)) return false;
switch (className) {
case '[object String]': return a == String(b);
case '[object Number]':
// NaN 不等于任何值,包括自己,需单独判断
return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
case '[object Date]':
case '[object Boolean]': return +a == +b; // 日期转时间戳,布尔转 0/1
case '[object RegExp]':
return a.source == b.source && a.global == b.global &&
a.multiline == b.multiline && a.ignoreCase == b.ignoreCase;
}
if (typeof a != 'object' || typeof b != 'object') return false;
// 6. 用 stack 检测循环引用,避免无限递归
var length = stack.length;
while (length--) { if (stack[length] == a) return true; }
stack.push(a);
var size = 0, result = true;
if (className == '[object Array]') {
size = a.length;
result = size == b.length;
if (result) {
while (size--) {
if (!(result = size in a == size in b && eq(a[size], b[size], stack))) break;
}
}
} else {
// 对象:构造函数不同则直接判不等
if ('constructor' in a != 'constructor' in b || a.constructor != b.constructor) return false;
for (var key in a) {
if (_.has(a, key)) {
size++;
if (!(result = _.has(b, key) && eq(a[key], b[key], stack))) break;
}
}
if (result) {
// 再反向扫一遍 b,防止 b 比 a 多属性
for (key in b) {
if (_.has(b, key) && !(size--)) break;
}
result = !size;
}
}
stack.pop();
return result;
}
_.isEqual = function(a, b) { return eq(a, b, []); };
这套实现里藏着不少"经验痕迹":区分 0 与 -0、单独处理 NaN、用 stack 应对循环引用、比较完 a 的属性后再反向确认 b 没有多余属性。深比较看起来简单,边界情况却出奇地多。
对象相关方法则大多围绕 for...in + _.has 展开:keys / values / functions 收集属性,extend 浅合并,pick 白名单取值,defaults 补默认值(判断条件是 obj[prop] == null,因此 false、0、'' 都不会被覆盖),clone 明确声明只做浅拷贝。
_.template 是 Underscore 里最"跨界"的功能,也是很多早期前端的第一个模板引擎。它的做法是:把模板字符串编译成一段 JavaScript 源码,再用 new Function 生成渲染函数。
_.templateSettings = {
evaluate: /<%([\s\S]+?)%>/g, // 执行任意 JS 代码
interpolate: /<%=([\s\S]+?)%>/g, // 输出变量(不转义)
escape: /<%-([\s\S]+?)%>/g // 输出并转义 HTML
};
_.template = function(text, data, settings) {
settings = _.defaults(settings || {}, _.templateSettings);
var source = "__p+='" + text
.replace(escaper, function(match) { return '\\' + escapes[match]; })
.replace(settings.escape || noMatch, function(match, code) {
return "'+\n_.escape(" + unescape(code) + ")+\n'";
})
.replace(settings.interpolate || noMatch, function(match, code) {
return "'+\n(" + unescape(code) + ")+\n'";
})
.replace(settings.evaluate || noMatch, function(match, code) {
// 结束当前字符串,插入可执行代码,再开启新字符串
return "';\n" + unescape(code) + "\n;__p+='";
}) + "';\n";
if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
source = "var __p='';" +
"var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n" +
source + "return __p;\n";
var render = new Function(settings.variable || 'obj', '_', source);
// 传了 data 就直接返回结果;没传则返回函数,可复用于多次渲染
if (data) return render(data, _);
var template = function(data) { return render.call(this, data, _); };
template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
return template;
};
三点值得注意:先转义模板里的反斜杠与引号,避免拼出的源码语法出错;settings.variable 存在时不使用 with,这在严格模式或 CSP 环境下是必需的;不传 data 时返回函数而非字符串,编译只发生一次,多次渲染性能更好。
要让 _(arr).map(fn).filter(fn).value() 成立,Underscore 做了一套巧妙的原型腾挪:
// 包装器:原始数据存放在 _wrapped 上
var wrapper = function(obj) { this._wrapped = obj; };
// 关键一步:让 _.prototype 指向 wrapper.prototype
_.prototype = wrapper.prototype;
// 结果处理:调用了 chain() 就继续返回包装对象,否则拆包
var result = function(obj, chain) {
return chain ? _(obj).chain() : obj;
};
// 把任意函数挂到 wrapper 原型上,自动把当前值插到第一个参数位
var addToWrapper = function(name, func) {
wrapper.prototype[name] = function() {
var args = slice.call(arguments);
unshift.call(args, this._wrapped);
return result(func.apply(_, args), this._chain);
};
};
_.mixin(_); // 把 _ 上所有方法批量混入 wrapper 原型
// 原生数组方法也一并代理,并保留链式能力
each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
var method = ArrayProto[name];
wrapper.prototype[name] = function() {
var wrapped = this._wrapped;
method.apply(wrapped, arguments);
var length = wrapped.length;
if ((name == 'shift' || name == 'splice') && length === 0) delete wrapped[0];
return result(wrapped, this._chain);
};
});
wrapper.prototype.chain = function() { this._chain = true; return this; };
wrapper.prototype.value = function() { return this._wrapped; };
因为 _.prototype === wrapper.prototype,往 wrapper 原型上加方法等于给 _ 的实例加方法,于是 _.mixin 既能扩展函数式 API,又能同步支持链式调用。这套思路在后来的 Lodash 中被发扬光大。
Underscore 1.3.3 的源码几乎没有炫技,通篇是"用最少的代码把边界情况处理干净":能力探测让它在 ES5 前后都能跑;breaker 哨兵统一了提前退出;each 作为基石被反复复用;eq 里那些看似啰嗦的分支,每一条都对应着一个真实的坑。
今天 _.map 这类功能已经是数组原生方法,Lodash 也早已接过了工具箱的接力棒。但 Underscore 留下的东西远不止几个函数:函数式风格、链式调用、throttle / debounce 的心智模型、以及"库要足够小、足够可组合"的设计哲学,至今仍是前端工具箱的底色。