var func = function(){ return JSON.stringify(arguments) + ": " + this.name };
   func = _.bind(func, {name: "moe"}, "hi");
   func();
   func = _.bind(func, {name: "moe2"}, "hi2");
   func();

輸出結果：

   "{"0":"hi"}: moe"
   "{"0":"hi","1":"hi2"}: moe"

可能有些不明就里的同學會問這是為什么啊，怎么 this.name 的值沒有變化呢。實際上我們第一個 _.bind 是正常的函數(shù)綁定，而第二個 func = _.bind(func, {name: "moe2"}, "hi2"); 是將上一個 _.bind 作為了 Function 參數(shù)傳入到了新的 _.bind 中，而本來的函數(shù) func 作為第一個 _.bind 的 func 參數(shù)一直傳遞到第二個 _.bind 中，但是中間的 this.name 卻被綁定到了第一個 _.bind 上面而不是第一個 _.bind 中的 func 上。有一點繞口。用個代碼介紹下，第二個 _.bind 的情況是這樣子的：

 func = _.bind(function(
       function(greeting){
           return greeting + ": " + this.name;
      },
       context,
       args
   ) {
        var length = arguments.length - 2;
        args = Array(length);
        for (var index = 0; index < length; index++) {
            args[index] = arguments[index + startIndex];
        }
        if (!_.isFunction(func)) throw new TypeError("Bind must be called on a function");
        var bound = function(args_2){
            args_2 = Array(arguments.length);
            for (var index = 0; index < arguments.length; index++) {
                args_2[index] = arguments[index];
            }
            (function(sourceFunc, boundFunc, context, callingContext, args) {
                if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
                var self = baseCreate(sourceFunc.prototype);
                var result = sourceFunc.apply(self, args);
                if (_.isObject(result)) return result;
                return self;
          })(func, bound, context, this, args.concat(args_2));
        };
        return bound;
    },
       {name: "moe2"},
       "hi2"
   );

所以 _.bind 一定要遵循正確的用法，不然真的出錯了可能調(diào)試都不好發(fā)現(xiàn)問題，多層回調(diào)嵌套的時候一層套一層，很麻煩。

  _.partial = restArgs(function(func, boundArgs) {
    var placeholder = _.partial.placeholder;
    var bound = function() {
      var position = 0, length = boundArgs.length;
      var args = Array(length);
      for (var i = 0; i < length; i++) {
        args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];
      }
      while (position < arguments.length) args.push(arguments[position++]);
      return executeBound(func, bound, this, this, args);
    };
    return bound;
  });

_.partial 函數(shù)的核心思想與 _.bind 相同，都是為了解決 this 指向的問題，區(qū)別在于 _.partial 不需要對 this 上的值做什么處理。用法上我覺得 _.partial 看上去更怪異一些，也許用來做一些特定的計算可能更合適些。

  _.partial.placeholder = _;

設置 _.partial.placeholder 為 _。

  _.bindAll = restArgs(function(obj, keys) {
    keys = flatten(keys, false, false);
    var index = keys.length;
    if (index < 1) throw new Error("bindAll must be passed function names");
    while (index--) {
      var key = keys[index];
      obj[key] = _.bind(obj[key], obj);
    }
  });

這里我們看到 _.bindAll 函數(shù)官網(wǎng)的示例就有點糊涂了：

   var buttonView = {
     label  : "underscore",
     onClick: function(){ console.log("clicked: " + this.label); },
     onHover: function(){ console.log("hovering: " + this.label); }
   };
   _.bindAll(buttonView, "onClick", "onHover");
   buttonView.onClick（);
   clicked: underscore

