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;};其餘的幾個好像都直接原生實現了的、、、、看來有點老了