稽核函数（数组或对象）
each_.each(list, iteratee, [context]) 别名： forEach
遍历list中的所有元素，按顺序用遍历输出每个元素。如果传递了context参数，则把iteratee绑定到context对象上。每次调用iteratee都会传递三个参数：(element, index, list)。如果list是个JavaScript对象，iteratee的参数是 (value, key, list))。返回list以方便链式调用。（注：如果存在原生的forEach方法，Underscore就使用它代替。）
_.each([1, 2, 3], alert);
=> alerts each number in turn...
_.each({one: 1, two: 2, three: 3}, alert);
=> alerts each number value in turn...
注意：集合函数能在数组，对象，和类数组对象，比如arguments, NodeList和类似的数据类型上正常工作。 但是它通过鸭子类型工作，所以要避免传递一个不固定length属性的对象（注：对象或数组的长度（length）属性要固定的）。每个循环不能被破坏 - 打破， 使用_.find代替，这也是很好的注意。
map_.map(list, iteratee, [context]) 别名： collect
通过变换函数（iteratee迭代器）把list中的每个值映射到一个新的数组中（注：产生一个新的数组）。如果存在原生的map方法，就用原生map方法来代替。如果list是个JavaScript对象，iteratee的参数是(value, key, list)。
_.map([1, 2, 3], function(num){ return num * 3; });
=> [3, 6, 9]
_.map({one: 1, two: 2, three: 3}, function(num, key){ return num * 3; });
=> [3, 6, 9]
reduce_.reduce(list, iteratee, [memo], [context]) Aliases: inject, foldl
别名为 inject 和 foldl, reduce方法把list中元素归结为一个单独的数值。Memo是reduce函数的初始值，reduce的每一步都需要由iteratee返回。这个迭代传递4个参数：memo, value 和 迭代的index（或者 key）和最后一个引用的整个 list。
如果没有memo传递给reduce的初始调用，iteratee不会被列表中的第一个元素调用。第一个元素将取代 传递给列表中下一个元素调用iteratee的memo参数，
var sum = _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0);
=> 6
reduceRight_.reduceRight(list, iteratee, memo, [context]) 别名: foldr
reducRight是从右侧开始组合的元素的reduce函数，如果存在JavaScript 1.8版本的reduceRight，则用其代替。Foldr在javascript中不像其它有懒计算的语言那么有用（注：lazy evaluation：一种求值策略，只有当表达式的值真正需要时才对表达式进行计算）。
var list = [[0, 1], [2, 3], [4, 5]];
var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
=> [4, 5, 2, 3, 0, 1]
find_.find(list, predicate, [context]) 别名： detect
在list中逐项查找，返回第一个通过predicate迭代函数真值检测的元素值，如果没有值传递给测试迭代器将返回undefined。 如果找到匹配的元素，函数将立即返回，不会遍历整个list。
var even = _.find([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
=> 2
filter_.filter(list, predicate, [context]) 别名： select
遍历list中的每个值，返回包含所有通过predicate真值检测的元素值。（注：如果存在原生filter方法，则用原生的filter方法。）
var evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
=> [2, 4, 6]
where_.where(list, properties)
遍历list中的每一个值，返回一个数组，这个数组包含包含properties所列出的属性的所有的键 - 值对。
_.where(listOfPlays, {author: "Shakespeare", year: 1611});
=> [{title: "Cymbeline", author: "Shakespeare", year: 1611},
{title: "The Tempest", author: "Shakespeare", year: 1611}]
findWhere_.findWhere(list, properties)
遍历list中的每一个值，返回匹配properties所列出的属性的所有的键 - 值对的第一个值。
如果没有找到匹配的属性，或者list是空的，那么将返回undefined。
_.findWhere(publicServicePulitzers, {newsroom: "The New York Times"});
=> {year: 1918, newsroom: "The New York Times",
reason: "For its public service in publishing in full so many official reports,
documents and speeches by European statesmen relating to the progress and
conduct of the war."}
reject_.reject(list, predicate, [context])
返回list中没有通过predicate真值检测的元素集合，与filter相反。
var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
=> [1, 3, 5]
every_.every(list, [predicate], [context]) 别名： all
如果list中的所有元素都通过predicate的真值检测就返回true。（注：如果存在原生的every方法，就使用原生的every。）
_.every([true, 1, null, ‘yes‘], _.identity); => false
some_.some(list, [predicate], [context]) 别名： any
如果list中有任何一个元素通过 predicate 的真值检测就返回true。一旦找到了符合条件的元素, 就直接中断对list的遍历. （注：如果存在原生的some方法，就使用原生的some。）
_.some([null, 0, ‘yes‘, false]); => true
contains_.contains(list, value) 别名： include
如果list包含指定的value则返回true（注：使用===检测）。如果list 是数组，内部使用indexOf判断。
_.contains([1, 2, 3], 3); => true
invoke_.invoke(list, methodName, *arguments)
在list的每个元素上执行methodName方法。 任何传递给invoke的额外参数，invoke都会在调用methodName方法的时候传递给它。
_.invoke([[5, 1, 7], [3, 2, 1]], ‘sort‘); => [[1, 5, 7], [1, 2, 3]]
pluck_.pluck(list, propertyName)
pluck也许是map最常使用的用例模型的简化版本，即萃取对象数组中某属性值，返回一个数组。
var stooges = [{name: ‘moe‘, age: 40}, {name: ‘larry‘, age: 50}, {name: ‘curly‘, age: 60}];
_.pluck(stooges, ‘name‘);
=> ["moe", "larry", "curly"]
max_.max(list, [iteratee], [context])
返回list中的最大值。如果传递iteratee参数，iteratee将作为list中每个值的排序依据。如果list为空，将返回-Infinity，所以你可能需要事先用isEmpty检查 list 。
var stooges = [{name: ‘moe‘, age: 40}, {name: ‘larry‘, age: 50}, {name: ‘curly‘, age: 60}];
_.max(stooges, function(stooge){ return stooge.age; });
=> {name: ‘curly‘, age: 60};
min_.min(list, [iteratee], [context])
返回list中的最小值。如果传递iteratee参数，iteratee将作为list中每个值的排序依据。如果list为空，将返回-Infinity，所以你可能需要事先用isEmpty检查 list 。
var numbers = [10, 5, 100, 2, 1000]; _.min(numbers); => 2
sortBy_.sortBy(list, iteratee, [context])
返回一个排序后的list拷贝副本。如果传递iteratee参数，iteratee将作为list中每个值的排序依据。迭代器也可以是字符串的属性的名称进行排序的(比如 length)。
_.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });
=> [5, 4, 6, 3, 1, 2]
groupBy_.groupBy(list, iteratee, [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"]}
indexBy_.indexBy(list, iteratee, [context])
给定一个list，和 一个用来返回一个在列表中的每个元素键 的iterator 函数（或属性名）， 返回一个每一项索引的对象。和groupBy非常像，但是当你知道你的键是唯一的时候可以使用indexBy 。
var stooges = [{name: ‘moe‘, age: 40}, {name: ‘larry‘, age: 50}, {name: ‘curly‘, age: 60}];
_.indexBy(stooges, ‘age‘);
=> {
"40": {name: ‘moe‘, age: 40},
"50": {name: ‘larry‘, age: 50},
"60": {name: ‘curly‘, age: 60}
}
countBy_.countBy(list, iteratee, [context])
排序一个列表组成一个组，并且返回各组中的对象的数量的计数。类似groupBy，但是不是返回列表的值，而是返回在该组中值的数目。
_.countBy([1, 2, 3, 4, 5], function(num) {
return num % 2 == 0 ? ‘even‘: ‘odd‘;
});
=> {odd: 3, even: 2}
shuffle_.shuffle(list)
返回一个随机乱序的 list 副本, 使用 Fisher-Yates shuffle 来进行随机乱序.
_.shuffle([1, 2, 3, 4, 5, 6]); => [4, 1, 6, 3, 5, 2]
sample_.sample(list, [n])
从 list中产生一个随机样本。传递一个数字表示从list中返回n个随机元素。否则将返回一个单一的随机项。
_.sample([1, 2, 3, 4, 5, 6]); => 4 _.sample([1, 2, 3, 4, 5, 6], 3); => [1, 6, 2]
toArray_.toArray(list)
把list(任何可以迭代的对象)转换成一个数组，在转换 arguments 对象时非常有用。
(function(){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
=> [2, 3, 4]
size_.size(list)
返回list的长度。
_.size({one: 1, two: 2, three: 3});
=> 3
partition_.partition(array, predicate)
拆分一个数组（array）为两个数组： 第一个数组其元素都满足predicate迭代函数， 而第二个的所有元素均不能满足predicate迭代函数。
_.partition([0, 1, 2, 3, 4, 5], isOdd); => [[1, 3, 5], [0, 2, 4]]