前言

在 《JavaScript 专题系列》 中，我们写了很多的功能函数，比如防抖、节流、去重、类型判断、扁平数组、深浅拷贝、查找数组元素、通用遍历、柯里化、函数组合、函数记忆、乱序等，可以我们该如何组织这些函数，形成自己的一个工具函数库呢？这个时候，我们就要借鉴 underscore 是怎么做的了。

自己实现

如果是我们自己去组织这些函数，我们该怎么做呢？我想我会这样做：

  1. (function(){
  2.     var root = this;
  3.  
  4.     var _ = {};
  5.  
  6.     root._ = _;
  7.  
  8.     // 在这里添加自己的方法
  9.     _.reverse = function(string){
  10.         return string.split('').reverse().join('');
  11.     }
  12.  
  13. })()
  14.  
  15. _.reverse('hello');
  16. => 'olleh'

我们将所有的方法添加到一个名为 _ 的对象上，然后将该对象挂载到全局对象上。

之所以不直接 window. = 是因为我们写的是一个工具函数库，不仅要求可以运行在浏览器端，还可以运行在诸如 Node 等环境中。

root

然而 underscore 可不会写得如此简单，我们从 var root = this 开始说起。

之所以写这一句，是因为我们要通过 this 获得全局对象，然后将 _ 对象，挂载上去。

然而在严格模式下，this 返回 undefined，而不是指向 Window，幸运的是 underscore 并没有采用严格模式，可是即便如此，也不能避免，因为在 ES6 中模块脚本自动采用严格模式，不管有没有声明 use strict。

如果 this 返回 undefined，代码就会报错，所以我们的思路是对环境进行检测，然后挂载到正确的对象上。我们修改一下代码：

  1. var root = (typeof window == 'object' && window.window == window && window) ||
  2.            (typeof global == 'object' && global.global == global && global);

在这段代码中，我们判断了浏览器和 Node 环境，可是只有这两个环境吗？那我们来看看 Web Worker。

Web Worker

Web Worker 属于 HTML5 中的内容，引用《JavaScript权威指南》中的话就是：

在 Web Worker 标准中，定义了解决客户端 JavaScript 无法多线程的问题。其中定义的 “worker” 是指执行代码的并行过程。不过，Web Worker 处在一个自包含的执行环境中，无法访问 Window 对象和 Document 对象，和主线程之间的通信业只能通过异步消息传递机制来实现。

为了演示 Web Worker 的效果，我写了一个 demo，查看代码。

在 Web Worker 中，是无法访问 Window 对象的，所以 typeof window 和 typeof global 的结果都是 undefined，所以最终 root 的值为 false，将一个基本类型的值像对象一样添加属性和方法，自然是会报错的。

那么我们该怎么办呢？

虽然在 Web Worker 中不能访问到 Window 对象，但是我们却能通过 self 访问到 Worker 环境中的全局对象。我们只是要找全局变量挂载而已，所以完全可以挂到 self 中嘛。

而且在浏览器中，除了 window 属性，我们也可以通过 self 属性直接访问到 Winow 对象。

  1. console.log(window.window === window); // true
  2. console.log(window.self === window); // true

考虑到使用 self 还可以额外支持 Web Worker，我们直接将代码改成 self：

  1. var root = (typeof self == 'object' && self.self == self && self) ||
  2.            (typeof global == 'object' && global.global == global && global);

node vm

到了这里，依然没完，让你想不到的是，在 node 的 vm 模块中，也就是沙盒模块，runInContext 方法中，是不存在 window，也不存在 global 变量的，查看代码。

但是我们却可以通过 this 访问到全局对象，所以就有人发起了一个 PR，代码改成了：

  1. var root = (typeof self == 'object' && self.self == self && self) ||
  2.            (typeof global == 'object' && global.global == global && global) ||
  3.            this;

微信小程序

到了这里，还是没完，轮到微信小程序登场了。

因为在微信小程序中，window 和 global 都是 undefined，加上又强制使用严格模式，this 为 undefined，挂载就会发生错误，所以就有人又发了一个 PR，代码变成了：

  1. var root = (typeof self == 'object' && self.self == self && self) ||
  2.            (typeof global == 'object' && global.global == global && global) ||
  3.            this ||
  4.            {};

这就是现在 v1.8.3 的样子。

虽然作者可以直接讲解最终的代码，但是作者更希望带着大家看看这看似普通的代码是如何一步步演变成这样的，也希望告诉大家，代码的健壮性，并非一蹴而就，而是汇集了很多人的经验，考虑到了很多我们意想不到的地方，这也是开源项目的好处吧。

函数对象

现在我们讲第二句 var _ = {};。

如果仅仅设置 为一个空对象，我们调用方法的时候，只能使用 .reverse('hello') 的方式，实际上，underscore 也支持类似面向对象的方式调用，即：

  1. _('hello').reverse(); // 'olleh'

再举个例子比较下两种调用方式：

  1. // 函数式风格
  2. _.each([1, 2, 3], function(item){
  3.     console.log(item)
  4. });
  5.  
  6. // 面向对象风格
  7. _([1, 2, 3]).each(function(item){
  8.     console.log(item)
  9. });

