lodash 中文学习拾零之Array篇

作者：Soaring_Tiger 转载请注明出处

[为什么叫lodash ?]很多人都知道 lodash是从underscore 里fork出来的，为什么叫lodash呢？其实挺简单 underscore是英文”下划线”（没错，就是那条 _ ）的意思，而 lo dash其实是西班牙语里的”破折号”的意思��

1. Array类
   1.1 dropWhile
   第一个参数是要处理的数组，第二个参数是切片条件，
   切片从左自右顺序执行，当遇到不满足条件的元素时，切片停止。

//例：从左自右查找，遇到是小于3的都切掉，遇到不符合条件的就停止切片。
_.dropWhile([1, 2, 3, 2], function(n) {
  return n < 3;
});
// → [3, 2] 最右边的那个2就没有被切下来

1.2 dropRightWhile 刚好和dropWhile反过来，从右边切起。

1.3 difference
第一个参数是要被处理的数组，后面的若干个数组都是用来筛选第一个数组的

_.difference([1, 2, 3, 6, 8, 5], [4, 2], [5, 6]);
// → [1, 3, 8]

1.4 findIndex 找出符合条件的第一个数组元素下标，如果没有符合条件的，返回值为-1

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
_.findIndex(users, { 'user': 'fred', 'active': false });
// → 1

1.5 findLastIndex 找出符合条件的最后一个数组元素下标。

1.6 first、head 都是返回第一个数组元素，没有就返回 undefined。

1.7 flatten 多维数组降纬
第一个参数是数组，第二个参数是否消成一维数组

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

// using `isDeep`
_.flatten([1, [2, 3, [4]]], true);
// → [1, 2, 3, 4]

1.8 intersection 获得所有数组元素的交集。

1.9 lastIndexOf 获得最后一个符合条件的数组元素下标（数组元素不适用于Object对象）。

1.10 pull 拔掉数组中符合要求的所有元素：

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

1.11 pullAt 拔掉指定的数组下标上的元素，注意返回值

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

console.log(array);
// → [5, 15]

console.log(evens);
// → [10, 20]

1.12 remove 删掉符合条件的元素，可以删除符合条件的Object。

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]

1.13 rest，去掉第一个数组元素后剩下的元素。

1.14 slice，把数组中指定下标范围的元素”切出来”。

1.15 sortedIndex 有序数组中符合要求的插入第一个位置
第一个参数是希望被插入的有序数组，第二个参数是准备要插入的元素，第三个参数是希望排序的属性或者值

var dict = { 'data': { 'thirty': 30, 'forty': 40, 'fifty': 50 } };

// 本例使用了迭代函数
_.sortedIndex(['thirty', 'fifty'], 'forty', function(word) {
  return this.data[word];
}, dict);
// → 1

// 本例中{'x':40}是准备插入的元素，'x'是要排序的属性。
_.sortedIndex([{ 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
// → 1

1.16 sortedLastIndex 有序数组中符合要求的插入最后一个位置。

1.17 take 从数组第一个元素开始，拿掉n个元素

1.18 takeRight 从数组最后一个元素（右侧）开始，拿掉n个元素

1.19 takeWhile 从数组里按条件拿元素
第一个参数是数组，第二个参数是条件表达式

_.takeWhile([1, 2, 3], function(n) {
  return n < 3;
});
// → [1, 2]
var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false},
  { 'user': 'pebbles', 'active': true }
];

// using the `_.matches` callback shorthand
_.pluck(_.takeWhile(users, { 'user': 'barney', 'active': false }), 'user');
// → ['barney']

// using the `_.matchesProperty` callback shorthand
_.pluck(_.takeWhile(users, 'active', false), 'user');
// → ['barney', 'fred']

// using the `_.property` callback shorthand
_.pluck(_.takeWhile(users, 'active'), 'user');
// → []

1.20 union 多个数组合并成一个数组。

1.21 uniq 去重
第一个参数是数组；第二个参数可以是“有序数组 isSorted=true“、迭代函数、属性；第三个参数是 this绑定的迭代方法。

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

// 使用有序数组 `isSorted`
_.uniq([1, 1, 2], true);
// → [1, 2]

// 使用迭代函数（注意第三个参数是Math，而迭代函数中的this绑定的就是Math）
_.uniq([1, 2.5, 1.5, 2], function(n) {
  return this.floor(n);
}, Math);
// → [1, 2.5]

// 使用属性 `_.property` callback shorthand
_.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// → [{ 'x': 1 }, { 'x': 2 }]

1.22 zip 将多个一维数组压缩成若干个二维数组，原始数组的第一个元素被压到第一个数组里，第二个元素压到第二个数组里……

_.zip(['fred', 'barney'], [30, 40], [true, false]);
// → [['fred', 30, true], ['barney', 40, false]]

1.23 unzip 是”近似于“zip的反操作，但是返回值是二维数组：

var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]);
// → [['fred', 30, true], ['barney', 40, false]]

_.unzip(zipped);
// → [['fred', 'barney'], [30, 40], [true, false]]

1.24 zipWith 类似于 zip，但是多加了迭代函数作为参数。

_.zipWith([1, 2], [10, 20], [100, 200], _.add);
// → [111, 222]

1.25 unzipWith 类似于unzip，但是多加了迭代函数作为参数（注意unzipWith并不是zipWith的反操作）。

var zipped = _.zip([1, 2], [10, 20], [100, 200]);
// → [[1, 10, 100], [2, 20, 200]]

_.unzipWith(zipped, _.add);
// → [3, 30, 300]

1.26 without ，不要某些元素（只对基本数据类型起作用）

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

1.27 zipObject 数组转对象，pairs的反操作，只接受两个参数：第一个参数的数组元素作为key,第二个参数的数组元素作为value。

_.zipObject([['fred', 30], ['barney', 40]]);
// → { 'fred': 30, 'barney': 40 }

_.zipObject(['fred', 'barney'], [30, 40]);
// → { 'fred': 30, 'barney': 40 }