var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
(1) first
_.first(array, [n])
返回array（数组）的第一个元素。传递 n参数将返回数组中从第一个元素开始的n个元素（返回数组中前 n 个元素.）
_.first([5, 4, 3, 2, 1]) ==> 5
_.first(stooges,2) ==> [{name: 'moe', age: 40}, {name: 'larry', age: 50}];
(2) last
_.last(array, [n])
返回array（数组）的最后一个元素。传递 n参数将返回数组中从最后一个元素开始的n个元素（返回数组里的后面的n个元素）。
_.last([5, 4, 3, 2, 1]) ==> 1
_.last(stooges,2) ==> [{name: 'larry', age: 50}, {name: 'curly', age: 60}];
(3) initial
_.initial(array, [n])
返回数组中除了最后一个元素外的其他全部元素。 在arguments对象上特别有用。传递 n参数将从结果中排除从最后一个开始的n个元素（排除数组后面的 n 个元素）。
_.initial([5, 4, 3, 2, 1]) ==> [5, 4, 3, 2]
_.initial(stooges,2) ==> [{name: 'moe', age: 40}];
(4) rest
_.rest(array, [index])
返回数组中除了第一个元素外的其他全部元素。传递 index 参数将返回从index开始的剩余所有元素 。
_.rest([5, 4, 3, 2, 1]) ==> [4, 3, 2, 1]
_.rest([5, 4, 3, 2, 1],2) ==> [3, 2, 1]
(5) compact
返回一个除去所有false值的 array副本。 在javascript中, false, null, 0, "", undefined 和 NaN 都是false值.
_.compact([0, 1, false, 2, '', 3, undefined]); ==> [1,2,3]
(6) flatten
_.flatten(array, [shallow])
将一个嵌套多层的数组 array（数组） (嵌套可以是任何层数)转换为只有一层的数组。 如果你传递 shallow参数，数组将只减少一维的嵌套。
_.flatten([1, [2], [3, [[4]]]]);
=> [1, 2, 3, 4];
_.flatten([1, [2], [3, [[4]]]], true);
=> [1, 2, 3, [[4]]];
(7) without
_.without(array, *values)
返回一个删除所有values值后的 array副本。
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
=> [2, 3, 4]
(8) union
_.union(*arrays)
返回传入的 arrays（数组）并集：按顺序返回，返回数组的元素是唯一的，可以传入一个或多个 arrays（数组）。
_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2, 3, 101, 10]
(9) intersection
_.intersection(*arrays)
返回传入 arrays（数组）交集。结果中的每个值是存在于传入的每个arrays（数组）里。
_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]
(10) uniq
_.uniq(array, [isSorted], [iteratee])
返回 array去重后的副本, 使用 === 做相等测试. 如果您确定 array 已经排序, 那么给 isSorted 参数传递 true值, 此函数将运行的更快的算法. 如果要处理对象元素, 传递 iteratee函数来获取要对比的属性.
_.uniq([1, 2, 1, 3, 1, 4]);
=> [1, 2, 3, 4]
var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 50}, {name: 'larry', age: 50}];
_.uniq(stooges, function(item){ return item.age })
==> [{name: 'moe', age: 40}, {name: 'larry', age: 50}];
(11) zip
_.zip(*arrays)
将 每个arrays中相应位置的值合并在一起。在合并分开保存的数据时很有用. 如果你用来处理矩阵嵌套数组时, _.zip.apply 可以做类似的效果。
_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]
(12) object
_.object(list, [values])
将数组转换为对象。传递任何一个单独[key, value]对的列表，或者一个键的列表和一个值得列表。 如果存在重复键，最后一个值将被返回。
_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
=> {moe: 30, larry: 40, curly: 50}
_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
=> {moe: 30, larry: 40, curly: 50}
(13) indexOf
_.indexOf(array, value, [isSorted])
返回value在该 array 中的索引值，如果value不存在 array中就返回-1。使用原生的indexOf 函数，除非它失效。如果您正在使用一个大数组，你知道数组已经排序，传递true给isSorted将更快的用二进制搜索..,或者，传递一个数字作为第三个参数，为了在给定的索引的数组中寻找第一个匹配值。
_.indexOf([1, 2, 3], 2);
=> 1
(14) findIndex
.findIndex(array, predicate, [context])
类似于.indexOf，当predicate通过真检查时，返回第一个索引值；否则返回-1。
_.findIndex([4, 6, 8, 12], isPrime);
=> -1 // not found
_.findIndex([4, 6, 7, 12], isPrime);
=> 2
(15) findLastIndex
_.findLastIndex(array, predicate, [context])
和 _.findIndex类似，但反向迭代数组，当predicate通过真检查时，最接近末端的索引值将被返回。
var users = [{'id': 1, 'name': 'Bob', 'last': 'Brown'},
{'id': 2, 'name': 'Ted', 'last': 'White'},
{'id': 3, 'name': 'Frank', 'last': 'James'},
{'id': 4, 'name': 'Ted', 'last': 'Jones'}];
_.findLastIndex(users, {
name: 'Ted'
});
=> 3
(16) range
_.range([start], stop, [step])
一个用来创建整数灵活编号的列表的函数，便于each 和 map循环。如果省略start则默认为 0；step 默认为 1.返回一个从start 到stop的整数的列表，用step来增加 （或减少）独占。值得注意的是，如果stop值在start前面（也就是stop值小于start值），那么值域会被认为是零长度，而不是负增长。-如果你要一个负数的值域 ，请使用负数step.
_.range(10);
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_.range(1, 11);
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
_.range(0, 30, 5);
=> [0, 5, 10, 15, 20, 25]
_.range(0, -10, -1);
=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
_.range(0);
=> []
