数组基本操作

1. 查找数组元素

first--返回第一个元素

_.first(array);

head--返回第一个元素

_.head(array);

tail--返回除第一个元素之外的数组

_.tail([1, 2, 3]);  //[2, 3]

last-返回最后元素

_.last(array);

findIndex--从头查询元素序号

遍历，查询到符合的元素即返回序号，没有符合的返回-1。predicate为Function|Object|String。

_.findIndex(array, [predicate]);

var users = [
    {user: 'barney', active: false},
    {user: 'fred', active: false},
    {user: 'pebbles', active: true}
];
_.findIndex(users, function(o){return !o.user == 'barney';});    //0
_.findIndex(users, {user: 'fred', active: false});    //1
_.findIndex(users, ['active', false]);    //0
_.findIndex(users, 'active');    //2

findLastIndex--从尾查询元素序号

用法类似 _.findIndex()，不过返回的序号为符合要求的最后一个。

indexOf--从头查询元素序号

从数组中查询value的序号，参数3如果是number，则从数组的number位置开始查找，参数3如果是true，则执行二分查找（二分查找为升序或降序的有序列表，查找时从中匹配为=或>或<，则可直接查找成功或只查找折半的子表）。

_.indexOf(array, value, number|bool);

_.indexOf([1, 2, 1, 2], 2);    //1
_.indexOf([1, 2, 1, 2], 2, 2);    //3
_.indexOf([1, 1, 2, 2], 2, true);    //2

lastIndexOf--从尾查询元素序号

功能和_.indexOf()类似，不过从末尾开始查询。

2. 替换数组元素

fill--替换元素

从start到end，用value修改或填补数组元素。此方法直接改变数组，而不是返回新的数组。

_.fill(array, value, [start=0], [end=array.length];

var array = [1, 2, 3];
_.fill(array, 'a');    //['a', 'a', 'a']
_.fill(Array(3), b);    //['b', 'b', 'b']
_.fill([4, 6, 8], '*', 1, 2);    //[4, '*', 8]

3. 删除数组元素

initial--删除末尾元素

_.initial([1, 2, 3]);    //[1, 2]

reset--删除首元素

和_.initial()相反。

drop--从头删除元素

从头开始删除number个数组元素。number不传默认为1

_.drop(array, [number]);

_.drop([1, 2, 3]);    //[2, 3]
_.drop([1, 2, 3], 2);    //[3]

dropRight--从尾删除元素

用法和drop一样，不过从尾部开始删除元素

dropRightWhile--从尾多功能过滤元素

从尾部开始通过参数对数组进行过滤，返回符合条件的调用。predicate可以为 Function|Object|String 。

_.dropRightWhile(array, [predicate]);

var users = [
    {user: 'barney', active: true},
    {user: 'fred', active: false},
    {user: 'pebbles', active: false}
];
_.dropRightWhile(users, function(o){return !o.active;});    //['barney']
_.dropRightWhile(users, {user: 'pebbles', active: false});    //['barney', 'fre']
_.dropRightWhile(users, ['active', false]);    //['barney']
_.dropRightWhile(users, 'active');    //['barney', 'fred', 'pebbles']

dropWhile--从头多功能过滤元素

功能和_.dropRightWhile()一样，只不过从头开始过滤。

compact--去除假值

去除数组中boolean值为false的元素，返回新的数组

_.compact(array);

_.compact(['a', 'b', '']);    //['a', 'b']
_.compact([0, 1, false, 2, '', 3, NaN, undefined]    //[1, 2, 3]

difference--删除特定元素

在数组array中去除和数组values中元素相同的元素。

_.difference(array, [values]);

_.difference([1, 2, 4], [2]);    //[1, 4]

differenceBy--多功能删除特定元素

通过参数Function|Object|String来进行参数匹配，删除相应元素。

_.differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], Math.floor);    //[3.1, 1.3]
_.differenceBy([{x: 2}, {x: 1}], [{x: 1}], 'x');    //[{x: 2}]

differenceWith--多功能删除特定元素

通过指定比较方式删除所匹配的数组元素。

var array = [{x: 1, y: 2}, {x: 2, y: 1}];
_.differenceWith(array, [{x: 1, y: 2}], _.isEqual); //[{x: 2, y: 1}]

pull--删除特定元素

直接对原数组操作，不返回新数组。

_.pull(arrary, [values]);

var arrary = [1, 2, 3, 1, 2, 3];
_.pull(array, 2, 3);    //[1, 1]

