lodash常用api 归类

已于 2022-06-22 21:46:06 修改
阅读量903 收藏 3
点赞数
分类专栏： javascript 文章标签： 前端 javascript 开发语言
于 2022-05-23 23:04:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42343307/article/details/124937077
版权

lodash常用api

中文文档 https://www.lodashjs.com/

Array：适用于数组类型，比如填充数据、查找元素、数组分片等操作

Collection：适用于数组和对象类型，部分适用于字符串，比如分组、查找、过滤等操作

Function：适用于函数类型，比如节流、延迟、缓存、设置钩子等操作

Lang：普遍适用于各种类型，常用于执行类型判断和类型转换

Math：适用于数值类型，常用于执行数学运算

Number：适用于生成随机数，比较数值与数值区间的关系

Object：适用于对象类型，常用于对象的创建、扩展、类型转换、检索、集合等操作

Seq：常用于创建链式调用，提高执行性能（惰性计算）

String：适用于字符串类型

使用方式

npm i -save lodash   \\全局安装

把一些方法封装在utils工具包里，然后再挂载到全局，因为挂载在全局成本还是挺大的，所以都是一些项目中比较常用的方法。按需引入了如下方法：

import _get from 'lodash/get'
import _map from 'lodash/map'
import _uniq from 'lodash/uniq'
import _pick from 'lodash/pick'
import _omit from 'lodash/omit'
import _isNaN from 'lodash/isNaN'
import _property from 'lodash/property'
import _findIndex from 'lodash/findIndex'
import _isUndefined from 'lodash/isUndefined'
import _isString from 'lodash/isString'
import _debounce from 'lodash/debounce'

数组

数组操作

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

将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块。

引入版本

3.0.0

参数
  1. array (Array): 需要处理的数组
  2. [size=1] (number): 每个数组区块的长度
返回

(Array): 返回一个包含拆分区块的新数组（注：相当于一个二维数组）。

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

_.compact(array) 数组除去假值

创建一个新数组，包含原数组中所有的非假值元素。例如false, null,0, "", undefined, 和 NaN 都是被认为是“假值”。

引入版本

0.1.0

参数
  1. array (Array): 待处理的数组
返回值

(Array): 返回过滤掉假值的新数组。

例子
_.compact([0, 1, false, 2, '', 3]);
// => [1, 2, 3]

_.concat(array, [values])多数组(值)链接成一个数组

创建一个新数组，将array与任何数组 或 值连接在一起。

引入版本

4.0.0

参数
  1. array (Array): 被连接的数组。
  2. [values] (…*): 连接的值。
返回值

(Array): 返回连接后的新数组。

例子
var array = [1];
var other = _.concat(array, 2, [3], [[4]]);
 
console.log(other);
// => [1, 2, 3, [4]]
 
console.log(array);
// => [1]

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

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

引入版本

4.0.0

参数
  1. array (Array): 要转换的数组。
  2. [separator=','] (string): 分隔元素。
返回值

(string): 返回连接字符串。

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

_.remove(array, [predicate=_.identity]) 移除数组中为真值的所有元素

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

Note: 和_.filter不同, 这个方法会改变数组 array。使用_.pull来根据提供的value值从数组中移除元素。

添加版本

2.0.0

参数
  1. array (Array): 要修改的数组。
  2. [predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
返回

(Array): 返回移除元素组成的新数组。

例子
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]

_.reverse(array)反转数组

反转array，使得第一个元素变为最后一个元素，第二个元素变为倒数第二个元素，依次类推。

Note: 这个方法会改变原数组 array，基于Array#reverse.

添加版本

4.0.0

参数
  1. array (Array): 要修改的数组。
返回

(Array): 返回 array.

例子
var array = [1, 2, 3];
 
_.reverse(array);
// => [3, 2, 1]
 
console.log(array);
// => [3, 2, 1]

_.unzip(array)

这个方法类似于_.zip，除了它接收分组元素的数组，并且创建一个数组，分组元素到打包前的结构。（：返回数组的第一个元素包含所有的输入数组的第一元素，第一个元素包含了所有的输入数组的第二元素，依此类推。）

添加版本

1.2.0

参数
  1. array (Array): 要处理的分组元素数组。
返回

(Array): 返回重组元素的新数组。

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

_.unzipWith(array, [iteratee=_.identity])

此方法类似于_.unzip，除了它接受一个iteratee指定重组值应该如何被组合。iteratee 调用时会传入每个分组的值： (…group)。

添加版本

3.8.0

参数
  1. array (Array): 要处理的分组元素数组。
  2. [iteratee=_.identity] (Function): 这个函数用来组合重组的值。
返回

(Array): 返回重组元素的新数组。

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

_.without(array, [values])

创建一个剔除所有给定值的新数组，剔除值的时候，使用SameValueZero做相等比较。

注意: 不像_.pull, 这个方法会返回一个新数组。

添加版本

0.1.0

参数
  1. array (Array): 要检查的数组。
  2. [values] (…*): 要剔除的值。
返回

(Array): 返回过滤值后的新数组。

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

_.xor([arrays])

创建一个给定数组唯一值的数组，使用symmetric difference做等值比较。返回值的顺序取决于他们数组的出现顺序。

添加版本

2.4.0

参数
  1. [arrays] (…Array): 要检查的数组。
返回

(Array): 返回过滤值后的新数组。

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

_.xorBy([arrays], [iteratee=_.identity])

这个方法类似_.xor ，除了它接受 iteratee（迭代器），这个迭代器 调用每一个 arrays（数组）的每一个值，以生成比较的新值。iteratee 调用一个参数：(value).

添加版本

4.0.0

参数
  1. [arrays] (…Array): 要检查的数组。
  2. [iteratee=_.identity] (Array|Function|Object|string): 调用每一个元素的迭代函数。
