underscore.js源码解析（四）

_.countBy = group(function(result, value, key) {
if (_.has(result, key)) result[key]++; else result[key] = 1;
});

这个就是返回符合条件的对象数量

  _.partition = group(function(result, value, pass) {
    result[pass ? 0 : 1].push(value);
  }, true);

这就是一个按要求把一个数组拆分成两个的函数，调用group函数，遍历数组，将符合条件的放在第一个数组当中，不符合的放在第二个函数当中

_.toArray

_.toArray = function(obj) {
//如果为空，返回空数组
if (!obj) return [];
//如果是数组，拷贝数组
if (_.isArray(obj)) return slice.call(obj);
if (_.isString(obj)) {
// 如果是字符串，则利用正则表达式提取匹配项
return obj.match(reStrSymbol);
}
//如果类数组，通过map方法转化数组
if (isArrayLike(obj)) return _.map(obj);
//对象，取出属性值存入数组
return _.values(obj);
};

_.size

_.size = function(obj) {
//判断是否为空
if (obj == null) return 0;
//如果是数组则返回数组长度，如果是对象返回属性的数量
return isArrayLike(obj) ? obj.length : _.keys(obj).length;
};

_.initial

_.initial = function(array, n, guard) {
return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
};

返回筛选后的数组，n是第几个开始，如果n不存在那么就是array.length-1，也就是数组全拷贝一遍，Math.max是为了规避负数的情况

_.first

_.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);
};

first就是取前几个元素的作用，调用了initial函数

_.rest

_.rest = _.tail = _.drop = function(array, n, guard) {
return slice.call(array, n == null || guard ? 1 : n);
};

_.rest是获取第n个元素之后的元素

_.last

_.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));
};

返回最后n个元素，结构跟first差不多

flatten

var flatten = function(input, shallow, strict, output) {
//output是存放结果的数组
output = output || [];
var idx = output.length;
//遍历input，input是要处理的数组
for (var i = 0, length = getLength(input); i length; i++) {
var value = input[i];
//判断是不是数组或者arguments对象
if (isArrayLike(value) (_.isArray(value) || _.isArguments(value))) {
// 是否只合并一次
if (shallow) {
var j = 0, len = value.length;
while (j len) output[idx++] = value[j++];
} else {
//如果不是，则递归调用flatten
flatten(value, shallow, strict, output);
idx = output.length;
}
//如果不是数组，并且是非严格的
} else if (!strict) {
//直接将value拷贝到output数组当中
output[idx++] = value;
}
}
return output;
};

flatten作用就是将多维数组合并成一维数组，如果参数shallow为true的话，就只合并一次

_.difference

_.difference = restArgs(function(array, rest) {
rest = flatten(rest, true, true);
return _.filter(array, function(value){
return !_.contains(rest, value);
});
});

作用是剔除第一数组中其他数组也有的元素，它是先调用flatten将其合并，再调用filter选出符合条件的，里面的条件是!_.cotains，也就是不存在的，所以最后取出的就是剔除完之后的元素数组了

_.uniq

_.uniq = _.unique = function(array, isSorted, iteratee, context) {
//如果没有isSorted参数则对参数进行调整
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 = getLength(array); 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) {
//处理对象，computed是上面回调函数返回的结果，然后比较，没有就添加
if (!_.contains(seen, computed)) {
seen.push(computed);
result.push(value);
}
//判断result里是否有value，如果没有就添加
} else if (!_.contains(result, value)) {
result.push(value);
}
}
return result;
};

就是一个去重的函数，分别对有序的，对象和普通三种情况分别进行处理

_.intersection