我們當然知道結果是 clicked: underscore，那么執(zhí)行 _.bindAll(buttonView, "onClick", "onHover"); 的意義在哪呢，所以說這又是官網(wǎng)坑人的地方了，_.bindAll 的本意是將其傳入的第二個及以后的參數(shù)放到一個共同的上下文環(huán)境里面執(zhí)行，從而達到 this 指向其第一個參數(shù)的本身的目的，而官網(wǎng)的示例為方法調(diào)用模式，this 指向已經(jīng)是 Object 本身了所以看不到變化，但是我們在瀏覽器控制臺查看的話應該能知道 this 上多了 [[TargetFunction]]: function ()、[[BoundThis]]: Object、[[BoundArgs]]: Array[0] 三個參數(shù)并且 [[BoundThis]] 恰好是 Object。閑來無事這好看到有人也寫了這個問題并舉證了一個示例，詳見 Understanding bind and bindAll in Backbone.js。我 cope 一下：

   function Developer(skill) {
     this.skill = skill;
     this.says = function(){
       console.log(this.skill + " rocks!");
     }
   }
   var john = new Developer("Ruby");
   _.bindAll(john, "says");
   var func = john.says;
   func(); //Ruby rocks!

這個函數(shù)調(diào)用模式的示例正好答疑了 this 指向已經(jīng)被改變的這個問題。

  _.memoize = function(func, hasher) {
    var memoize = function(key) {
      var cache = memoize.cache;
      var address = "" + (hasher ? hasher.apply(this, arguments) : key);
      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);
      return cache[address];
    };
    memoize.cache = {};
    return memoize;
  };

_.memoize 函數(shù)更像是一個可以緩存第一次執(zhí)行結果的遞歸函數(shù)，我們從源碼中可以看到 memoize.cache = {}; 就是用來存儲計算結果的容器，這里面比較有意思的是 hasher 這個參數(shù)，官網(wǎng)釋義： hashFunction，實際上就是通過 hashFunction 對傳入的 key 值進行處理然后放到 memoize.cache = {}; 中，至于怎么處理 hash 也好、md5 也好、或者什么其他的計算加密真值判斷增加對象等等都可以通過 hasher 這個傳入的回調(diào)進行擴展。

————————— 疲憊的分割線 ———————————
這幾天北京總在下雨，身體特別的疲憊，狀態(tài)也不怎么好，所以今天才開始繼續(xù)更新。
————————— END ———————————

  _.delay = restArgs(function(func, wait, args) {
    return setTimeout(function() {
      return func.apply(null, args);
    }, wait);
  });

_.delay 函數(shù)用于處理定時器相關函數(shù)，原理是通過 setTimeout 進行二次封裝，比較關鍵的就是 args 參數(shù)通過 restArgs 函數(shù)處理為一個數(shù)組，方便了下一步的 func.apply(null, args); 傳值。

  _.defer = _.partial(_.delay, _, 1);

_.defer 這個函數(shù)我們首先可以看到內(nèi)部應用了 _.partial 并且中間傳入?yún)?shù) _，這意味著當 _.defer 執(zhí)行的時候傳入的參數(shù)會被補全到 _.partial 內(nèi)部 bound 中的 args[0] 位置，而此時 args 的值為 [func, 1]并將它傳給 _.delay 函數(shù)，即 _.delay.apply(null, args);，用著這種方式曲線的設置 setTimeout 函數(shù)的 wait = 1，目的就是處理代碼復用問題，不然的話完全可以改裝一下 _.delay 函數(shù)可以更簡單的實現(xiàn)這一功能。

  _.throttle = function(func, wait, options) {
    var timeout, context, args, result;
    var previous = 0;
    if (!options) options = {};
    var later = function() {
      previous = options.leading === false ? 0 : _.now();
      timeout = null;
      result = func.apply(context, args);
      if (!timeout) context = args = null;
    };
    var throttled = function() {
      var now = _.now();
      if (!previous && options.leading === false) previous = now;
      var remaining = wait - (now - previous);
      context = this;
      args = arguments;
      if (remaining <= 0 || remaining > wait) {
        if (timeout) {
          clearTimeout(timeout);
          timeout = null;
        }
        previous = now;
        result = func.apply(context, args);
        if (!timeout) context = args = null;
      } else if (!timeout && options.trailing !== false) {
        timeout = setTimeout(later, remaining);
      }
      return result;
    };
    throttled.cancel = function() {
      clearTimeout(timeout);
      previous = 0;
      timeout = context = args = null;
    };
    return throttled;
  };

_.throttle 函數(shù)可以限制和控制其參數(shù) func 的執(zhí)行次數(shù)和執(zhí)行時間，思想就是通過 wait、now、previous 和 remaining 進行判斷然后分別執(zhí)行相應的策略。

wait：使用 _.throttle 函數(shù)時傳入的時間標識，在每個 wait 毫秒時間段內(nèi)最多且一定調(diào)用一次該函數(shù)。

now：使用 _.now() 函數(shù)獲取當前時間戳。

previous：用來緩存函數(shù)執(zhí)行時的時間戳，用于后面與下一次執(zhí)行時的時間戳進行相關判斷。

remaining：緩存 wait - (now - previous) 的差值。

我們在看官網(wǎng)介紹可以知道 _.throttle 傳遞的 options 分四種情況（默認是 {leading:false,trailing:false}）：

{leading:true,trailing:true}：從實例化 _.throttle 的時間開始到執(zhí)行實例化的函數(shù)的時間為止，中間的差值定義為 now - previous，進而得出設定的時間 wait 與 now - previous 的差值 remaining，從而決定怎么執(zhí)行函數(shù)。參考 世紀之光 的很有趣的說法，就是第一次可以立即執(zhí)行，第二次開始將在每 wait 時間內(nèi)只允許執(zhí)行一次，為什么會第一次立即執(zhí)行呢，因為大家設置的 wait 一般都不會太大，所以頁面加載過程中一般已經(jīng)執(zhí)行了 _.throttle 的實例化，也就是說其 remaining <= 0，而后面如果一直執(zhí)行函數(shù)，那么就開始 0 < remaining <= wait 模式了，

{leading:false,trailing:false}：這種情況下比較有意思的是 previous 這個參數(shù)，在實例化 _.throttle 的時候，previous = 0，利用了 !0 === true 的特性使 _.throttle 內(nèi)部并沒有執(zhí)行回調(diào)函數(shù) func，所以第一次函數(shù)調(diào)用失敗，在第二次開始 previous = now （now 為第一次調(diào)用的時間戳），所以它也分為兩種情況：

{leading:true,trailing:false}：這種情況下是沒有 setTimeout 函數(shù)的，因為 leading:true，所以 previous 初始化為 0，意味著第一次執(zhí)行函數(shù)會立即執(zhí)行，兒后面就要遵循 remaining <= 0 || remaining > wait 才能執(zhí)行，也就是說只有第一執(zhí)行完畢后的時間超過了 wait 才能繼續(xù)調(diào)用函數(shù)才能執(zhí)行（調(diào)用是重點），以此類推。

{leading:false,trailing:true}：這種情況由于 leading:false，所以每次 previous 都等于當前調(diào)用函數(shù)時的時間戳，所以完美的不存在 remaining <= 0 || remaining > wait 的情況，由此只能通過 setTimeout 執(zhí)行回調(diào)，所以遵循通過 setTimeout 函數(shù)設定時間為 remaining 毫秒后執(zhí)行 _.throttle 函數(shù)的回調(diào)函數(shù) func，用以達到在規(guī)定時間 wait 毫秒時執(zhí)行函數(shù)的目的，并且規(guī)定 wait 時間內(nèi)只執(zhí)行一次函數(shù)。

其實總結一下就是大概一下兩種都存在或者只存在其一的情況：

remaining <= 0：立即執(zhí)行 _.throttle 函數(shù)的回調(diào)函數(shù) func。

0 < remaining <= wait：通過 setTimeout 函數(shù)設定時間為 remaining 毫秒后執(zhí)行 _.throttle 函數(shù)的回調(diào)函數(shù) func，用以達到在規(guī)定時間 wait 毫秒時執(zhí)行函數(shù)的目的，并且規(guī)定 wait 時間內(nèi)只執(zhí)行一次函數(shù)。

 _.debounce = function(func, wait, immediate) {
   var timeout, result;
   var later = function(context, args) {
     timeout = null;
     if (args) result = func.apply(context, args);
   };
   var debounced = restArgs(function(args) {
     if (timeout) clearTimeout(timeout);
     if (immediate) {
       var callNow = !timeout;
       timeout = setTimeout(later, wait);
       if (callNow) result = func.apply(this, args);
     } else {
       timeout = _.delay(later, wait, this, args);
     }
     return result;
   });
   debounced.cancel = function() {
     clearTimeout(timeout);
     timeout = null;
   };
   return debounced;
 };

_.debounce 更像是 _.delay 的方言版，當 immediate = true 的時候通過 var callNow = !timeout = false 達到立即執(zhí)行回調(diào)函數(shù) func 的目的，并用 later 函數(shù)限制 規(guī)定 wait 時間內(nèi)不允許在調(diào)用函數(shù)（later 函數(shù)內(nèi)部 context = args = underfind，其實我們知道 var later = function(context, args) 這個條件是為 _.delay(later, wait, this, args) 準備的）。

  _.wrap = function(func, wrapper) {
    return _.partial(wrapper, func);
  };

_.wrap 的兩個參數(shù)理論上都要求是 Function，我們已經(jīng)知道 _.partial 是用來在 this 上下功夫的，雖然這里和 this 也沒什么太大關系，之所以這里應用了 _.partial 是為了讓 func 作為 wrapper 的第一個參數(shù)執(zhí)行，并且通過 executeBound 函數(shù)對函數(shù)調(diào)用模式和方法調(diào)用模式做處理。

  _.negate = function(predicate) {
    return function() {
      return !predicate.apply(this, arguments);
    };
  };

_.negate 用來做真值判斷。

  _.compose = function() {
    var args = arguments;
    var start = args.length - 1;
    return function() {
      var i = start;
      var result = args[start].apply(this, arguments);
      while (i--) result = args[i].call(this, result);
      return result;
    };
  };

_.compose 用于將函數(shù)執(zhí)行結果進行傳遞，需要注意的是 var args = arguments; 中的 arguments 和 args[start].apply(this, arguments); 中的 arguments 并不相同就可以了。這個涉及到函數(shù)的執(zhí)行，當每一個函數(shù)執(zhí)行的時候都會形成一個內(nèi)部的上下文執(zhí)行環(huán)境（傳說叫 ExecutionContext，這個我還沒有考證過），在構建環(huán)境的同時生成 arguments 變量和作用域鏈表等等，這里不像敘述了。

  _.after = function(times, func) {
    return function() {
      if (--times < 1) {
        return func.apply(this, arguments);
      }
    };
  };

_.after 接受兩個參數(shù)，Number 參數(shù)用來限定 _.after 實例化函數(shù)的執(zhí)行次數(shù)，說白了就是只有當?shù)?Number 次執(zhí)行實例化函數(shù)的時候才會繼續(xù)執(zhí)行 func 回調(diào)，這個用來處理遍歷 _.each 時某些情況很有用。

  _.before = function(times, func) {
    var memo;
    return function() {
      if (--times > 0) {
        memo = func.apply(this, arguments);
      }
      if (times <= 1) func = null;
      return memo;
    };
  };

_.before，與 _.after 相反，只在規(guī)定 Number 參數(shù)的次數(shù)內(nèi)以此執(zhí)行 _.before，超過之后結束。

  _.once = _.partial(_.before, 2);

_.once 創(chuàng)建一個只能調(diào)用一次的函數(shù)。到這里關于函數(shù)相關的源碼就結束了，說心里話很多地方看得懂不一定說的懂，說的懂也不一定用的懂，就拿這個 _.once 來講，它只用了 _.partial 和 _.before 來做文章，用 _.before 限定只能執(zhí)行一次還好理解，那么為什么一定要用 _.partial 坐下處理呢，其目的真的只是為了讓 2 作為 _.before 的第一個參數(shù)進行傳遞過去并將 _.once 的傳參作為 arguments[1+] 傳入么，更深一層考慮，_.partial 函數(shù)是不是有處理過 _.once 傳遞過來的函數(shù)的作用域鏈和 this 相關的情況呢。

  _.restArgs = restArgs;

_.restArgs 將 restArgs 函數(shù)綁定到 _ 對象上。