返回

(Array): 返回过滤值后的新数组。

例子
_.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// => [1.2, 3.4]
 
// The `_.property` iteratee shorthand.
_.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 2 }]

_.xorWith([arrays], [comparator])

该方法是像_.xor，除了它接受一个 comparator ，以调用比较数组的元素。 comparator 调用2个参数：(arrVal, othVal).

添加版本

4.0.0

参数
  1. [arrays] (…Array): 要检查的数组。
  2. [comparator] (Function): 调用每一个元素的比较函数。
返回

(Array): 返回过滤值后的新数组。

例子
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 }]

多个数组合并成特定的类型

_.zip([arrays])

创建一个分组元素的数组，数组的第一个元素包含所有给定数组的第一个元素，数组的第二个元素包含所有给定数组的第二个元素，以此类推。

添加版本

0.1.0

参数
  1. [arrays] (…Array): 要处理的数组。
返回

(Array): 返回分组元素的新数组。

例子
_.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]

_.zipObject([props=[]], [values=[]])

这个方法类似_.fromPairs，除了它接受2个数组，第一个数组中的值作为属性标识符（属性名），第二个数组中的值作为相应的属性值。

添加版本

0.4.0

参数
  1. [props=[]] (Array): The property identifiers.
  2. [values=[]] (Array): The property values.
返回

(Object): Returns the new object.

例子
_.zipObject(['a', 'b'], [1, 2]);
// => { 'a': 1, 'b': 2 }

_.zipObjectDeep([props=[]], [values=[]])

这个方法类似_.zipObject，除了它支持属性路径。

添加版本

4.1.0

参数
  1. [props=[]] (Array): 属性标识符（属性名）。
  2. [values=[]] (Array): 属性值。
返回

(Object): 返回新对象。

例子
_.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
// => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }

_.zipWith([arrays], [iteratee=_.identity])

这个方法类似于_.zip，不同之处在于它接受一个 iteratee（迭代函数），来 指定分组的值应该如何被组合。 该iteratee调用每个组的元素： (…group).

添加版本

3.8.0

参数
  1. [arrays] (…Array): 要处理的数组。
  2. [iteratee=_.identity] (Function): 函数用来组合分组的值。
返回

(Array): 返回分组元素的新数组。

例子
_.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
  return a + b + c;
});
// => [111, 222]

排除给定的值

_.difference(array, [values])

创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中。（注：即创建一个新数组，这个数组中的值，为第一个数字（array 参数）排除了给定数组中的值。）该方法使用SameValueZero做相等比较。结果值的顺序是由第一个数组中的顺序确定。

注意: 不像_.pullAll，这个方法会返回一个新数组。

引入版本

0.1.0

参数
  1. array (Array): 要检查的数组。
  2. [values] (…Array): 排除的值。
返回值

(Array): 返回一个过滤值后的新数组。

例子
_.difference([3, 2, 1], [4, 2]);
// => [3, 1]

_.differenceBy(array, [values], [iteratee=_.identity])

这个方法类似_.difference ，除了它接受一个 iteratee （注：迭代器）， 调用array 和 values 中的每个元素以产生比较的标准。 结果值是从第一数组中选择。iteratee 会调用一个参数：(value)。（注：首先使用迭代器分别迭代array 和 values中的每个元素，返回的值作为比较值）。

Note: 不像_.pullAllBy，这个方法会返回一个新数组。

引入版本

4.0.0

参数
  1. array (Array): 要检查的数组。
  2. [values] (…Array): 排除的值。
  3. [iteratee=_.identity] (Array|Function|Object|string): iteratee 调用每个元素。
返回值

(Array): 返回一个过滤值后的新数组。

例子
_.differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], Math.floor);
// => [3.1, 1.3]
 
// The `_.property` iteratee shorthand.
_.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
// => [{ 'x': 2 }]

_.differenceWith(array, [values], [comparator])

这个方法类似_.difference ，除了它接受一个 comparator （注：比较器），它调用比较array，values中的元素。 结果值是从第一数组中选择。comparator 调用参数有两个：(arrVal, othVal)。

Note: 不像_.pullAllWith, 这个方法会返回一个新数组。

引入版本

4.0.0

参数
  1. array (Array): 要检查的数组。
  2. [values] (…Array): 排除的值。
  3. [comparator] (Function): comparator 调用每个元素。
返回值

(Array): 返回一个过滤值后的新数组。

例子
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
 
_.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
// => [{ 'x': 2, 'y': 1 }]

数组切片

_.drop(array, [n=1])

创建一个切片数组，去除array前面的n个元素。（n默认值为1。）

引入版本

0.5.0

参数
  1. array (Array): 要查询的数组。
  2. [n=1] (number): 要去除的元素个数。
返回值

(Array): 返回array剩余切片。

例子
_.drop([1, 2, 3]);
// => [2, 3]
 
_.drop([1, 2, 3], 2);
// => [3]
 
_.drop([1, 2, 3], 5);
// => []
 
_.drop([1, 2, 3], 0);
// => [1, 2, 3]

_.dropRight(array, [n=1])

创建一个切片数组，去除array尾部的n个元素。（n默认值为1。）

引入版本

3.0.0

参数
  1. array (Array): 要查询的数组。
  2. [n=1] (number): 要去除的元素个数。
返回值

(Array): 返回array剩余切片。

例子
_.dropRight([1, 2, 3]);
// => [1, 2]
 
_.dropRight([1, 2, 3], 2);
// => [1]
 
_.dropRight([1, 2, 3], 5);
// => []
 
_.dropRight([1, 2, 3], 0);
// => [1, 2, 3]

_.dropRightWhile(array, [predicate=_.identity])

创建一个切片数组，去除array中从 predicate 返回假值开始到尾部的部分。predicate 会传入3个参数： (value, index, array)。