可是该如何实现呢？

既然以 ([1, 2, 3]) 的形式可以执行，就表明 不是一个字面量对象，而是一个函数！

幸运的是，在 JavaScript 中，函数也是一种对象，我们举个例子：

  1. var _ = function() {};
  2. _.value = 1;
  3. _.log = function() { return this.value + 1 };
  4.  
  5. console.log(_.value); // 1
  6. console.log(_.log()); // 2

我们完全可以将自定义的函数定义在 _ 函数上！

目前的写法为：

  1. var root = (typeof self == 'object' && self.self == self && self) ||
  2.            (typeof global == 'object' && global.global == global && global) ||
  3.            this ||
  4.            {};
  5.  
  6. var _ = function() {}
  7.  
  8. root._ = _;

如何做到 ([1, 2, 3]).each(…)呢？即 函数返回一个对象，这个对象，如何调用挂在 _ 函数上的方法呢？

我们看看 underscore 是如何实现的：

  1. var _ = function(obj) {
  2.     if (!(this instanceof _)) return new _(obj);
  3.     this._wrapped = obj;
  4. };
  5.  
  6. _([1, 2, 3]);

我们分析下 _([1, 2, 3]) 的执行过程：

  • 执行 this instanceof ，this 指向 window ，window instanceof 为 false，!操作符取反，所以执行 new _(obj)。
  • new (obj) 中，this 指向实例对象，this instanceof 为 true，取反后，代码接着执行
  • 执行 this._wrapped = obj， 函数执行结束
  • 总结，([1, 2, 3]) 返回一个对象，为 {_wrapped: [1, 2, 3]}，该对象的原型指向 .prototype
    示意图如下：

_()示意图

然后问题来了，我们是将方法挂载到 函数对象上，并没有挂到函数的原型上呐，所以返回了的实例，其实是无法调用 函数对象上的方法的！

我们写个例子：

  1. (function(){
  2.     var root = (typeof self == 'object' && self.self == self && self) ||
  3.                (typeof global == 'object' && global.global == global && global) ||
  4.                this ||
  5.                {};
  6.  
  7.     var _ = function(obj) {
  8.         if (!(this instanceof _)) return new _(obj);
  9.         this._wrapped = obj;
  10.     }
  11.  
  12.     root._ = _;
  13.  
  14.     _.log = function(){
  15.         console.log(1)
  16.     }
  17.  
  18. })()
  19.  
  20. _().log(); // _(...).log is not a function

确实有这个问题，所以我们还需要一个方法将 上的方法复制到 .prototype 上，这个方法就是 _.mixin。

_.functions

为了将 上的方法复制到原型上，首先我们要获得 上的方法，所以我们先写个 _.functions 方法。

  1. _.functions = function(obj) {
  2.     var names = [];
  3.     for (var key in obj) {
  4.         if (_.isFunction(obj[key])) names.push(key);
  5.     }
  6.     return names.sort();
  7. };

isFunction 函数可以参考 《JavaScript专题之类型判断(下)》

mixin

现在我们可以写 mixin 方法了。

  1. var ArrayProto = Array.prototype;
  2. var push = ArrayProto.push;
  3.  
  4. _.mixin = function(obj) {
  5.     _.each(_.functions(obj), function(name) {
  6.         var func = _[name] = obj[name];
  7.         _.prototype[name] = function() {
  8.             var args = [this._wrapped];
  9.             push.apply(args, arguments);
  10.             return func.apply(_, args);
  11.         };
  12.     });
  13.     return _;
  14. };
  15.  
  16. _.mixin(_);

each 方法可以参考 《JavaScript专题jQuery通用遍历方法each的实现》

值得注意的是：因为 _[name] = obj[name] 的缘故，我们可以给 underscore 拓展自定义的方法:

  1. _.mixin({
  2.   addOne: function(num) {
  3.     return num + 1;
  4.   }
  5. });
  6.  
  7. _(2).addOne(); // 3

至此，我们算是实现了同时支持面向对象风格和函数风格。

导出

终于到了讲最后一步 root. = ，我们直接看源码：

  1. if (typeof exports != 'undefined' && !exports.nodeType) {
  2.     if (typeof module != 'undefined' && !module.nodeType && module.exports) {
  3.         exports = module.exports = _;
  4.     }
  5.     exports._ = _;
  6. } else {
  7.     root._ = _;
  8. }

为了支持模块化，我们需要将 _ 在合适的环境中作为模块导出，但是 nodejs 模块的 API 曾经发生过改变，比如在早期版本中：

  1. // add.js
  2. exports.addOne = function(num) {
  3.   return num + 1
  4. }
  5.  
  6. // index.js
  7. var add = require('./add');
  8. add.addOne(2);

在新版本中：

  1. // add.js
  2. module.exports = function(1){
  3.     return num + 1
  4. }
  5.  
  6. // index.js
  7. var addOne = require('./add.js')
  8. addOne(2)

所以我们根据 exports 和 module 是否存在来选择不同的导出方式，那为什么在新版本中，我们还要使用 exports = module.exports = _ 呢？

这是因为在 nodejs 中，exports 是 module.exports 的一个引用，当你使用了 module.exports = function(){}，实际上覆盖了 module.exports，但是 exports 并未发生改变，为了避免后面再修改 exports 而导致不能正确输出，就写成这样，将两者保持统一。

写个 demo 吧：

  1. // exports 是 module.exports 的一个引用
  2. module.exports.num = '1'
  3.  
  4. console.log(exports.num) // 1
  5.  
  6. exports.num = '2'
  7.  
  8. console.log(module.exports.num) // 2
  1. // addOne.js
  2. module.exports = function(num){
  3.     return num + 1
  4. }
  5.  
  6. exports.num = '3'
  7.  
  8. // result.js 中引入 addOne.js
  9. var addOne = require('./addOne.js');
  10.  
  11. console.log(addOne(1)) // 2
  12. console.log(addOne.num) // undefined
  1. // addOne.js
  2. exports = module.exports = function(num){
  3.     return num + 1
  4. }
  5.  
  6. exports.num = '3'
  7.  
  8. // result.js 中引入 addOne.js
  9. var addOne = require('./addOne.js');
  10.  
  11. console.log(addOne(1)) // 2
  12. console.log(addOne.num) // 3

最后为什么要进行一个 exports.nodeType 判断呢？这是因为如果你在 HTML 页面中加入一个 id 为 exports 的元素，比如

  1. <div id="exports"></div>

就会生成一个 window.exports 全局变量，你可以直接在浏览器命令行中打印该变量。

此时在浏览器中，typeof exports != 'undefined' 的判断就会生效，然后 exports. = ，然而在浏览器中，我们需要将 _ 挂载到全局变量上呐，所以在这里，我们还需要进行一个是否是 DOM 节点的判断。

源码

最终的代码如下，有了这个基本结构，你可以自由添加你需要使用到的函数了：

  1. (function() {
  2.  
  3.     var root = (typeof self == 'object' && self.self == self && self) ||
  4.         (typeof global == 'object' && global.global == global && global) ||
  5.         this || {};
  6.  
  7.     var ArrayProto = Array.prototype;
  8.  
  9.     var push = ArrayProto.push;
  10.  
  11.     var _ = function(obj) {
  12.         if (obj instanceof _) return obj;
  13.         if (!(this instanceof _)) return new _(obj);
  14.         this._wrapped = obj;
  15.     };
  16.  
  17.     if (typeof exports != 'undefined' && !exports.nodeType) {
  18.         if (typeof module != 'undefined' && !module.nodeType && module.exports) {
  19.             exports = module.exports = _;
  20.         }
  21.         exports._ = _;
  22.     } else {
  23.         root._ = _;
  24.     }
  25.  
  26.     _.VERSION = '0.1';
  27.  
  28.     var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
  29.  
  30.     var isArrayLike = function(collection) {
  31.         var length = collection.length;
  32.         return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
  33.     };
  34.  
  35.     _.each = function(obj, callback) {
  36.         var length, i = 0;
  37.  
  38.         if (isArrayLike(obj)) {
  39.             length = obj.length;
  40.             for (; i < length; i++) {
  41.                 if (callback.call(obj[i], obj[i], i) === false) {
  42.                     break;
  43.                 }
  44.             }
  45.         } else {
  46.             for (i in obj) {
  47.                 if (callback.call(obj[i], obj[i], i) === false) {
  48.                     break;
  49.                 }
  50.             }
  51.         }
  52.  
  53.         return obj;
  54.     }
  55.  
  56.     _.isFunction = function(obj) {
  57.         return typeof obj == 'function' || false;
  58.     };
  59.  
  60.     _.functions = function(obj) {
  61.         var names = [];
  62.         for (var key in obj) {
  63.             if (_.isFunction(obj[key])) names.push(key);
  64.         }
  65.         return names.sort();
  66.     };
  67.  
  68.     /**
  69.      * 在 _.mixin(_) 前添加自己定义的方法
  70.      */
  71.     _.reverse = function(string){
  72.         return string.split('').reverse().join('');
  73.     }
  74.  
  75.     _.mixin = function(obj) {
  76.         _.each(_.functions(obj), function(name) {
  77.             var func = _[name] = obj[name];
  78.             _.prototype[name] = function() {
  79.                 var args = [this._wrapped];
  80.  
  81.                 push.apply(args, arguments);
  82.  
  83.                 return func.apply(_, args);
  84.             };
  85.         });
  86.         return _;
  87.     };
  88.  
  89.     _.mixin(_);
  90.  
  91. })()

相关链接

underscore 系列

underscore 系列目录地址：https://github.com/mqyqingfeng/Blog。

underscore 系列预计写八篇左右，重点介绍 underscore 中的代码架构、链式调用、内部函数、模板引擎等内容，旨在帮助大家阅读源码，以及写出自己的 undercore。

如果有错误或者不严谨的地方，请务必给予指正，十分感谢。如果喜欢或者有所启发，欢迎star，对作者也是一种鼓励。