underscore源码解析（集合）

underscore就是一些函数的集合,大概分为6部分,分别是基础函数,集合,数组,函数,对象,实用功能.
    
在实现每一个功能的时候,基本上先自己实现,再对比。

(function(){

}.call(this));
基本框架长这样，就一个函数的自调用，用window作为调用对象，防止污染全局。

//把window对象先存起来备用吧。
var root = this;
//弄个window的属性_；
var previousUnderscore = root._;
//存一些原型
var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
//存一些原型的方法
var
    push             = ArrayProto.push,
    slice            = ArrayProto.slice,
    toString         = ObjProto.toString,
    hasOwnProperty   = ObjProto.hasOwnProperty;

var
    nativeIsArray      = Array.isArray,
    nativeKeys         = Object.keys,
    nativeBind         = FuncProto.bind,
    nativeCreate       = Object.create;
//弄个备用的构造函数
var Ctor = function(){};

//构造函数_，obj是_实例的话，直接返回obj.若是直接调用构造函数而不是通过new操作符的话，会调用第二个if.执行new _(obj).
//另外，这样的话obj就不是实例了，所以弄个实例属性_wrapped把obj存起来备用。
var _ = function(obj) {
    if (obj instanceof _) return obj;
    if (!(this instanceof _)) return new _(obj);
    this._wrapped = obj;
};
//这个是什么nodejs接口的，不懂。过了，嘿嘿

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

//这个是关于函数优化的，参数函数，调用EC，参数数量。
//只传了一个参数的话，context==null.这里应该是可以用context === void 0或者context==null，一个意思。直接返回传入的函数
//没传第三个参数的话，默认就是传三个参数给调用的函数，一般是用在forEach,filter这些数组方法，function(element,index,array);
//第三个参数是1或2的话，感觉没什么特别的，直接调用吧.是4的话就是reduce函数之类的。
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 2: return function(value, other) {
            return func.call(context, value, other);
        };
        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);
    };
};

//没传参数的话，直接返回一个函数，设置a,调用这个函数a,返回传给a的参数
//value是函数的话，直接调用上面的函数优化公式，
//对象的话，返回是否对象匹配的函数。
//返回一个property函数，这个函数调用传一个对象，value是键，返回值

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

_.identity = function(value) {
    return value;
};
_.property = function(key) {
    return function(obj) {
        return obj == null ? void 0 : obj[key];
    };
};
//源码中没有用到。返回一个迭代函数吧。
_.iteratee = function(value, context) {
    return cb(value, context, Infinity);
};
//创建一个对象合并器.keyfunc是一个对象键数组函数，返回对象所有键。
//undefinedOnly么是定义是不是只有往目标对象上添加属性而不管属性是否存在。一般为
//true。也就是当对象不存在这个属性的时候才添加。
//当返回的函数只有一个参数时或者直接调用，直接返回那个参数。
//否则把对象的参数一个个遍历出来，添加到新对象，再返回新对象

//放个参考的
//https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/assign

var createAssigner = function(keysFunc, undefinedOnly) {
    return function(obj) {
        var length = arguments.length;
        if (length < 2 || obj == null) return obj;
        for (var index = 1; index < length; index++) {
            var source = arguments[index],
                keys = keysFunc(source),
                l = keys.length;
            for (var i = 0; i < l; i++) {
                var key = keys[i];
                if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];
            }
        }
        return obj;
    };
};

//创建一个对象，原型是参数prototype
//参数不是对象的话，直接返回
//有原生的Object.create方法的话直接用
//利用Ctor构造函数创建对象原型。
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;
};


//数组索引的最大值
var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;

//是不是类数组，包括原生数组和nodelist类型
var isArrayLike = function(collection) {
    var length = collection && collection.length;
    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
};

//前面一些基础函数写完了。写正式的了。首先集合方法。


//对数组和对象的键集合进行迭代遍历.每个key调用函数，返回原来的obj

_.each = _.forEach = function(obj, iteratee, context) {
    //iteratee默认3个参数
    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;
};

//每个key调用函数，返回调用后集合数组

_.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;
};
//参数一大堆先不看了。黑
function createReduce(dir) {

    function iterator(obj, iteratee, memo, keys, index, length) {
        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) {
        iteratee = optimizeCb(iteratee, context, 4);
        var keys = !isArrayLike(obj) && _.keys(obj),
            length = (keys || obj).length,
            index = dir > 0 ? 0 : length - 1;
            if (arguments.length < 3) {
            memo = obj[keys ? keys[index] : index];
            index += dir;
        }
        return iterator(obj, iteratee, memo, keys, index, length);
    };
}
_.reduce = _.foldl = _.inject = createReduce(1);
_.reduceRight = _.foldr = createReduce(-1);


//predicate为一个函数，遍历数组，若return true直接返回。里面用到一个 _.findIndex函数，先研究下。研究在下面。
//_.findKey也差不多。最终函数返回obj[key];

_.find = _.detect = function(obj, predicate, context) {
    var key;
    if (isArrayLike(obj)) {
        key = _.findIndex(obj, predicate, context);
    } else {
        key = _.findKey(obj, predicate, context);
    }
    if (key !== void 0 && key !== -1) return obj[key];
};
//这个函数就是index搜索器，dir表示正者搜还是反着搜，搜到predicate函数返回的是ture的时候就把索引返回的，都没搜到就返回-1；
function createIndexFinder(dir) {
    return function(array, predicate, context) {
        predicate = cb(predicate, context);
        var length = array != null && array.length;
        var index = dir > 0 ? 0 : length - 1;
        for (; index >= 0 && index < length; index += dir) {
            if (predicate(array[index], index, array)) return index;
        }
        return -1;
    };
}

