underscore源码解析（array）

//数组的一些方法吧
//截取数组前几个元素，n就是前几个
_.initial = function(array, n, guard) {
    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
};
//默认返回数组的第一个元素，传了n的话就返回前n个元素
_.first = _.head = _.take = function(array, n, guard) {
    if (array == null) return void 0;
    if (n == null || guard) return array[0];
    return _.initial(array, array.length - n);
};
//默认返回数组的最后一个元素，传了n的话就返回最后n个元素
_.last = function(array, n, guard) {
    if (array == null) return void 0;
    if (n == null || guard) return array[array.length - 1];
    return _.rest(array, Math.max(0, array.length - n));
};
_.rest = _.tail = _.drop = function(array, n, guard) {
    return slice.call(array, n == null || guard ? 1 : n);
};
//把数组里面的假值去掉.返回一个没有假值的数组。
_.compact = function(array) {
    return _.filter(array, _.identity);
};



//看不太懂，递归太烂了。作用就是把数组扁平化，变成一个数组。
var flatten = function(input, shallow, strict, startIndex) {
    var output = [], idx = 0;
    for (var i = startIndex || 0, length = input && input.length; i < length; i++) {
        var value = input[i];
        if (isArrayLike(value) || _.isArguments(value)) {
    if (!shallow) value = flatten(value, shallow, strict);
        var j = 0, len = value.length;
        output.length += len;
    while (j < len) {
        output[idx++] = value[j++];
    }
    } else if (!strict) {
        output[idx++] = value;
    }
}
    return output;
};
flatten([1, [2], [3, [[4]]  ]]);
//without自己写的。
function without(array,value){
    var args=Array.prototype.slice.call(arguments,1);
    for (var i = 0, l = args.length ; i < l;i++){
        var pos=array.indexOf(args[i]);
        while(pos>=0){
            array.splice(pos, 1);
            pos=array.indexOf(args[i],pos);
        }
    }
    return array;
}
//console.log(without([1,2,3,4],1,2));

_.without = function(array) {
    return _.difference(array, slice.call(arguments, 1));
};
//difference，取第一个数组，把后面数组中不在第一个中去掉；
_.difference = function(array) {
    var rest = flatten(arguments, true, true, 1);
    return _.filter(array, function(value){
        return !_.contains(rest, value);
    });
};

//数组的并集，并且是唯一的。
//先扁平化，再去重
_.union = function() {
    return _.uniq(flatten(arguments, true, true));
};

//返回数组的交集吧
//j===argLength判断是否都不包含
_.intersection = function(array) {
    if (array == null) return [];
var result = [];
var argsLength = arguments.length;
for (var i = 0, length = array.length; i < length; i++) {
    var item = array[i];
    if (_.contains(result, item)) continue;
    for (var j = 1; j < argsLength; j++) {
        if (!_.contains(arguments[j], item)) break;
    }
    if (j === argsLength) result.push(item);
}
return result;
};

//弄个空数组，判断是否存在加入的元素，不存在就加入。处理数组这样就够了。
    _.uniq = _.unique = function(array, isSorted, iteratee, context) {
    if (array == null) return [];
    if (!_.isBoolean(isSorted)) {
        context = iteratee;
        iteratee = isSorted;
        isSorted = false;
    }
    if (iteratee != null) iteratee = cb(iteratee, context);
    var result = [];
    var seen = [];
    for (var i = 0, length = array.length; i < length; i++) {
        var value = array[i],
            computed = iteratee ? iteratee(value, i, array) : value;
        if (isSorted) {
            if (!i || seen !== computed) result.push(value);
            seen = computed;
        } else if (iteratee) {
            if (!_.contains(seen, computed)) {
                seen.push(computed);
                result.push(value);
            }
        } else if (!_.contains(result, value)) {
            result.push(value);
        }
    }
    return result;
};

// Complement of _.zip. Unzip accepts an array of arrays and groups
// each array's elements on shared indices

_.unzip = function(array) {
    var length = array && _.max(array, 'length').length || 0;
    var result = Array(length);
    for (var index = 0; index < length; index++) {
        result[index] = _.pluck(array, index);
    }
    return result;
};

//用来变对象的。可以没有value直接传list,把list变一个对象
//也可以传长度和list一样的value，来构成数组
_.object = function(list, values) {
    var result = {};
    for (var i = 0, length = list && list.length; i < length; i++) {
        if (values) {
            result[list[i]] = values[i];
        } else {
            result[list[i][0]] = list[i][1];
        }
    }
    return result;
};

其他的几个好像都直接原生实现了的、、、、看来有点老了