var restArgs = function(func) {
    startIndex = func.length - 1;
    return function() {
      var rest = Array(1);
      rest[0] = arguments[startIndex];
      var args = Array(arguments.length);
      for (index = 0; index < startIndex; index++) {
        args[index] = arguments[index];
      }
      args[startIndex] = rest;
      return func.apply(this, args);
    };
  };

等同于：

  var restArgs = function(func) {
    return function() {
      return func.apply(this, arguments);
    };
  };

作者將5行代碼擴展到21行，其實就是為了一個 startIndex 而已。

  var baseCreate = function(prototype) {
    if (!_.isObject(prototype)) return {};
    if (nativeCreate) return nativeCreate(prototype);
    Ctor.prototype = prototype;
    var result = new Ctor;
    Ctor.prototype = null;
    return result;
  };

baseCreate 用于創建一個干凈且只存在具有想要其具有 prototype 的函數，第一個判斷是否具有 prototype 參數，第二個判斷運用 Object.create 創建，余下則是自己運用 Ctor 這個空函數創建，沒什么可細說的。

  var property = function(key) {
    return function(obj) {
      return obj == null ? void 0 : obj[key];
    };
  };

property 用于獲取 obj 的 key 值，通過 property（） 設置 key ，重點是設置兩個字，有 key 則以沒有則創建之。

  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;

設置 一個最大值 MAX_ARRAY_INDEX，Math.pow(2, 53) - 1 意為2的53次冪等于9007199254740991，Math 的相關函數參考 Math，其實我一直覺得 MAX_ARRAY_INDEX 并不用設置這么大的值，Math.pow(2, 16) 就足以。

  var getLength = property("length");

設置 obj 的 key 值并生成函數，等同于：

  var getLength = function(obj) {
         return obj == null ? void 0 : obj["length"];
    };

  var isArrayLike = function(collection) {
    var length = getLength(collection);
    return typeof length == "number" && length >= 0 && length <= MAX_ARRAY_INDEX;
  };

isArrayLike，使 Obj 具有 length 屬性且有值則返回 true，否則返回 false，這是一個判斷函數。

  _.each = _.forEach = function(obj, iteratee, context) {
    iteratee = optimizeCb(iteratee, context);
    var i, length;
    if (isArrayLike(obj)) {
      for (i = 0, length = obj.length; i < length; i++) {
        iteratee(obj[i], i, obj);
      }
    } else {
      var keys = _.keys(obj);
      for (i = 0, length = keys.length; i < length; i++) {
        iteratee(obj[keys[i]], keys[i], obj);
      }
    }
    return obj;
  };

我一直以為 JAVASCRIPT 最精華的就是回調的執行方式，雖然互聯網上一些文章總在說回調毀了一切，人云亦云等等，但是回調支撐起了所有的框架，而且回調很優雅用的好可以很舒服，回調不是毀了一切只是因為某些人不恰當的設置回調毀了他自己的代碼。在 _.forEach 中 iteratee 即回調函數，其中運用了 optimizeCb 優化回調，然后是一個常規判斷，這里為什么用 isArrayLike(obj) 而不是 isArray(obj) 來判斷是不是數組呢，留下一個思考問題。

  _.map = _.collect = function(obj, iteratee, context) {
    iteratee = cb(iteratee, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length,
        results = Array(length);
    for (var index = 0; index < length; index++) {
      var currentKey = keys ? keys[index] : index;
      results[index] = iteratee(obj[currentKey], currentKey, obj);
    }
    return results;
  };

封裝 map 函數，沒什么好說的，參考 Map、Map.prototype、WeakMap 用于知識儲備，至于作者的 _.map 更多的是根據一定的條件遍歷 obj 中的元素，與 _.forEach 的更大區別是 _.forEach 不會對傳入的 obj 做改動直接 return obj，而 _.map 會 return results，return results 是每個 iteratee 回調的集合。

  var createReduce = function(dir) {
    var reducer = function(obj, iteratee, memo, initial) {
      var keys = !isArrayLike(obj) && _.keys(obj),
          length = (keys || obj).length,
          index = dir > 0 ? 0 : length - 1;
      if (!initial) {
        memo = obj[keys ? keys[index] : index];
        index += dir;
      }
      for (; index >= 0 && index < length; index += dir) {
        var currentKey = keys ? keys[index] : index;
        memo = iteratee(memo, obj[currentKey], currentKey, obj);
      }
      return memo;
    };
    return function(obj, iteratee, memo, context) {
      var initial = arguments.length >= 3;
      return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);
    };
  };

createReduce，創建 reduce。關于 reduce 的介紹可見 reduce 方法 (Array) (JavaScript)：https://msdn.microsoft.com/library/ff679975(v=vs.94).aspx 和 array-reduce，作者這里的 reduce 肯定不是這樣，但既然命名為 createReduce，想來也脫不了太多關系。函數中 reducer 首先定義 keys，其值為 obj 的 key 集合或者 false，后面幾個語句里都有對于 keys 的三元運算，目的就是排除 obj 不為 Object 的可能性。接下來判斷傳入 initial，如果傳入 initial 為 false 則默認 memo 值為 keys[keys.length-1] || 0，之后是 for 循環遍歷回調，并返回最后一個回調值。跳出 reducer 函數 return function 的恰恰是引用 reducer 函數的外部接口，于是所有一切都連貫上了，包括 initial 的定義是 arguments 長度大于等于3等等。
我們再重新過一遍代碼，在最外部 return 的時候判斷 initial，實際上就是再確定是否傳入了 memo 和 context，當然最主要的就是 memo，以此來確定在內部 reducer 的時候是否具有初始值。在這里我覺得作者應該對 memo 進行類型判斷的，如果是 Number 或者 String 還說的過去，但是如果傳入 memo 是 Object 就有點說不過去了，會出錯的。比如：

    _.reduce([1, 2, 3], function(memo, num){ return memo + num; });
    6
    _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 1);
    7
    _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, "1");
    "1123"
    _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, []);
    "123"
    _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, [1,2]);
    "1,2123"
    _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, {a:1});
    "[object Object]123"

  _.reduce = _.foldl = _.inject = createReduce(1);

這里就是用 createReduce 包裝好的 _.reduce，不解釋。

  _.reduceRight = _.foldr = createReduce(-1);

這里就是用 createReduce 包裝好的 _.reduceRight，與 _.reduce 計算順序相反即從右面向左面開始。