引入版本

3.0.0

参数
  1. array (Array): 要查询的数组。
  2. [predicate=_.identity] (Function): 这个函数会在每一次迭代调用。
返回值

(Array): 返回array剩余切片。

例子
var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.dropRightWhile(users, function(o) { return !o.active; });
// => objects for ['barney']
 
// The `_.matches` iteratee shorthand.
_.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
// => objects for ['barney', 'fred']
 
// The `_.matchesProperty` iteratee shorthand.
_.dropRightWhile(users, ['active', false]);
// => objects for ['barney']
 
// The `_.property` iteratee shorthand.
_.dropRightWhile(users, 'active');
// => objects for ['barney', 'fred', 'pebbles']

_.dropWhile(array, [predicate=_.identity])

创建一个切片数组，去除array中从起点开始到 predicate 返回假值结束部分。predicate 会传入3个参数： (value, index, array)。

引入版本

3.0.0

参数
  1. array (Array): 要查询的数组。
  2. [predicate=_.identity] (Function): 这个函数会在每一次迭代调用。
返回值

(Array): 返回array剩余切片。

例子
var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
 
_.dropWhile(users, function(o) { return !o.active; });
// => objects for ['pebbles']
 
// The `_.matches` iteratee shorthand.
_.dropWhile(users, { 'user': 'barney', 'active': false });
// => objects for ['fred', 'pebbles']
 
// The `_.matchesProperty` iteratee shorthand.
_.dropWhile(users, ['active', false]);
// => objects for ['pebbles']
 
// The `_.property` iteratee shorthand.
_.dropWhile(users, 'active');
// => objects for ['barney', 'fred', 'pebbles']

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

裁剪数组array，从 start 位置开始到end结束，但不包括 end 本身的位置。

Note: 这个方法用于代替Array#slice 来确保数组正确返回。

添加版本

3.0.0

参数
  1. array (Array): 要裁剪数组。
  2. [start=0] (number): 开始位置。
  3. [end=array.length] (number): 结束位置。
返回

(Array): 返回 数组array 裁剪部分的新数组。

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

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

添加版本

0.1.0

参数
  1. array (Array): 要检索的数组。
  2. [n=1] (number): 要提取的元素个数。
返回

(Array): 返回 array 数组的切片（从起始元素开始n个元素）。

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

_.takeRight(array, [n=1])

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

添加版本

3.0.0

参数
  1. array (Array): 要检索的数组。
  2. [n=1] (number): 要提取的元素个数。
返回

(Array): 返回 array 数组的切片（从结尾元素开始n个元素）。

例子
_.takeRight([1, 2, 3]);
// => [3]
 
_.takeRight([1, 2, 3], 2);
// => [2, 3]
 
_.takeRight([1, 2, 3], 5);
// => [1, 2, 3]
 
_.takeRight([1, 2, 3], 0);
// => []

_.takeRightWhile(array, [predicate=_.identity])

从array数组的最后一个元素开始提取元素，直到 predicate 返回假值。predicate 会传入三个参数： (value, index, array)。

添加版本

3.0.0

参数
  1. array (Array): 要检索的数组。
  2. [predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
返回

(Array): 返回 array 数组的切片。

例子
var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.takeRightWhile(users, function(o) { return !o.active; });
// => objects for ['fred', 'pebbles']
 
// The `_.matches` iteratee shorthand.
_.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
// => objects for ['pebbles']
 
// The `_.matchesProperty` iteratee shorthand.
_.takeRightWhile(users, ['active', false]);
// => objects for ['fred', 'pebbles']
 
// The `_.property` iteratee shorthand.
_.takeRightWhile(users, 'active');
// => []

_.takeWhile(array, [predicate=_.identity])

从array数组的起始元素开始提取元素，，直到 predicate 返回假值。predicate 会传入三个参数： (value, index, array)。

添加版本

3.0.0

参数
  1. array (Array): 需要处理的数组
  2. [predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
返回

(Array): 返回 array 数组的切片。

例子
var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false},
  { 'user': 'pebbles', 'active': true }
];
 
_.takeWhile(users, function(o) { return !o.active; });
// => objects for ['barney', 'fred']
 
// The `_.matches` iteratee shorthand.
_.takeWhile(users, { 'user': 'barney', 'active': false });
// => objects for ['barney']
 
// The `_.matchesProperty` iteratee shorthand.
_.takeWhile(users, ['active', false]);
// => objects for ['barney', 'fred']
 
// The `_.property` iteratee shorthand.
_.takeWhile(users, 'active');
// => []

数组值(索引)的查找替换

_.fill(array, value, [start=0], [end=array.length])值替换

使用 value 值来填充（替换） array，从start位置开始, 到end位置结束（但不包含end位置）。

Note: 这个方法会改变 array（注：不是创建新数组）。

引入版本

3.2.0

参数
  1. array (Array): 要填充改变的数组。
  2. value (*): 填充给 array 的值。
  3. [start=0] (number): 开始位置（默认0）。
  4. [end=array.length] (number):结束位置（默认array.length）。
返回值

(Array): 返回 array。

例子
var array = [1, 2, 3];
 
_.fill(array, 'a');
console.log(array);
// => ['a', 'a', 'a']
 
_.fill(Array(3), 2);
// => [2, 2, 2]
 
_.fill([4, 6, 8, 10], '*', 1, 3);
// => [4, '*', '*', 10]

_.findIndex(array, [predicate=_.identity], [fromIndex=0]) 返回数组元素索引值

该方法类似_.find，区别是该方法返回第一个通过 predicate 判断为真值的元素的索引值（index），而不是元素本身。

引入版本

1.1.0

参数
  1. array (Array): 要搜索的数组。
  2. [predicate=_.identity] (Array|Function|Object|string): 这个函数会在每一次迭代调用。
  3. [fromIndex=0] (number): The index to search from.
