Lodash

1. Lodash是什么？
是一个具有一致接口、模块化、高性能等特性的 JavaScript 工具库。
2.关于数组的一些方法：

_.chunk(array,[size=1])
将 array 拆分成多个 size 长度的块，把这些块组成一个新数组。
如果 array 无法被分割成全部等长的块，那么最后剩余的元素将组成一个块。

栗子：
_.chunk(['a', 'b', 'c', 'd'], 2);
// => [['a', 'b'], ['c', 'd']]

_.compact()  返回过滤假值之后的数组
假值：false、null、 0、""、undefined 和 NaN 

栗子：
_.compact([0,false,'',1,2])
// =>[1,2]

_.find(collection, [predicate=_.identity], [fromIndex=0])

_.difference() 返回过滤掉的数组

栗子：
_.difference([1,2,3],[2])   //第二个参数是需要过滤掉的值
// =>[1,3]

_.drop(array,[n=1])  去掉前n个元素，返回剩余的值

栗子：
_.drop([1,2,3],2)   //默认是从1开始的
// =>[3]  

_.dropRight(array,[n=1])  去掉数组尾部n个元素

栗子：
_.dropRight([1,2,3],2)
// =>[1]

_.fill(array,value,[start=0],[end=array.length])  //改变数组的一个方法
value是需要加到数组的内容，从start的位置开始 ，end位置结束但不包括end

栗子：
_.fill([1,2,3],'a',1,2)
// =>[1,'a',3]

_.findIndex(array, [predicate=_.identity], [thisArg])
 //返回符合查询条件的元素的索引值, 未找到则返回 -1

栗子：
var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];

_.findIndex(users, function(chr) {
  return chr.user == 'barney';
});
// => 0

_.findLastIndex(array, [predicate=_.identity], [thisArg])  //从右到左循环遍历
//返回匹配数组元素的索引值, 否则返回 -1 

_.first()   //返回数组第一个元素

_.indexOf()   //返回元素在数组中索引的位置

栗子：
_.indexOf([1,2,3,2],2)
// => 1

_.initial()     //去除数组中最后一个元素

栗子：
_.initial([1,2,3,4])
// => [1,2,3]

_.intersection()   //取出各数组中全等的元素

栗子：
_.intersection([1,2],[2,3])
// =>[2]

_.last()         //返回最后一个元素

栗子：
_.last([1,2,3])
// => 3

_.lastIndexOf()           
 //和_.indexOf() 类似，只不过是从右往左循环数组        索引从1开始

_.pull(array,[values])        //移除数组中所有和values相等的元素

栗子：
var array=[1,2,3,2,3,1]
_.pull(array,2,3)
// => [1,1]

_.remove()       //返回被移除元素组成的新数组

栗子：
var array = [1, 2, 3, 4];
var evens = _.remove(array, function(n) {
  return n % 2 == 0;
});

console.log(array);
// => [1, 3]

console.log(evens);
// => [2, 4]

_.rest()          //获取第一个元素除外的所有元素

栗子：
_.rest([1,2,3])
// => [2,3]

_.slice(array,[start=0],[end=array.length])           
//截取从start位置到end但不包括end位置的元素

栗子：
_.slice([1,2,3.4],1,3)
// => [1,4]

_.take(array,[n=1])     从数组的起始位置1开始取n个元素，返回的是取得的元素的数组

栗子：
_.take([1,2,3,4],2)
// => [1,2]

_.takeRight()         //和_.take()类似，只不过是从右往左循环遍历数组

_.union()          //按照顺序，从所有提供的数组中创建一个惟一值数组

栗子：
_.union([1,2][2,4],[1,4])
// => [1,2,4]

_.uniq()         //返回无重复值的新数组

栗子： 
_.uniq([1,2,2])
// => [1,2]

_.without()           //返回过滤后的新数组

栗子：
_.without([1,2,1,2,3],1)
// => [2,2,3]

_.zipObject()         //返回 一个新的对象

栗子：
_.zipObject([['fred', 30], ['barney', 40]]);
// => { 'fred': 30, 'barney': 40 }

当然这也只是其中一部分，详情点连接

http://lodashjs.com/docs/#_flattenarray-isdeep