摘要：他指示了一個(gè)對(duì)象的屬性，返回的將用來(lái)獲得該屬性對(duì)應(yīng)的值在上面的分析中，我們知道，當(dāng)傳入的是一個(gè)函數(shù)時(shí)，還要經(jīng)過一個(gè)叫的內(nèi)置函數(shù)才能獲得最終的所以此處的必然是優(yōu)化回調(diào)的作用了。

對(duì)的，讓你所見，又開始造輪子了。哈哈，造輪子我們是認(rèn)真的~

源碼閱讀是必須的，Underscore是因?yàn)閯倓倢W(xué)習(xí)整理了一波函數(shù)式編程，加上自己曾經(jīng)沒有太多閱讀源碼的經(jīng)驗(yàn)，先拿Underscore練練手，跟著前輩們走一走，學(xué)一學(xué)。也相同時(shí)能夠夯實(shí)js基礎(chǔ)，從源碼中學(xué)習(xí)到更多的編碼技巧

Underscore源碼閱讀大致按照官方文檔來(lái)編寫.盡量的說明每一個(gè)函數(shù)的寫法，希望自己可以從中可以收獲大神的編碼功力。

github:Personal_Blog

窺探Underscore源碼系列-開篇

窺探Underscore源碼系列-工具

窺探Underscore源碼系列-集合

窺探Underscore源碼系列-數(shù)組

窺探Underscore源碼系列-函數(shù)

窺探Underscore源碼系列-對(duì)象

窺探Underscore源碼系列-感悟

Underscore源碼+注釋地址

(function(){}())

常規(guī)操作哈，跟jQuery一毛一樣，通過IIFE來(lái)包裹業(yè)務(wù)邏輯，目的簡(jiǎn)單：1、避免全局污染。2、保護(hù)隱私

  var root = typeof self == "object" && self.self === self && self ||
            typeof global == "object" && global.global === global && global ||
            this ||
            {};
  var previousUnderscore = root._;

通過global和self來(lái)判斷是node環(huán)境還是window環(huán)境，說白了，就是為了拿到全局變量。因?yàn)槲覀冃枰粋€(gè)全局的變量_,所以為了防止沖突，我們這里拿到root后，先暫存下之前的root._

  var ArrayProto = Array.prototype, ObjProto = Object.prototype;
  var SymbolProto = typeof Symbol !== "undefined" ? Symbol.prototype : null;

  var push = ArrayProto.push,
      slice = ArrayProto.slice,
      toString = ObjProto.toString,
      hasOwnProperty = ObjProto.hasOwnProperty;

  var nativeIsArray = Array.isArray,
      nativeKeys = Object.keys,
      nativeCreate = Object.create;

  var Ctor = function(){};

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

  if (typeof exports != "undefined" && !exports.nodeType) {
    if (typeof module != "undefined" && !module.nodeType && module.exports) {
      exports = module.exports = _;
    }
    exports._ = _;
  } else {
    root._ = _;
  }

  _.VERSION = "1.8.3";

由于Underscore本身依賴很多原生js的方法，所以這里為了避免原型鏈的查找性能消耗，Underscore通過局部變量來(lái)保存一些常用的對(duì)象和方法。既可以提升性能，減少對(duì)象成員訪問深度也可以減少代碼的冗長(zhǎng)。

下面的Ctor和_ 是為了面向?qū)ο蠖鴾?zhǔn)備的。

  var optimizeCb = function(func, context, argCount) {
    if (context === void 0) return func;
    switch (argCount == null ? 3 : argCount) {
      case 1: return function(value) {
        return func.call(context, value);
      };
      case 3: return function(value, index, collection) {
        return func.call(context, value, index, collection);
      };
      case 4: return function(accumulator, value, index, collection) {
        return func.call(context, accumulator, value, index, collection);
      };
    }
    return function() {
      return func.apply(context, arguments);
    };
  };

  var builtinIteratee;

  var cb = function(value, context, argCount) {
    if (_.iteratee !== builtinIteratee) return _.iteratee(value, context);
    if (value == null) return _.identity;
    if (_.isFunction(value)) return optimizeCb(value, context, argCount);
    if (_.isObject(value) && !_.isArray(value)) return _.matcher(value);
    return _.property(value);
  };

  _.iteratee = builtinIteratee = function(value, context) {
    return cb(value, context, Infinity);
  };

這里的迭代，我們需要理清楚一個(gè)概念，在Underscore中，我們需要改變那種命令式的編程方式，具體的可以看我之前寫的關(guān)于函數(shù)式編程的文章哈。

所以這里想說的就是關(guān)于遍歷迭代的東西。

var results = _.map([1,2,3],function(elem){
  return elem*2;
}); // => [2,4,6]

