1、_.each(list, iterator, [context]):对集合中每一元素执行处理器方法.
如果传递了context参数，则把iterator绑定到context对象上。每次调用iterator都会传递三个参数：(element, index, list)。如果list是个JavaScript对象，iterator的参数是 (value, key, list))。如果存在原生的forEach方法，Underscore就使用它代替。
var each = _.each = _.forEach = function(obj, iterator, context) {
//不处理null
if (obj == null) return;
//宿主环境支持foreach，则优先调用
if (nativeForEach && obj.forEach === nativeForEach) {
obj.forEach(iterator, context);
//obj.length是number，以后for循环都需要加这个条件
} else if (obj.length === +obj.length) {
//obj为数组
for (var i = 0, l = obj.length; i < l; i++) {
//i是obj的序号，iterator的返回值如果是breaker的话，则终止；breaker是内部对象，只在any中进行调用
if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
}
} else {
//obj为对象
for (var key in obj) {
//不考虑原型链的属性
if (_.has(obj, key)) {
if (iterator.call(context, obj[key], key, obj) === breaker) return;
}
}
}
};
2、_.map(list, iterator, [context]) :通过变换函数（iterator迭代器）把list中的每个值映射到一个新的数组中
_.map = _.collect = function(obj, iterator, context) {
var results = [];
if (obj == null) return results;
if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
each(obj, function(value, index, list) {
//自增数组；iterator需要有返回值；
results[results.length] = iterator.call(context, value, index, list);
});
//如果是数组的话，一定要返回相同长度的新数组
if (obj.length === +obj.length) results.length = obj.length;
return results;
};
var a = [1,2,3,4,5];
var result = _.map(a, function(value){
if(value < 3){
return value%2 ? value:0;
}
})
console.log(result);
3、_.reduce():list中元素归结为一个单独的数值
Memo是reduce函数的初始值，reduce的每一步都需要由iterator返回。这个迭代传递4个参数：memo, value 和 迭代的index（或者 key）和最后一个引用的整个 list。
_.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
var initial = arguments.length > 2;
if (obj == null) obj = [];
if (nativeReduce && obj.reduce === nativeReduce) {
//为什么用bind，而不用call方法呢？
if (context) iterator = _.bind(iterator, context);
return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
}
each(obj, function(value, index, list) {
if (!initial) {
//如果没有memo，则把第一个值作为memo；只是考虑第一次的情况，真巧妙
memo = value;
initial = true;
} else {
memo = iterator.call(context, memo, value, index, list);
}
});
//TypeError:内置的js对象
if (!initial) throw new TypeError('Reduce of empty array with no initial value');
return memo;
};
4、_reduceRight():从右侧开始执行reduce函数
_.reduceRight = _.foldr = function(obj, iterator, memo, context) {
var initial = arguments.length > 2;
if (obj == null) obj = [];
if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
if (context) iterator = _.bind(iterator, context);
return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
}
//函数反转
var reversed = _.toArray(obj).reverse();
if (context && !initial) iterator = _.bind(iterator, context);
return initial ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator);
};
5、_.find():遍历list，返回第一个通过iterator迭代器真值检测的元素值.
如果没有值传递给测试迭代器将返回undefined。 如果找到匹配的元素，函数将立即返回，不会遍历整个list。
_.find = _.detect = function(obj, iterator, context) {
var result;
//找到一个就返回
any(obj, function(value, index, list) {
if (iterator.call(context, value, index, list)) {
result = value;
//any iterator return true
return true;
}
});
return result;
};
6、_.filter():遍历list中的每个值，返回包含所有通过iterator真值检测的元素值。如果存在原生filter方法，则用原生的filter方法。
_.filter = _.select = function(obj, iterator, context) {
var results = [];
if (obj == null) return results;
if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
each(obj, function(value, index, list) {
//自增函数
if (iterator.call(context, value, index, list)) results[results.length] = value;
});
return results;
};
7、_.reject():返回没有用过iterator真值检测的元素值，与filter相反
_.reject = function(obj, iterator, context) {
var results = [];
if (obj == null) return results;
each(obj, function(value, index, list) {
if (!iterator.call(context, value, index, list)) results[results.length] = value;
});
return results;
};
8、_.every():如果list中的所有元素都通过iterator的真值检测就返回true。
_.every = _.all = function(obj, iterator, context) {
var result = true;
if (obj == null) return result;
if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
each(obj, function(value, index, list) {
//result = (result && iterator.call(context, value, index, list)) 太高明了
if (!(result = result && iterator.call(context, value, index, list))) return breaker;
});
return !!result;
};
9、_.any(): 如果list中有任何一个元素通过 iterator 的真值检测就返回true。也叫some
一旦找到了符合条件的元素, 就直接中断对list的遍历. 如果存在原生的some方法，就使用原生的some
var any = _.some = _.any = function(obj, iterator, context) {
//如果iterator存在，则继续；如果iterator不存在，则执行iterator = _.identity(默认的迭代器或处理器)
iterator || (iterator = _.identity);
var result = false;
if (obj == null) return result;
if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
each(obj, function(value, index, list) {
if (result || (result = iterator.call(context, value, index, list))) return breaker;
});
//!!一般用来将后面的表达式强制转换为布尔类型的数据（boolean），也就是只能是true或者false
return !!result;
};
10、_.include():集合中是否有值与目标参数完全匹配(同时将匹配数据类型)
_.include = _.contains = function(obj, target) {
var found = false;
if (obj == null) return found;
//这种return太好了
if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
found = any(obj, function(value) {
return value === target;
});
return found;
};
11、_.invoke():在list的每个元素上执行methodName方法。 任何传递给invoke的额外参数，invoke都会在调用methodName方法的时候传递给它。
_.invoke = function(obj, method) {
var args = slice.call(arguments, 2);
return _.map(obj, function(value) {
//不需要method||value
//method可以是对象的属性名
return (_.isFunction(method) ? method || value : value[method]).apply(value, args);
});
};
12、_.pluck():获取对象数组的属性值
_.pluck = function(obj, key) {
return _.map(obj, function(value){ return value[key]; });
};
实例
var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
_.pluck(stooges, 'name');
=> ["moe", "larry", "curly"]
13、_.max():取最大值
14、_.min():取最小值
_.min = function(obj, iterator, context) {
//iterator不存在，obj是数组，且有值
if (!iterator && _.isArray(obj) && obj[0] === +obj[0]) return Math.min.apply(Math, obj);
//iterator不存在，obj为空，返回最大值
if (!iterator && _.isEmpty(obj)) return Infinity;
var result = {computed : Infinity};
each(obj, function(value, index, list) {
//iterator存在，执行iterator；不存在，computed为当前值；
var computed = iterator ? iterator.call(context, value, index, list) : value;
//当前计算值小于之前计算值，给result赋值；不小于的话，不赋值；把&&当if用
computed < result.computed && (result = {value : value, computed : computed});
});
return result.value;
};
15、_.shuffle():随机乱序
_.shuffle = function(obj) {
var shuffled = [], rand;
each(obj, function(value, index, list) {
//随机数在0到当前已处理的数量之间
rand = Math.floor(Math.random() * (index + 1));
//交换随机数与当前序号的值
shuffled[index] = shuffled[rand];
shuffled[rand] = value;
});
return shuffled;
};
16、_.sortBy():返回一个排序后的list拷贝副本。
如果有iterator参数，iterator将作为list排序的依据。迭代器也可以是字符串的属性的名称进行排序的(比如 length)。相比Array.prototype.sort,sortBy()支持对对象排序
_.sortBy = function(obj, val, context) {
//val是处理器，返回需要比较的值；val是对象的属性，返回属性的值
var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
// 调用顺序: _.pluck(_.map().sort());
// 调用_.map()方法遍历集合, 并将集合中的元素放到value节点, 将元素中需要进行比较的数据放到criteria属性中
// 调用sort()方法将集合中的元素按照criteria属性中的数据进行顺序排序
// 调用pluck获取排序后的对象集合并返回
return _.pluck(_.map(obj, function(value, index, list) {
return {
value : value,
criteria : iterator.call(context, value, index, list)
};
}).sort(function(left, right) {
var a = left.criteria, b = right.criteria;
if (a === void 0) return 1;
if (b === void 0) return -1;
//不明白为什么这么写？
return a < b ? -1 : a > b ? 1 : 0;
}), 'value');
};
17、_.groupBy(list, iterator, [context])把一个集合分组为多个集合，通过 iterator 返回的结果进行分组.
如果 iterator 是一个字符串而不是函数, 那么将使用 iterator 作为各元素的属性名来对比进行分组.
_.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); });
=> {1: [1.3], 2: [2.1, 2.4]}
_.groupBy(['one', 'two', 'three'], 'length');
=> {3: ["one", "two"], 5: ["three"]}
_.groupBy = function(obj, val) {
var result = {};
var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
each(obj, function(value, index) {
var key = iterator(value, index);
//|| 和 &&用得真好；如果result[key]不存在的话，赋为[];如果result[key]存在的话，给他push
(result[key] || (result[key] = [])).push(value);
});
return result;
};
18、_.sortedIndex(list, value, [iterator], [context])： 使用二分查找确定value在list中的位置序号，value按此序号插入能保持list原有的排序。
如果提供iterator函数，iterator将作为list排序的依据，包括你传递的value 。 iterator也可以是字符串的属性名用来排序(比如length)。
_.sortedIndex([10, 20, 30, 40, 50], 35);
=> 3
var stooges = [{name: 'moe', age: 40}, {name: 'curly', age: 60}];
_.sortedIndex(stooges, {name: 'larry', age: 50}, 'age');
=> 1
_.sortedIndex = function(array, obj, iterator) {
iterator || (iterator = _.identity);
var low = 0, high = array.length;
while (low < high) {
//(low+high) >> 1右移一位，不是/2,因为右移的话，小数就没了
var mid = (low + high) >> 1;
iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
}
return low;
};
19、_.toArray():转为数组
_.toArray = function(obj) {
if (!obj) return [];
if (_.isArray(obj)) return slice.call(obj);
if (_.isArguments(obj)) return slice.call(obj);
if (obj.toArray && _.isFunction(obj.toArray)) return obj.toArray();
// 将对象转换为数组, 数组中包含对象中所有属性的值列表(不包含对象原型链中的属性)
return _.values(obj);
};
20、_.size():
_.size = function(obj) {
//如果是对象，则返回属性的个数（不包含原型链）
return _.isArray(obj) ? obj.length : _.keys(obj).length;
};