返回值

(number): 返回找到元素的 索引值（index），否则返回 -1。

例子
var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
 
_.findIndex(users, function(o) { return o.user == 'barney'; });
// => 0
 
// The `_.matches` iteratee shorthand.
_.findIndex(users, { 'user': 'fred', 'active': false });
// => 1
 
// The `_.matchesProperty` iteratee shorthand.
_.findIndex(users, ['active', false]);
// => 0
 
// The `_.property` iteratee shorthand.
_.findIndex(users, 'active');
// => 2

_.head(array)返回数组的第一个元素

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

引入版本

0.1.0

别名

_.first

参数
  1. array (Array): 要查询的数组。
返回值

(*): 返回数组 array的第一个元素。

例子
_.head([1, 2, 3]);
// => 1
 
_.head([]);
// => undefined

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

获取array中的最后一个元素。

引入版本

0.1.0

参数

  1. array (Array): 要检索的数组。

  2. 返回值

(*): 返回array中的最后一个元素

例子
_.last([1, 2, 3]);
// => 3

_.indexOf(array, value, [fromIndex=0]) 返回在数组中的索引

使用SameValueZero 等值比较，返回首次 value 在数组array中被找到的 索引值， 如果 fromIndex 为负值，将从数组array尾端索引进行匹配。

引入版本

0.1.0

参数
  1. array (Array): 需要查找的数组。
  2. value (*): 需要查找的值。
  3. [fromIndex=0] (number): 开始查询的位置。
返回值

(number): 返回 值value在数组中的索引位置, 没有找到为返回-1。

例子
_.indexOf([1, 2, 1, 2], 2);
// => 1
 
// Search from the `fromIndex`.
_.indexOf([1, 2, 1, 2], 2, 2);
// => 3

_.lastIndexOf(array, value, [fromIndex=array.length-1])返回匹配值的索引值

这个方法类似_.indexOf ，区别是它是从右到左遍历array的元素。

引入版本

0.1.0

参数
  1. array (Array): 要搜索的数组。
  2. value (*): 要搜索的值。
  3. [fromIndex=array.length-1] (number): 开始搜索的索引值。
返回值

(number): 返回匹配值的索引值，否则返回 -1。

例子
_.lastIndexOf([1, 2, 1, 2], 2);
// => 3
 
// Search from the `fromIndex`.
_.lastIndexOf([1, 2, 1, 2], 2, 2);
// => 1

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

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

引入版本

0.1.0

参数
  1. array (Array): 要查询的数组。
返回值

(Array): 返回截取后的数组array。

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

_.tail(array)去除数组array中的第一个元素

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

添加版本

4.0.0

参数
  1. array (Array): 要检索的数组。
返回

(Array): 返回 array 数组的切片（除了array数组第一个元素以外的全部元素）。

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

数组交集

_.intersection([arrays])给定数组的交集

创建唯一值的数组，这个数组包含所有给定数组都包含的元素，使用SameValueZero进行相等性比较。（注：可以理解为给定数组的交集）

引入版本

0.1.0

参数
  1. [arrays] (…Array): 待检查的数组。
返回值

(Array): 返回一个包含所有传入数组交集元素的新数组。

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

_.intersectionBy([arrays], [iteratee=_.identity])

这个方法类似_.intersection，区别是它接受一个 iteratee 调用每一个arrays的每个值以产生一个值，通过产生的值进行了比较。结果值是从第一数组中选择。iteratee 会传入一个参数：(value)。

引入版本

4.0.0

参数
  1. [arrays] (…Array): 待检查的数组。
  2. [iteratee=_.identity] (Array|Function|Object|string): iteratee（迭代器）调用每个元素。
返回值

(Array): 返回一个包含所有传入数组交集元素的新数组。

例子
_.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
// => [2.1]
 
// The `_.property` iteratee shorthand.
_.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }]

_.intersectionWith([arrays], [comparator])

这个方法类似_.intersection，区别是它接受一个 comparator 调用比较arrays中的元素。结果值是从第一数组中选择。comparator 会传入两个参数：(arrVal, othVal)。

引入版本

4.0.0

参数
  1. [arrays] (…Array): 待检查的数组。
  2. [comparator] (Function): comparator（比较器）调用每个元素。
返回值

(Array): 返回一个包含所有传入数组交集元素的新数组。

例子
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([arrays])

创建一个按顺序排列的唯一值的数组。所有给定数组的元素值使用SameValueZero做等值比较。（注： arrays（数组）的并集，按顺序返回，返回数组的元素是唯一的）

添加版本

0.1.0

参数
  1. [arrays] (…Array): 要检查的数组。
返回

(Array): 返回一个新的联合数组。

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

_.unionBy([arrays], [iteratee=_.identity])

这个方法类似_.union ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）的每个元素以产生唯一性计算的标准。iteratee 会传入一个参数：(value)。

添加版本

4.0.0

参数
  1. [arrays] (…Array): 要检查的数组。
  2. [iteratee=_.identity] (Array|Function|Object|string): 迭代函数，调用每个元素。
返回

(Array): 返回一个新的联合数组。

例子
_.unionBy([2.1], [1.2, 2.3], Math.floor);
// => [2.1, 1.2]
 
// The `_.property` iteratee shorthand.
_.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

_.unionWith([arrays], [comparator])

这个方法类似_.union， 除了它接受一个 comparator 调用比较arrays数组的每一个元素。 comparator 调用时会传入2个参数： (arrVal, othVal)。

添加版本

4.0.0

参数
  1. [arrays] (…Array): 要检查的数组。
  2. [comparator] (Function): 比较函数，调用每个元素。
返回

(Array): 返回一个新的联合数组。

例子
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 }]

移除数组中所有给定值相等的元素

_.pull(array, [values])

移除数组array中所有和给定值相等的元素，使用SameValueZero 进行全等比较。

注意： 和_.without 方法不同，这个方法会改变数组。使用_.remove 从一个数组中移除元素。

引入版本

2.0.0

参数
  1. array (Array): 要修改的数组。
  2. [values] (…*): 要删除的值。
返回值

(Array): 返回 array.

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

_.pullAll(array, values)

这个方法类似_.pull，区别是这个方法接收一个要移除值的数组。

Note: 不同于_.difference, 这个方法会改变数组 array。

引入版本

4.0.0

参数
  1. array (Array): 要修改的数组。
  2. values (Array): 要移除值的数组。
返回值

(Array): 返回 array。

例子
var array = [1, 2, 3, 1, 2, 3];
 
_.pullAll(array, [2, 3]);
console.log(array);
// => [1, 1]

_.pullAllBy(array, values, [iteratee=_.identity])

这个方法类似于_.pullAll ，区别是这个方法接受一个 iteratee（迭代函数） 调用 array 和 values的每个值以产生一个值，通过产生的值进行了比较。iteratee 会传入一个参数： (value)。

Note: 不同于_.differenceBy, 这个方法会改变数组 array。

引入版本

4.0.0

参数
  1. array (Array): 要修改的数组。
  2. values (Array): 要移除值的数组。
  3. [iteratee=_.identity] (Array|Function|Object|string): iteratee（迭代器）调用每个元素。
返回值

(Array): 返回 array.

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

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

这个方法类似于_.pullAll，区别是这个方法接受 comparator 调用array中的元素和values比较。comparator 会传入两个参数：(arrVal, othVal)。

注意: 和_.differenceWith 不同, 这个方法会改变数组 array。

引入版本

4.6.0

参数
  1. array (Array): 要修改的数组。
  2. values (Array): 要移除值的数组。
  3. [comparator] (Function): comparator（比较器）调用每个元素。
返回值

(Array): 返回 array。

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

_.pullAt(array, [indexes])

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

Note: 和_.at不同, 这个方法会改变数组 array。

引入版本

3.0.0

参数
  1. array (Array): 要修改的数组。
  2. [indexes] (…(number|number[])): 要移除元素的索引。
返回值

(Array): 返回移除元素组成的新数组。

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

数组中插入值 排序去重

_.sortedIndex(array, value) 插入到尽可能小的索引位置

使用二进制的方式检索来决定 value值 应该插入到数组中 尽可能小的索引位置，以保证array的排序。

添加版本

0.1.0

参数
  1. array (Array): 要检查的排序数组。
  2. value (*): 要评估的值。
返回

(number): 返回 value值 应该在数组array中插入的索引位置 index。

例子
_.sortedIndex([30, 50], 40);
// => 1

_.sortedIndexBy(array, value, [iteratee=_.identity])

这个方法类似_.sortedIndex ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）元素，返回结果和value 值比较来计算排序。iteratee 会传入一个参数：(value)。

添加版本

4.0.0

参数
  1. array (Array): 要检查的排序数组。
  2. value (*): 要评估的值。
  3. [iteratee=_.identity] (Array|Function|Object|string): 迭代函数，调用每个元素。
返回

(number): 返回 value值 应该在数组array中插入的索引位置 index。

例子
var objects = [{ 'x': 4 }, { 'x': 5 }];
 
_.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
// => 0
 
// The `_.property` iteratee shorthand.
_.sortedIndexBy(objects, { 'x': 4 }, 'x');
// => 0

_.sortedIndexOf(array, value)

这个方法类似_.indexOf，除了它是在已经排序的数组array上执行二进制检索。

添加版本

4.0.0

参数
  1. array (Array): 要搜索的数组。
  2. value (*): 搜索的值。
返回

(number): 返回匹配值的索引位置，否则返回 -1。

例子
_.sortedIndexOf([4, 5, 5, 5, 6], 5);
// => 1

_.sortedLastIndex(array, value)

此方法类似于_.sortedIndex，除了 它返回 value值 在 array 中尽可能大的索引位置（index）。

添加版本

3.0.0

参数
  1. array (Array): 要检查的排序数组。
  2. value (*): 要评估的值。
返回

(number): 返回 value值 应该在数组array中插入的索引位置 index。

例子
_.sortedLastIndex([4, 5, 5, 5, 6], 5);
// => 4

_.sortedLastIndexBy(array, value, [iteratee=_.identity])

这个方法类似_.sortedLastIndex ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）元素，返回结果和value 值比较来计算排序。iteratee 会传入一个参数：(value)。

添加版本

4.0.0

参数
  1. array (Array): 要检查的排序数组。
  2. value (*): 要评估的值。
  3. [iteratee=_.identity] (Array|Function|Object|string): 迭代函数，调用每个元素。
返回

(number): 返回 value值 应该在数组array中插入的索引位置 index。

例子
var objects = [{ 'x': 4 }, { 'x': 5 }];
 
_.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
// => 1
 
// The `_.property` iteratee shorthand.
_.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
// => 1

_.sortedLastIndexOf(array, value)

这个方法类似_.lastIndexOf，除了它是在已经排序的数组array上执行二进制检索。

添加版本

4.0.0

参数
  1. array (Array): 要搜索的数组。
  2. value (*): 搜索的值。
返回

(number): 返回匹配值的索引位置，否则返回 -1。

例子
_.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
// => 3

_.sortedUniq(array) 排序去重

这个方法类似_.uniq，除了它会优化排序数组。

添加版本

4.0.0

参数
  1. array (Array): 要检查的数组。
返回

(Array): 返回一个新的不重复的数组。

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

_.sortedUniqBy(array, [iteratee]) 排序去重

这个方法类似_.uniqBy，除了它会优化排序数组。

添加版本

4.0.0

参数
  1. array (Array): 要检查的数组。
  2. [iteratee] (Function): 迭代函数，调用每个元素。
返回

(Array): 返回一个新的不重复的数组。

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

_.uniq(array) 去重

创建一个去重后的array数组副本。使用了SameValueZero 做等值比较。只有第一次出现的元素才会被保留。

添加版本

0.1.0

参数
  1. array (Array): 要检查的数组。
返回

(Array): 返回新的去重后的数组。

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

_.uniqBy(array, [iteratee=_.identity])

这个方法类似_.uniq ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）的每个元素以产生唯一性计算的标准。iteratee 调用时会传入一个参数：(value)。

添加版本

4.0.0

参数
  1. array (Array): 要检查的数组。
  2. [iteratee=_.identity] (Array|Function|Object|string): 迭代函数，调用每个元素。
返回

(Array): 返回新的去重后的数组。

例子
_.uniqBy([2.1, 1.2, 2.3], Math.floor);
// => [2.1, 1.2]
 
// The `_.property` iteratee shorthand.
_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

_.uniqWith(array, [comparator])

这个方法类似_.uniq， 除了它接受一个 comparator 调用比较arrays数组的每一个元素。 comparator 调用时会传入2个参数： (arrVal, othVal)。

添加版本

4.0.0

参数
  1. array (Array): 要检查的数组。
  2. [comparator] (Function): 比较函数，调用每个元素。
返回

(Array): 返回新的去重后的数组。

例子
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 }]

数学

_.add(augend, addend)求和

两个数相加。

添加版本

3.4.0

参数
  1. augend (number): 相加的第一个数。
  2. addend (number): 相加的第二个数。
返回

(number): 返回总和。

例子
_.add(6, 4);
// => 10

_.ceil(number, [precision=0])向上舍入

根据 precision（精度） 向上舍入 number。（注： precision（精度）可以理解为保留几位小数。）

添加版本

3.10.0

参数
  1. number (number): 要向上舍入的值。
  2. [precision=0] (number): 向上舍入的的精度。
返回

(number): 返回向上舍入的值。

例子
_.ceil(4.006);
// => 5
 
_.ceil(6.004, 2);
// => 6.01
 
_.ceil(6040, -2);
// => 6100

_.divide(dividend, divisor) 两数相除

两个数相除。

添加版本

4.7.0

参数
  1. dividend (number): 相除的第一个数。
  2. divisor (number): 相除的第二个数。
返回

(number): 返回商数。

例子
_.divide(6, 4);
// => 1.5

_.floor(number, [precision=0])向下舍入

根据 precision（精度） 向下舍入 number。（注： precision（精度）可以理解为保留几位小数。）

添加版本

3.10.0

参数
  1. number (number): 要向下舍入的值。
  2. [precision=0] (number): 向下舍入的精度。
返回

(number): 返回向下舍入的值。

例子
_.floor(4.006);
// => 4
 
_.floor(0.046, 2);
// => 0.04
 
_.floor(4060, -2);
// => 4000

_.max(array)最大值

计算 array 中的最大值。 如果 array 是 空的或者假值将会返回 undefined。

添加版本

0.1.0

参数
  1. array (Array): 要迭代的数组。
返回

(*): 返回最大的值。

例子
_.max([4, 2, 8, 6]);
// => 8
 
_.max([]);
// => undefined

_.maxBy(array, [iteratee=_.identity])数组中对象里面的最大值

这个方法类似_.max 除了它接受 iteratee 来调用 array中的每一个元素，来生成其值排序的标准。 iteratee 会调用1个参数: (value) 。

添加版本

4.0.0

参数
  1. array (Array): 要迭代的数组。
  2. [iteratee=_.identity] (Function): 调用每个元素的迭代函数。
返回

(*): 返回最大的值。

例子
var objects = [{ 'n': 1 }, { 'n': 2 }];
 
_.maxBy(objects, function(o) { return o.n; });
// => { 'n': 2 }
 
// The `_.property` iteratee shorthand.
_.maxBy(objects, 'n');
// => { 'n': 2 }

_.mean(array) 平均值

计算 array 的平均值。

添加版本

4.0.0

参数
  1. array (Array): 要迭代的数组。
返回

(number): 返回平均值。

例子
_.mean([4, 2, 8, 6]);
// => 5

_.meanBy(array, [iteratee=_.identity])平均值

这个方法类似_.mean， 除了它接受 iteratee 来调用 array中的每一个元素，来生成其值排序的标准。 iteratee 会调用1个参数: (value) 。

添加版本

4.7.0

参数
  1. array (Array): 要迭代的数组。
  2. [iteratee=_.identity] (Function): 调用每个元素的迭代函数。
返回

(number): 返回平均值。

例子
var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
 
_.meanBy(objects, function(o) { return o.n; });
// => 5
 
// The `_.property` iteratee shorthand.
_.meanBy(objects, 'n');
// => 5

_.min(array)最小值

计算 array 中的最小值。 如果 array 是 空的或者假值将会返回 undefined。

添加版本

0.1.0

参数
  1. array (Array): 要迭代的数组。
返回

(*): 返回最小的值。

例子
_.min([4, 2, 8, 6]);
// => 2
 
_.min([]);
// => undefined

_.minBy(array, [iteratee=_.identity])最小值

这个方法类似_.min 除了它接受 iteratee 来调用 array中的每一个元素，来生成其值排序的标准。 iteratee 会调用1个参数: (value) 。

添加版本

4.0.0

参数
  1. array (Array): 要迭代的数组。
  2. [iteratee=_.identity] (Function): 调用每个元素的迭代函数。
返回

(*): 返回最小的值。

例子
var objects = [{ 'n': 1 }, { 'n': 2 }];
 
_.minBy(objects, function(o) { return o.n; });
// => { 'n': 1 }
 
// The `_.property` iteratee shorthand.
_.minBy(objects, 'n');
// => { 'n': 1 }

_.multiply(multiplier, multiplicand)两数相乘

两个数相乘。

添加版本

4.7.0

参数
  1. augend (number): 相乘的第一个数。
  2. addend (number): 相乘的第二个数。
返回

(number): 返回乘积。

例子
_.multiply(6, 4);
// => 24

_.round(number, [precision=0])四舍五入

根据 precision（精度） 四舍五入 number。

添加版本

3.10.0

参数
  1. number (number): 要四舍五入的数字。
  2. [precision=0] (number): 四舍五入的精度。
返回

(number): 返回四舍五入的数字。

例子
_.round(4.006);
// => 4
 
_.round(4.006, 2);
// => 4.01
 
_.round(4060, -2);
// => 4100

_.subtract(minuend, subtrahend)两数差

亮数相减。

添加版本

4.0.0

参数
  1. minuend (number): 相减的第一个数。
  2. subtrahend (number): 相减的第二个数。
返回

(number): 返回差。

例子
_.subtract(6, 4);
// => 2

_.sum(array)求和

计算 array 中值的总和

添加版本

3.4.0

参数
  1. array (Array): 要迭代的数组。
返回

(number): 返回总和。

例子
_.sum([4, 2, 8, 6]);
// => 20

_.sumBy(array, [iteratee=_.identity]) 求和

这个方法类似_.summin 除了它接受 iteratee 来调用 array中的每一个元素，来生成其值排序的标准。 iteratee 会调用1个参数: (value) 。

添加版本

4.0.0

参数
  1. array (Array): 要迭代的数组。
  2. [iteratee=_.identity] (Function): 调用每个元素的迭代函数。
返回

(number): 返回总和。

例子
var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
 
_.sumBy(objects, function(o) { return o.n; });
// => 20
 
// The `_.property` iteratee shorthand.
_.sumBy(objects, 'n');
// => 20

数字

_.clamp(number, [lower], upper) 返回被限制的值

返回限制在 lower 和 upper 之间的值。

添加版本

4.0.0

参数
  1. number (number): 被限制的值。
  2. [lower] (number): 下限。
  3. upper (number): 上限。
返回

(number): 返回被限制的值。

例子
_.clamp(-10, -5, 5);
// => -5
 
_.clamp(10, -5, 5);
// => 5

_.inRange(number, [start=0], end)值是否在范围内

检查 n 是否在 start 与 end 之间，但不包括 end。 如果 end 没有指定，那么 start 设置为0。 如果 start 大于 end，那么参数会交换以便支持负范围。

添加版本

3.3.0

参数
  1. number (number): 要检查的值。
  2. [start=0] (number): 开始范围。
  3. end (number): 结束范围。
返回

(boolean): 如果number在范围内 ，那么返回true，否则返回 false。

例子
_.inRange(3, 2, 4);
// => true
 
_.inRange(4, 8);
// => true
 
_.inRange(4, 2);
// => false
 
_.inRange(2, 2);
// => false
 
_.inRange(1.2, 2);
// => true
 
_.inRange(5.2, 4);
// => false
 
_.inRange(-3, -2, -6);
// => true

_.random([lower=0], [upper=1], [floating])随机数

产生一个包括 lower 与 upper 之间的数。 如果只提供一个参数返回一个0到提供数之间的数。 如果 floating 设为 true，或者 lower 或 upper 是浮点数，结果返回浮点数。

注意: JavaScript 遵循 IEEE-754 标准处理无法预料的浮点数结果。

添加版本

0.7.0

参数
  1. [lower=0] (number): 下限。
  2. [upper=1] (number): 上限。
  3. [floating] (boolean): 指定是否返回浮点数。
返回

(number): 返回随机数。

例子
_.random(0, 5);
// => an integer between 0 and 5
 
_.random(5);
// => also an integer between 0 and 5
 
_.random(5, true);
// => a floating-point number between 0 and 5
 