pullAll--删除特定元素

和pull功能一样，不过pullAll参数为数组。

var array = [1, 2, 3, 1, 2, 3];
_.pullAll(array, [2, 3]);   //[1, 1]

pullAllBy--多功能删除特定元素

匹配参数Function|Object|String删除对应的元素。

var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
_.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');  //[{ 'x': 2 }]

pullAllWith--多功能删除特定元素

删除匹配指定匹配方式的元素。

var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
_.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);  //[{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]

pullAt--删除特定序号元素

直接对原数组操作，并且返回移除的元素组成的数组。

_.pullAt(array, [indexes]);

var array = [5, 10, 15, 20];
var delArr = _.pullAt(array, 1, 3);
//array: [5, 15]
//delArr: [10, 20]

remove--多功能删除元素

逻辑和_.dropRightWhile()类似，通过Function|Object|String进行删除元素匹配。对原数组进行操作，并返回移除的元素组成的数组。

_.remove(array, [predicate]);

``bash var array = [1, 2, 3, 4]; var delArr = _.remove(array, function(item){ return item % 2 == 0; }); //array: [1, 3] //delArr: [2, 4]

### without--删除数组某些值
不同于_.difference()，values为一些零散的参数。
```bash
_.without([1, 2, 1, 3], 1, 2);    //[3]

xor--删除重复值后合并

可多组数组进行，两两配对删除，然后合并。

_.xor([2, 4], [1, 2]);    //[4, 1]
_.xor([1, 2], [3, 4, 1]);    //[2, 3, 4]
_.xor([1, 2], [1, 2], [1]);    //[1]
_.xor([1, 2], [1, 2], [1, 4], [1, 4]);    //[]

xorBy--多功能删除重复值后合并

_.xorBy([2.1, 1.2], [4.3, 2.4], Math.floor);    // [1.2, 4.3]
_.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');   // [{ 'x': 2 }]

xorWith--多功能删除重复值后合并

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
_.xorWith(objects, others, _.isEqual);
// [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]

uniq--数组去重

如isSorted设置为true，表明数组为升降序排列数组，使用二分法去重。最后一个参数thisArg为指定this指向。

_.uniq([2, 1, 2]);    //[2, 1]

uniqBy--数组多功能去重

可添加数据处理后对比去重。第二个参数可为 Function|Object|String。

_.uniqBy([2.1, 1.2, 2.3], Math.floor);    //[2.1, 1.2]
_.uniqBy([1, 2.5, 1.5, 2], function(item){    //指定this为Math
    return Math.floor(item);
});
//下列方式官方文档没有给出说明，经由我多次测试发现
//第二个参数设置为x时，对比数组中每个key为x的值，相同者去重
//若第二个参数在数组中没有响应的key，则永远返回数组第一项array[0]。
_.uniqBy([{'x': 1}, {'x': 2}, {'x': 1}], 'x');    //[{x: 1}, {x: 2}]
_.uniqBy([{'x': 1}, {'x': 2}, {'x': 1}], 'y');    //[{'x': 1}]

uniqWith--数组多功能去重

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; .uniqWith(objects, .isEqual); // [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]

### sortedUniq--有序数组去重
和_.uniq()功能类似，不过只对有序数组去重。
```bash
_.sortedUniq([1, 1, 2]);    //[1, 2]

sortedUniqBy--有序数组多功能去重

和_.uniqBy()功能类似，不过只对有序数组去重。

_.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);   //[1.1, 2.3]

3. 添加数组元素

sortedIndex--对有序数组进行插入

把元素按有序排列的方式在相应位置插入一个有序数组，返回插入的位置。

_.sortedIndex(array, value);

_.sortedIndex([30, 50], 40);    //1

sortedLastIndex--对有序数组进行反向插入

与_.sortedIndex()功能类似，不过是从尾部开始插入。

_.sortedLastIndex([4, 4, 5, 5], 5);    //4

4. 拆分数组

chunk--对数组分块

根据number对array进行均等分块

_.chunk(array, number);

_.chunk([1, 2, 3, 4], -1);    //number <= 1时，按1等分
//[1, 2, 3, 4]
_.chunk[1, 2 , 3, 4], 3);
//[[1, 2, 3], [4]]

5. 合并数组

concat--合并数组或添加元素

添加任何元素至数组中，不改变原数组，返回一个新数组。

_.concat(array, [values]);