_.findIndex = createIndexFinder(1);
//和前面那个差不多，不过返回键名
_.findKey = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var keys = _.keys(obj), key;
    for (var i = 0, length = keys.length; i < length; i++) {
        key = keys[i];
        if (predicate(obj[key], key, obj)) return key;
    }
};

//把predicate返回为true的堆到一个新数组，再返回这个新数组
_.filter = _.select = function(obj, predicate, context) {
    var results = [];
    predicate = cb(predicate, context);
    _.each(obj, function(value, index, list) {
        if (predicate(value, index, list)) results.push(value);
    });
    return results;
};


//扩展自己，利用attrs类型的json，调用传入一个对象
_.matcher = _.matches = function(attrs) {
    attrs = _.extendOwn({}, attrs);
    return function(obj) {
        return _.isMatch(obj, attrs);
    };
};

//传对象和attrs，attrs类似{"a":1,"b":2}这种json的东西，若json类似的存在于obj中，则返回true，否则false；
_.isMatch = function(object, attrs) {
    var keys = _.keys(attrs), length = keys.length;
    if (object == null) return !length;
    var obj = Object(object);
    for (var i = 0; i < length; i++) {
        var key = keys[i];
        if (attrs[key] !== obj[key] || !(key in obj)) return false;
    }
    return true;
};
//遍历obj中的每一个值，返回一个数组，这个数组包含properties所列出的属性的所有的键值对。
//这里的obj是类[{},{},{}]的东西
_.where = function(obj, attrs) {
    return _.filter(obj, _.matcher(attrs));
};

//全部obj的元素分别调用predicate,有一个返回值是false,整个返回false
//否则返回true
_.every = _.all = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length;
    for (var index = 0; index < length; index++) {
        var currentKey = keys ? keys[index] : index;
        if (!predicate(obj[currentKey], currentKey, obj)) return false;
    }
    return true;
};


//全部obj的元素分别调用predicate,有一个返回值是true,整个返回false
//否则返回false
_.some = _.any = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length;
    for (var index = 0; index < length; index++) {
        var currentKey = keys ? keys[index] : index;
        if (predicate(obj[currentKey], currentKey, obj)) return true;
    }
    return false;
};
//检查obj是否包含target,就是indexOf方法的调用。
_.contains = _.includes = _.include = function(obj, target, fromIndex) {
    if (!isArrayLike(obj)) obj = _.values(obj);
    return _.indexOf(obj, target, typeof fromIndex == 'number' && fromIndex) >= 0;
};


//对每个obj元素调用method，注意method方法的获取，例子用了[]['sort']，获取到sort函数引用
//args,是传给method的参数，可选。
_.invoke = function(obj, method) {
    var args = slice.call(arguments, 2);
    var isFunc = _.isFunction(method);
    return _.map(obj, function(value) {
        var func = isFunc ? method : value[method];
        return func == null ? func : func.apply(value, args);
    });
};
_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');


//传key，获得值组成的数组。
_.pluck = function(obj, key) {
    return _.map(obj, _.property(key));
};
var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
_.pluck(stooges, 'name');
//结果["moe", "larry", "curly"]


//普通的数组且没有传iteratee的情况下，直接用交换机的方式比较最大值
//传了迭代函数的话，一般obj是[{a:1},{a:2},{a:3}],迭代函数把各个对象的相应键的值取出来比较。再返回最大值
_.max = function(obj, iteratee, context) {
    var result = -Infinity, lastComputed = -Infinity,
        value, computed;
    if (iteratee == null && obj != null) {
        obj = isArrayLike(obj) ? obj : _.values(obj);
        for (var i = 0, length = obj.length; i < length; i++) {
            value = obj[i];
            if (value > result) {
                result = value;
            }
        }
    } else {
        iteratee = cb(iteratee, context);
        _.each(obj, function(value, index, list) {
            computed = iteratee(value, index, list);
            if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
                result = value;
                lastComputed = computed;
            }
        });
    }
    return result;
};

//用 Fisher-Yates shuffle算法，产生随机排序数组
//https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
_.shuffle = function(obj) {
    var set = isArrayLike(obj) ? obj : _.values(obj);
    var length = set.length;
    var shuffled = Array(length);
    for (var index = 0, rand; index < length; index++) {
        rand = _.random(0, index);
        //这里用交换机，rand<index的时候，把shuffled【rand】索引的值放到shuffled【index】索引上
        if (rand !== index) shuffled[index] = shuffled[rand];
        shuffled[rand] = set[index];
    }
    return shuffled;
};

//guard默认是1,n==null的时候，默认随机返回一个obj数组元素
//n有值的时候，返回n个元素
_.sample = function(obj, n, guard) {
    if (n == null || guard) {
        if (!isArrayLike(obj)) obj = _.values(obj);
        return obj[_.random(obj.length - 1)];
    }
    return _.shuffle(obj).slice(0, Math.max(0, n));
};

//一般用来转换nodelist为真正的数组，可以调用原生的数组方法。
_.toArray = function(obj) {
    if (!obj) return [];
    if (_.isArray(obj)) return slice.call(obj);
    if (isArrayLike(obj)) return _.map(obj, _.identity);
    return _.values(obj);
};

//数组的长度或者对象键集合的长度。
_.size = function(obj) {
    if (obj == null) return 0;
    return isArrayLike(obj) ? obj.length : _.keys(obj).length;
};
//obj每个元素分别调用predicate,返回true的扔到pass数组，false的扔到fail数组
_.partition = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var pass = [], fail = [];
    _.each(obj, function(value, key, obj) {
        (predicate(value, key, obj) ? pass : fail).push(value);
    });
    return [pass, fail];
};
集合的函数差不多就这些，其实还有4个函数，觉得用不太到还挺难就不写了，哈哈哈哈哈