lodash基础

安装及文档

Npm安装：npm install lodash --save
全局引用：import _ from lodash
中文文档：lodash中文文档

数组操作

_chunk(array, number)

将数组转化为长度为number数组的数组

_.chunk(['a', 'b', 'c', 'd', 'e'],3)
// => [['a', 'b', 'c'], [ 'd', 'e']]

_.compact(array)

对数组的处理，去除数组中的false，null，‘’，undefine，NaN

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

_concat(array, [value])

返回一个旧数组和value组成的新数组

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

_.difference(array, [values])

返回的array中不含values中的值

// (A-（A和B的交集）)
_.difference([3, 2, 1], [4, 2]);
// => [3, 1]

_difference(array, [values],iteratee)

返回过滤后的新数组array

_.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x')
// => [{ 'x': 2 }]

_.drop(array, number)

切除数组前面number长度的数组，返回后面的数组，默认长度1

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

_.dropRight

切除后面的

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

_.fill(array, value, start, end)

改变原数组值，返回的array，默认全部修改，
(类似splite，修改的范围为[start, end))

_.fill([4, 6, 8, 10], '*', 1, 3);
// => [4, '*', '*', 10]

_.fromPairs(pairs)

返回一个新对象

_.fromPairs([['fred', 30], ['barney', 40]]);
// => { 'fred': 30, 'barney': 40 }

_take(array, number)

返回数组的前number长度的数组

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

_.inital(array)

返回删除最后一个元素外的所有元素的数组（修改原数组）

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

_union(array)

返回一个新的联合数组

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

_unionBy(array, iteratee)

返回一个新的联合数组

_.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

_.uniq(array)

返回去重后的数组

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

_.uniqBy(array, iteratee)

返回去重后的新数组

_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

集合

collection: (array|object): 一个用来迭代的集合
[predicate=_.identity ] (Array|function|object|string):每次迭代调用的函数
[orders] (string[]): 迭代函数的排列顺序
(collection,[predicate=.identity]) 简化为 => (Array, function())

_.every(Array, function())

通过断言函数检查collection中的所有元素是否都返回真值
一旦predicate返回假值，迭代马上停止，如果都返回真值，则返回true否则返回false
(判断数组的每一项是否都符合后面的条件)

var users = [
  { 'user': 'barney', 'age': 36, 'active': false },
  { 'user': 'fred',   'age': 40, 'active': false }
]
_.every(users, { 'user': 'barney', 'active': false });
// => false

_.every(users, ['active', false]);
// => true

_.filter(Array, function())

返回断言函数返回真值的所有元素组成的数组

var users = [
  { 'user': 'barney', 'age': 36, 'active': true },
  { 'user': 'fred',   'age': 40, 'active': false }
]
_.filter(users, { 'age': 36, 'active': true });
// => objects for ['barney']
 
_.filter(users, ['active', false]);
// => objects for ['fred']

_.groupBy(Array, function())

根据迭代器创建一个对象，key是遍历集合中的每个元素返回的结果，每个键对应的值为生成key的元素组成的数组

const data = [
 { name: '小明', age: 20, address: '北京' },
 { name: '小红', age: 21, address: '杭州' },
 { name: '小军', age: 22, address: '北京' },
 { name: '小百', age: 23, address: '杭州' },
]
const test2 = _.groupBy(data, 'address')
/**
* { 北京：[{ name: '小明', age: 20, address: '北京' },{ name: '小军', age: 22, address: '北京' }],
*   杭州：[ { name: '小红', age: 21, address: '杭州' },{ name: '小百', age: 23, address: '杭州' }]
* }
*/   

_.keyBy(Array, function())

创建一个对象组成，key是collection中每个元素经过迭代函数处理后返回的结果，每个key对应的值是生成key的最后一个元素。

const data = [
 { name: '小明', age: 20 },
 { name: '小红', age: 21 },
]
const test1 = _.keyBy(data, 'name')
// => {小明: { name: '小明', age: 20 }, 小红: { name: '小红', age: 21 }}

_.orderBy(Array,function(),‘desc’):排序

const data = [
 { name: '小明', age: 20 },
 { name: '小红', age: 21 },
]
const test2 = _.orderBy(data, ['age'], 'asc')
// => {小明: { name: '小明', age: 20 }, 小红: { name: '小红', age: 21 }}

例子

// 将数组对象中名字相同项value相加在一起
_.toArray(_.groupBy(this.filterCountData, 'name')).map(v => ({
      name: v[0].name,
      total: v.reduce((total, item) => total + (item.value?? 0), 0),
      data: v,
    }))