_.map = _.collect = function (obj, iteratee, context) {
    iteratee = cb(iteratee, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length,
        results = Array(length); // 定長(zhǎng)初始化數(shù)組
    for (var index = 0; index < length; index++) {
        var currentKey = keys ? keys[index] : index;
        results[index] = iteratee(obj[currentKey], currentKey, obj);
    }
    return results;
};

我們傳遞給的 _.map 的第二個(gè)參數(shù)就是一個(gè) iteratee，他可能是函數(shù)，對(duì)象，甚至是字符串。

value 為 null。則 iteratee 的行為只是返回當(dāng)前迭代元素自身

value 為一個(gè)函數(shù)。那么通過內(nèi)置函數(shù) optimizeCb 對(duì)其進(jìn)行優(yōu)化

value 為一個(gè)對(duì)象。那么返回的 iteratee（_.matcher）的目的是想要知道當(dāng)前被迭代元素是否匹配給定的這個(gè)對(duì)象

value 是字面量，如數(shù)字，字符串等。他指示了一個(gè)對(duì)象的屬性 key，返回的 iteratee（_.property）將用來(lái)獲得該屬性對(duì)應(yīng)的值

在上面的分析中，我們知道，當(dāng)傳入的 value 是一個(gè)函數(shù)時(shí)，value 還要經(jīng)過一個(gè)叫 optimizeCb 的內(nèi)置函數(shù)才能獲得最終的 iteratee：

var cb = function (value, context, argCount) {
  // ...
  if (_.isFunction(value)) return optimizeCb(value, context, argCount);
  // ...
};

所以此處的optimizeCb必然是優(yōu)化回調(diào)的作用了。

  // 優(yōu)化回調(diào)的函數(shù)，遍歷
  var optimizeCb = function(func, context, argCount) {
    // void 0 會(huì)返回真正的undefined 此處確保上下文的存在
    if (context === void 0) return func;
    switch (argCount == null ? 3 : argCount) {
      case 1: return function(value) {
        // argCount為0時(shí)候，迭代過程中，我們只需要這個(gè)value就可以了
        return func.call(context, value);
      };
      // The 2-parameter case has been omitted only because no current consumers
      //  3個(gè)參數(shù)(值,索引,被迭代集合對(duì)象).
      case 3: return function(value, index, collection) {
        return func.call(context, value, index, collection);
      };
      // 4個(gè)參數(shù)(累加器(比如reducer需要的), 值, 索引, 被迭代集合對(duì)象)
      case 4: return function(accumulator, value, index, collection) {
        return func.call(context, accumulator, value, index, collection);
      };
    }
    return function() {
      return func.apply(context, arguments);
    };
  };

整體的代碼非常清晰，待優(yōu)化的回調(diào)函數(shù)func，上下文context以及迭代回調(diào)需要的參數(shù)個(gè)數(shù)。

上面的這個(gè)優(yōu)化的回調(diào)涉及到不同地方使用的不同迭代。這里暫時(shí) 先放一放。等過了一遍源碼后，看到每一個(gè)用到迭代的地方，在回頭來(lái)看，就會(huì)明白很多。

在 ES6中，我們定義不定參方法的時(shí)候可以這么寫

let a = (b,...c)=>{
console.log(b,c);
}

但是在此之前，Underscore實(shí)現(xiàn)了自己的reset，使用如下：

  function a(a,b,c,d,e){
      console.log(a,b,c,d,e)
  }
  let aa = restArgs(a);//let aa = restArgs(a,4)
  aa(1,2,3,4,5,6,7,8,8)

看下restArgs的實(shí)現(xiàn)：

var restArgs = function(func, startIndex) {
    //未傳則取形參個(gè)數(shù)減一

    startIndex = startIndex == null ? func.length - 1 : +startIndex;

    return function() {
      //  多傳了幾個(gè)參數(shù)
      //length為多傳了幾個(gè)參數(shù)
      var length = Math.max(arguments.length - startIndex, 0),
          rest = Array(length),
          index = 0;
      for (; index < length; index++) {
        rest[index] = arguments[index + startIndex];
      }
      
      //優(yōu)化。注意rest參數(shù)總是最后一個(gè)參數(shù), 否則會(huì)有歧義
      switch (startIndex) {
        case 0: return func.call(this, rest);
        case 1: return func.call(this, arguments[0], rest);
        case 2: return func.call(this, arguments[0], arguments[1], rest);
      }
      //撇去常用的startIndex，這里循環(huán)
      //先拿到前面參數(shù)
      var args = Array(startIndex + 1);
      for (index = 0; index < startIndex; index++) {
        args[index] = arguments[index];
      }
      //拿到后面的數(shù)組
      args[startIndex] = rest;
      return func.apply(this, args);
    };
  };  

  var Ctor = function(){};
  
  // 定義了一個(gè)用于繼承的內(nèi)部方法
  var baseCreate = function(prototype) {
    if (!_.isObject(prototype)) return {};
    // nativeCreate = Object.create;
    if (nativeCreate) return nativeCreate(prototype);
    Ctor.prototype = prototype;
    var result = new Ctor;
    Ctor.prototype = null;
    return result;
  };

function Animal(name){
  this.name = name;
}
Animal.prototype.eat = function(){
  console.log(this.name,"鳥為食亡");
}
var dog = Object.create(Animal.prototype);
dog.name = "毛毛";
dog.eat();

的確在造造輪子，只是更想自己擼一遍優(yōu)秀代碼。