lodash 是一个一致性、模块化、高性能的 JavaScript 实用工具库。
通过降低 array、number、objects、string 等等的使用难度从而让 JavaScript 变得更简单。或者说是 lodash 封装了很多 string、array、object 等常见数据类型的处理函数。

lodash 的模块化方法 非常适用于：

  • 遍历 array、object 和 string
  • 对值进行操作和检测
  • 创建符合功能的函数

lodash 的全局对象是 _.

安装

  1. bootCND bootCND 搜索 “lodash” 拷贝地址
  2. 官网下载文件 lodash 中文文档
  3. npm
    1. <!-- 留着偷懒直接复制粘贴 -->
    2. <script src="https://cdn.bootcdn.net/ajax/libs/lodash.js/4.17.21/lodash.min.js"></script>

    数组

    查找下标 _.indexOf(array, value, [fromIndex=0])

    返回首次 value 在数组 array 中被找到的下标。
    1. _.indexOf([1, 2, 1, 2], 2); // 1
    与之相似的是 _.lastIndexOf(array, value, [fromIndex=array.length-1]) 右到左遍历 array 的元素。

    拆分数组 _.chunk(array, [size=1])

    将 array 拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果 array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块。很适合做发牌程序
    1. _.chunk(['a', 'b', 'c', 'd'], 2); // => [['a', 'b'], ['c', 'd']] 
    2. _.chunk(['a', 'b', 'c', 'd'], 3);// => [['a', 'b', 'c'], ['d']]

    删除 n 个 item _.drop(array, [deleteCount=1])

    创建一个切片数组，去除 array 前面的 n 个元素。
    1. _.drop([1, 2, 3]); // => [2, 3]
    2. _.drop([1, 2, 3], 2); // => [3]
    3. _.drop([1, 2, 3], 5); // => []
    4. _.drop([1, 2, 3], 0); // => [1, 2, 3]
    与之相似的还有 _.dropRight(array, [n=1]) 从右向左删。

    查找满足条件的 item 的 index .findIndex(array, [predicate=.identity], [fromIndex=0])

    返回找到元素的 index，否则返回 -1 ```jsx 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

  1. 与之相似的 _.findLastIndex(array, [predicate=_.identity], [fromIndex=array.length-1]) 从后向前查找。
  2. <a name="ttF90"></a>
  3. ### 获取 array 中第一个 item _.head(array)
  4. 获取数组 array 的第一个元素。
  5. ```jsx
  6. _.head([1, 2, 3]); // => 1
  8. _.head([]); // => undefined

与之相似的是 _.last(array) 获取array中的最后一个元素

扁平化 _.flattenDeep(array)

将array递归为一维数组。

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

与之相似的 _.flattenDepth(array, [depth=1]) 根据传入的参数扁平化层级。

删除数组中的最后一个元素_.initial(array)

获取数组array中除了最后一个元素之外的所有元素。

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

交集 _.intersection([arrays])
查找交集。

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

去重 _.uniq(array)

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

去重 _.sortedUniq(array)

  1. _.sortedUniq([1, 1, 2]); // => [1, 2]

并集 _.union([arrays])

按顺序返回，返回数组的元素是唯一的。

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

差集 _.xor([arrays])

创建一个给定数组唯一值的数组。

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

数组转字符串 _.join(array, [separator=’,’])

将 array 中的所有元素转换为由 separator 分隔的字符串。类似于 join

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

获取数组中第 n 个 item _.nth(array, [n=0])

获取array数组的第n个元素。

  1. var array = ['a', 'b', 'c', 'd'];
  2. _.nth(array, 1); // => 'b'
  3. _.nth(array, -2); // => 'c';

移除 _.pullAllWith(array, values, [comparator])

接受 comparator 调用 array 中的元素和 values 比较。comparator 会传入两个参数：(arrVal, othVal)。会改变原数组。

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

移除 _.pullAt(array, [indexes])

根据索引 indexes，移除 array 中对应的元素，并返回被移除元素的数组。会改变原数组。

  1. var array = [5, 10, 15, 20];
  2. var evens = _.pullAt(array, 1, 3);
  3. console.log(array); // => [5, 15]
  4. console.log(evens); // => [10, 20]

移除 .remove(array, [predicate=.identity])

移除数组中 predicate（断言）返回为真值的所有元素，并返回移除元素组成的数组。predicate（断言） 会传入3个参数： (value, index, array)。会改变原数组。

  1. var array = [1, 2, 3, 4];
  2. var evens = _.remove(array, function(n) {
  3.   return n % 2 == 0;
  4. });
  5. console.log(array); // => [1, 3]
  6. console.log(evens); // => [2, 4]

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

同原生 slice

获取第二个及以后的所有 item _.tail(array)

获取除了 array 第一个元素以外的全部元素。

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

截取 n 个 item _.take(array, [n=1])

创建一个数组切片，从 array 的起始元素开始提取 n 个元素。

  1. _.take([1, 2, 3]); // => [1]
  2. _.take([1, 2, 3], 2); // => [1, 2]
  3. _.take([1, 2, 3], 5); // => [1, 2, 3]
  4. _.take([1, 2, 3], 0); // => []

与之相似的是 _.takeRight(array, [n=1]) 从后向前截取

删除 _.without(array, [values])

创建一个剔除所有给定值的新数组。

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