var array = [1];
var other = _.concat(array, 2, [3], [[4]]);
//array [1]
//other [1, 2, 3, [4]];

flatten--抹平嵌套数组

isDeep为空或者false时，只抹平第一层嵌套。为true时，全部抹平。

_.flatten([1, [2, 3, [4]]]);    //[1, 2, 3, [4]]
_.flatten([1, [2, 3, [4]]], true);    //[1, 2, 3, 4]

flattenDeep--全部抹平嵌套数组

_.flattenDeep([1, [2, 3, [4]]]);    //[1, 2, 3, 4]

flattenDepth--抹平嵌套数组n次

默认depth为1.

_.flattenDepth(array, [depth=1]);

_.flattenDepth([1, [2, [3, [4]], 5]], 2);    //[1, 2, 3, [4], 5]

join--合并数组为字符串

默认合并字符为 , 。

_.join(array, [separator=',']);

_.join(['a', 'b', 'c'], '~');   //'a~b~c'

6. 数组排序

reverse--反转数组

对原数组进行操作，不返回新数组。

var array = [1, 2, 3];
_.reverse(array);   //array：[3, 2, 1]

7. 获取子数组

slice--截取数组

和原生slice功能类似。

_.slice(array, [start=0], [end=array.length]);

take--正向获取n个元素

获取数组中的前n个元素。默认为1

_.take(array, [n=1]);

_.take([1, 2, 3]);    //[1]
_.take([1, 2, 3], 2);    //[1, 2]

takeRight--反向获取n个元素

获取数组中的后n个元素。默认为1

_.takeRight([1, 2, 3], 2);    //[2, 3]

takeRightWhile--反向多功能获取n个元素

通过Function|Object|String来确定所获取的元素。

_.takeRightWhile(array, predicate);

_.takeRightWhile([1, 2, 3], function(item){
    return item > 1;
});
//[2, 3]
var users = [
    {user: 'barney', active: true},
    {user: 'fred', active: false},
    {user: 'pebbles', active: false}
];
_.takeRightWhile(users, function(o){return !o.active});    //['fred', 'pebbles']
_.takeRightWhile(users, {user: 'pebbles', active: false});    //['pebles']
_.takeRightWhile(users, 'active');    //[]

takeWhile--正向多重获取n个元素

类似_.takeRightWhile()，执行顺序相反。

8. 其他数组操作

intersection--返回数组交集

_.intersection([1, 2], [2, 3], [4, 2]);    //[2]

intersectionBy--多功能返回数组交集

返回第一个数组的元素。

_.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);   //[2.1]
_.intersectionBy([{x: 1}], [{x: 2}, {x: 1}], 'x');  //[{x: 1}]

intersectionWith--多功能返回数组交集

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
_.intersectionWith(objects, others, _.isEqual); // [{ 'x': 1, 'y': 2 }]

union--数组去重合并

_.union([arrays]);

_.union([1,2], [4, 2], [2, 1]);    //[1, 2, 4]

unionBy--数组多功能去重合并

_.unionBy([2.1, 1.2], [4.3, 2.4], Math.floor);  //[2.1, 1.2, 4.3]
_.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); //[{ 'x': 1 }, { 'x': 2 }]

unionWith--数组多功能去重合并

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
_.unionWith(objects, others, _.isEqual);
// [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]

zip--多数组同位置元素组合

把每个数组相同index位置的元素组合为一个数组。

_.zip(['a', 'b'], [30, 40], [true, false]);    //[['a', 30, true], ['b', 40, false]]
_.zip(['a', 'b'], [30], [true, false]);    //[['a', 30, true], ['b', undefined, false]]

unzip--还原zip后的数组

把zip的过程逆行。

_.zip(['a', 30, true], ['b', 40, false]);    //[['a', 'b'], [30, 40], [true, false]]

unzipWith--在upzip时对数据进行操作

var zipped = _.zip([1, 2], [10, 20], [100, 200]);    //[[1, 10, 100], [2, 20, 200]]
_.unzipWith(zipped, _.add);    //[3, 30, 300]

zipWith

类似_.unzipWith()函数

zipObject--两数组配对转为json格式

两个数组间进行配对转换json。

_.zipObject(array, array);

_.zipObject(['zhou', 'chen'], [30, 33]);    //{zhou: 30, chen: 33}

fromPairs--数组内元素转为json格式

_.fromPairs([['zhou', 30], ['chen', 33]]);  //{zhou: 30, chen: 33}