DIV CSS 佈局教程網

Underscore.js 1.3.3 源码解读:那些每天都在用的工具函数是怎么实现的
編輯:JavaScript基礎知識     

在 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 开始

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 做多字段排序的通用套路。

三、数组方法:uniq 与 flatten 的门道

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 归零。

四、函数方法:throttle 与 debounce

这一组是 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 生成缓存键,把结果存在闭包里。

五、对象与深比较:eq 函数的分支艺术

_.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 的心智模型、以及"库要足够小、足够可组合"的设计哲学,至今仍是前端工具箱的底色。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved