Underscore整体概述

1. 作用域

与其他第三方库一样，Underscore也通过立即执行函数来包裹自己的业务逻辑。

目的：

• 避免全局污染：所有库中的逻辑，库所定义和使用的变量全部被封装到了该函数的作用域中。
• 隐私保护：但凡在立即执行函数中声明的函数、变量等，除非是自己想暴露，否则绝无可能在外部获得。

(function(root){
  var _ = function(){
    
  }
  root._ = _
})(this)

2. _ 对象

underscore有下划线的意思，所以underscore通过一个下划线变量 _ 来标识自身。

注： _ 是一个函数对象，之后所有的api都会被挂载到这个对象上，例如_.map()

(funtion(root){
  var _ = function(obj){
   
  }
  _.map = function(){
    //balalala
  }
  // ......
  root._ = _
})(this)

3. _()

虽然Underscore推崇函数式编程，但也支持面向对象风格的函数调用，仅需要通过_()来包裹对象即可。
当我们进行如下调用时：_([1,2,3])会创建一个新的underscore对象实例（从而能够调用underscore提供的方法），并在this._wrapped中存储传入的数据。

var _ = function(obj){
  if(obj instanceof _){
     return obj
  }
  if(!(this instanceof _)){
     return new _(obj)
  }
  this._wrapped = obj
}

当使用面向对象的方式调用时，例如传入[1,2,3]，函数首先会判断是不是_的实例，如果是直接返回这个实例对象，如果不是则创建一个实例对象new _(obj)，然后将参数[1,2,3]赋值给_wrapped，以备后用。

4. mixin

• mixin(混入)模式是增加代码复用度的一个广泛的设计模式。
• _.mixin(obj)：为underscore对象混入obj具有的功能
• mixin主要实现了 _ 的原型对象的方法调用

源码如下：

_.mixin = function(obj) {
    _.each(_.functions(obj), function(name) {
        var func = obj[name];

        _.prototype[name] = function() {
            var args = [this._wrapped];
            push.apply(args, arguments);
            return result(this, func.apply( _ , args));
        }
    });
}
_.mixin(_)

最后一句是执行这个mixin函数，执行完后会将 _ 上挂载的方法都挂载到原型对象prototype上，以方便面向对象时的调用

5. 链式调用 _.chain()

• _.chain(obj)：为underscore对象的方法增加链式调用能力
• _.chain源码如下：

_.chain = function(obj){
  var instance = _(obj)
  instance._chain = true
  return instance
}

比较简单，就是拿到这个实例对象，赋了一个属性 _chain为true，再返回这个实例对象

• underscore还提供了一个帮助函数result，该函数将会判断方法调用结果，如果该方法的调用者被标识了需要链化，则链化当前的方法执行结果。
• 源码如下：

var chainResult = function(instance , obj){
  return instance._chain ? _(obj).chain() : obj ;  
}

---

============这是分割线============

---

接下来我们就看看，当调用_.unique([1,2,3,1])的时候怎么执行的
先附上源码：

(function(root){
  var _ = function(){}
  
  _.unique = function(arr,callback){
    var ret = [];
    var target, i = 0;
    for (; i < arr.length; i++) {
        var target = callback ? callback(arr[i]) : arr[i];
        if (ret.indexOf(target) === -1) {
            ret.push(target);
        }
    }
    return ret;
  }

  root._ = _
})(this)

代码就不解释了，比较简单，就是在 _ 对象上新建一个unique方法直接调用就行。

如果使用面向对象的调用方式呢？就需要这样写了 _([1,2,3,1]).chain().unique()
先附上源码：

(function(root){
  var push = Array.prototype.push;
  //面向对象调用时返回_的实例，然后将参数存储在_wrapped中
  var _ = function(obj) {
    if (obj instanceof _) {
        return obj;
    }
    if (!(this instanceof _)) {
        return new _(obj);
    }
    this._wrapped = obj;
  }
  //给_定义一个去重的函数
  _.unique = function(arr, callback) {
    var ret = [];
    var target, i = 0;
    for (; i < arr.length; i++) {
        var target = callback ? callback(arr[i]) : arr[i];
        if (ret.indexOf(target) === -1) {
            ret.push(target);
        }
    }
    return ret;
  }
   //定义一个遍历函数
  _.each = function(target, callback) {
    console.log(target)
    var key, i = 0;
    if (_.isArray(target)) {
        var length = target.length;
        for (; i < length; i++) {
            callback.call(target, target[i], i);
        }
    } else {
        for (key in target) {
            callback.call(target, key, target[key]);
        }
    }
  }
  //开启链接式的调用
  _.chain = function(obj) {
    var instance = _(obj);
    instance._chain = true;
    return instance;
  }

  //辅助函数    obj   数据结果
  var result = function(instance, obj) {
    //_(obj).chain() 会对传入的obj创建一个新的实例对象，返回出去
    return instance._chain ? _(obj).chain() : obj;
  }
  //获取_上所有绑定的函数
  _.functions = function(obj) {
    var result = [];
    var key;
    for (key in obj) {
        result.push(key);
    }
    return result;
  }
  //类型检测
  _.isArray = function(array) {
    return toString.call(array) === "[object Array]";
  }
  //将函数加载到
  _.mixin = function(obj) {
    _.each(_.functions(obj), function(name) {
        var func = obj[name];

        _.prototype[name] = function() {
            var args = [this._wrapped];
            push.apply(args, arguments);
            return result(this, func.apply(this, args));
        }
    });
}

root._ = _
})(this)

以上基本就是underscore的源码框架了。

1. 先解释_.mixin(_)

• 函数一开始就会调用这个函数，传入的参数就是我们自定义的参数，例如[1,2,3]，然后调用each方法，each方法传入两个参数，第一个参数_.functions(obj)，就是获取绑定在 _ 上面的所有函数，返回的是一个数组。
• 继续往里走，第二个参数回去调用数组中各个函数名，拿到这个函数。
• 继续，之后会给 _ 的prototype绑定函数，
  var args = [this._wrapped]就是获取我们传进来的参数[1,2,3,1]
  push.apply(args,arguments)如果后面调用方法时，还有参数，则合并push进args里。(如果不了解apply的可以看看我之前写的call apply bind的理解这篇文章)
• 最后调用result这个函数，第一个参数this就是当前的实例对象，第二个参数就是调用unique的方法。
• 最后返回的结果，是调用chain后的实例对象

2. _([1,2,3,1]).chain().unique()

• 首先_([1,2,3,1])会生成一个实例对象，instance
• 调用chain方法，给instance创建一个属性chain并且设置为true，表示可以链式调用
• 调用unique方法，此处的unique方法不是 _ 的方法，而是_.prototype的方法，也就是mixin中的函数。
• 最后返回result的结果，也就是执行unique方法后的实例对象。