_.random(1.2, 5.2);
// => a floating-point number between 1.2 and 5.2
沉迷...
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lodash3.6 Api文档离线帮助手册
04-12
lodash3.6 Api文档离线帮助手册。
lodash常用API
10-21 2771
_.chunk 将数组进行切分 这个函数把数组按照一定的长度分开，返回新的数组。（片段化数组） const arr = [1,2,3,4,5,6,7,8,9]; _.chunk(arr,2); // =>[[1,2],[3,4],[5,6],[7,8],[9]] compact 去除假值。（将所有的空值，0，NaN过滤掉） _.compact...
lodash 开发中常用的api
z止于至善的博客
04-06 838
lodash 开发中常用的api isEmpty(value) 说明 检查value是否为一个空对象，集合，映射或者set。 判断的依据是除非是有枚举属性的对象，length 大于 0 的 arguments object, array, string 或类jquery选择器。 参数 value(*): 要检查的值。 返回 (boolean): 如果value为空，那么返回true，否则返回false。 ...
Lodash 常用API中文参考
weixin_33935505的博客
03-26 253
lodash和underscore都是现在非常流行的两个javascript库，提供了一套函数式编程的实用功能。 而lodash本身最初也是underscore的一个fork，因为和其他(Underscore.js的)贡献者意见相左。 lodash主要使用了延迟计算，所以也使得lodash的性能远远超过了Underscore。在lodash中使用延迟计算，也就意味着当我们使用链式方法时，在直接...
超火js库: Lodash API例子
weixin_34115824的博客
12-27 155
lodash.js是一款超火的js库，在npm上平均周下载量达到了惊人的12,374,096,github start36K!大量框架都用到了lodash,包括拥有123kstart的vue本文对比lodash英文文档，加上一些小栗子和个人的经验~~,希望能帮到你们 lodash采用了immutable的思想，永远不会改变原数据，而是会...
Halcon常用算子归类脑图
03-29
Halcon常用算子归类脑图
Javascript常用脚本归类
10-26
Javascript常用脚本归类Javascript常用脚本归类Javascript常用脚本归类Javascript常用脚本归类Javascript常用脚本归类Javascript常用脚本归类
常用函数归类.xlsx
05-09
基本囊括了日常办公常用函数（财务、信息、工程函数除外），并对每种函数的各种用法有详细的讲解和举例，函数类型有：统计、数学、日期和时间、查找和引用、文本、逻辑。部分函数（如YEAR()、MONTH()等）因使用方法...
常用汉字偏旁归类表
03-14
【汉字偏旁归类表】是汉字学习与研究的重要工具，尤其对于汉字的分类和记忆具有很大的帮助。偏旁，也称为部首，是构成汉字的基本元素，它们可以帮助我们理解和辨认汉字，甚至推测字义。以下是根据描述和部分内容解析...
android常用的API接口调用
08-04
本文将对 Android 常用的 API 接口调用进行归类和详细介绍。 显示网页 要在 Android 应用程序中显示网页，可以使用 Intent.ACTION_VIEW 动作和 Uri.parse() 方法来解析 URL。例如： ```java Uri uri = Uri.parse(...
jackson 忽略多余字段_Lodash那些“多余”和让人眼前一亮的 API
weixin_39737947的博客
11-28 296
作者：JS强迫症患者链接：https://juejin.im/post/5ed3cd366fb9a047f129c39a本文初衷是想列举一些比较“多余”的API以及对应原生JS写法；后面发现API过多，精力有限，慢慢的变成记录那些有助于提高开发效率的API，希望对您有所帮助。对于那些，根据名字或者描述便能知道其实际用途的API，笔者未做Demo演示。各位看官可以查看对应官方文档便能快速应...
Lodash常用用法总结
weixin_34216196的博客
12-02 475
Lodash是一个轻量级的JavaScript工具函数库，它方便了日常开发中对数据的操作，提高了开发效率。 ​ 日常开发中，通常会对数据，特别是数组和对象进行各种读写等操作：比如去重，拷贝，合并，过滤，求交集，求和等等。根据平时开发中对数据的操作，我对Lodash常见的用法做了以下总结，方便今后的学习和整理。 Array Creat...
lodash使用技巧--利用lodash将数据分类汇总（笔记）
weixin_34417635的博客
08-29 3215
var result=[ { name:'减1元', quantity:1, amount:1 }, { name:'减3元', quantity:1, amount:3 }, { name:'减2元', quantity:1, ...
JS【详解】 数组 (含常用的操作数组的lodash)
朝阳39的博客
05-18 1500
创建数组 方式 1 - 字面量 let arr1 = []; let arr2 = [1,2,3]; 方式 2 - 新建数组实例 let arr1 = new Array(); // 参数为空,得到一个空数组 [] let arr2 = new Array(4); // 参数为一个数值时表示数组的长度，得到 [null,null,null,null] let arr3 = new Array(15, 16, 17); // 参数为多个数值时表示数组中的元素，得到[15,16,17] 方式.
【javascript】学习Lodash：让你的JS代码更具优雅和易读性
weixin_55846296的博客
06-20 787
随着JavaScript语言的不断发展，越来越多的开发人员依赖它的强大特性和适应性来构建现代Web应用程序和网站。但是，随着代码库变得越来越大和复杂，我们可能会遇到一些处理不同数据结构的问题。这时，我们可以使用 Lodash工具包来让我们的JS代码更加优雅和易于阅读。Lodash是一个很流行的JavaScript实用工具库，提供了很多有用的函数方法来简化我们的日常任务。Lodash提供了很多高效实用的函数，如lodash.map等，可以我们简单地对数组，对象，字符串等常用数据类型进行操作。
lodash API 和 es6 API相似用法总结
脚步
01-25 277
import _ from 'lodash'; let a={'aa':'bb'} es6 Object.values(a) 等价于 _.values(a)  返回['bb']    IE不支持es6此API es6 arry.includes(value) 等价于 _.includes(arry,value)  判断value是否在arry中  IE不支持es6此API...
Lodash - 集合方法 _.groupBy 分组
欢迎来到猫猫的博客 o_o ，如有问题，欢迎提出改正~
01-16 4237
对数据进行分组，返回一个对象 参数： 参数1：collection（Array|Object） 参数2：iteratee 示例1： let arr1 = [6.1, 4.2, 6.3]; console.log(_.groupBy(arr1, Math.floor)); // 向下取整后分组=> { '4': [4.2], '6': [6.1, 6.3] } 示例2： let arr2 = ["one", "two", "thre...
lodash常用api之Array数组方法篇
热门推荐
喵大嗷的博客
05-07 1万+
_.flattenDeep(array)：将array递归为一个一维数组 如果不用lodash，个人的思路就是将array使用JSON.stringify转化为字符串，然后使用字符串的replace方法将字符'['和']'去除掉 使用这个方法会方便很多 _.flattenDeep([1, [2, [3, [4]], 5]]); // => [1, 2, 3, 4, 5] ...
lodash-es 工具库常用工具函数和案例详解，干货满满
最新发布
2401_84166497的博客
04-15 2333
Lodash中文文档Lodash 是一个一致性、模块化、高性能的 JavaScript 实用工具库，算是从Underscore分离出来的超集。Lodash 通过降低 array、number、objects、string 等等的使用难度从而让 JavaScript 变得更简单。遍历 array、object 和 string对值进行操作和检测创建符合功能的函数lodash为了良好的浏览器兼容性，它使用了旧版 es5 的模块语法；而lodash-es。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值