数组

1.【last】获取数组中最后一个元素

let arr = [1, 2, 3, 4, 5]
let lastElement = _.last(arr) 
console.log(lastElement) // 5

2. 【nth】 获取数组中倒数第二个元素

let arr = [1, 2, 3, 4, 5]
let lastSecondElement = _.nth(-2) 
console.log(lastSecondElement) // 4

3. 【uniq】 去重

let arr = [2, 1, 2, '2', true]
let uniqArr = _.uniq(arr)
console.log(uniqArr) // [2, 1, '2', true]

4. 【uniqBy】 数组对象去重(根据对象中某个参数)

let uniqArr = _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x')
console.log(uniqArr) // [{ 'x': 1 }, { 'x': 2 }]

5. 【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 }]

6.【zipObject】通过数组[“x”, “y”] 和 数组[10, 10] 创建对象 {x: 10, y: 10}

let keys = ["x", "y"]
let values = [10, 10]
let obj = _.zipObject(keys, values) 
console.log(obj) // {x: 10, y: 10}

7.【flatten】脱掉一层

_.flatten([1, [2, [3, [4]], 5]]) // => [1, 2, [3, [4]], 5]
[1, [2, [3, [4]], 5]].flat(默认参数为1 最大 Infinity)  // => [1, 2, [3, [4]], 5]  

let address = {
  '江苏省': ['南京市', '苏州市'],
  '浙江省': ['杭州市', '绍兴市']
}
let cities = _.flatten(_.values(address))
console.log(cities) // ["南京市", "苏州市", "杭州市", "绍兴市"]

10.【intersection】所有数组的交集

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

11.intersectionBy

// 对于数组下嵌套json数据的情况下，根据指定属性id（根据实际的业务需要可任意指定的），
//取出两个数组的交集，返回的新数组为两个数组的交集
const arr = intersectionBy(delArr1, delArr2, 'id')

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

12.【join】

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

对象

1.Get

import { get } from 'lodash' 
// 从一个变量中取值，第一参数表示变量，第二个表示该节点对应的名称，第三个参数表示当取不到的时候设置的默认值
const a1 = get(nextProps, 'treeVal', undefined)

2.【merge】合并多个对象中key值相同的键值对

let obj1 = {'9': {name: '乐购超市'}}
let obj2 = {'9': {storeToken: 'xxx'}}
let obj3 = {'9': {storePosition: 'Hangzhou'}}
let mergedObj = _.merge(obj1, obj2, obj3) 
console.log(mergedObj)
// 9: {name: "乐购超市", storeToken: "xxx", storePosition: "Hangzhou"}

3.【omit】根据某一key进行删除

var object = { 'a': 1, 'b': '2', 'c': 3 };
_.omit(object, ['a', 'c']);
// => { 'b': '2' }

4.【omitBy】

var object = { 'a': 1, 'b': '2', 'c': 3 };
_.omitBy(object, _.isNumber);
// => { 'b': '2' }

集合

1.排序 【orderBy】（对象数组，根据对象中的某个属性的值，升序或降序排序）

let users = [
  {user: 'Tom', age: 25},
  {user: 'Amy', age: 23},
  {user: 'Perter', age: 22},
  {user: 'Ben', age: 29}
]
let sortedUsers = _.orderBy(users, 'age', 'desc')
console.log(sortedUsers)
// [{user: "Ben", age: 29}, {user: "Tom", age: 25}, {user: "Amy", age: 23}, {user: "Perter", age: 22}]

2.【groupBy】合并某一key的value相同的对象

_.groupBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': [4.2], '6': [6.1, 6.3] }
// The `_.property` iteratee shorthand.
_.groupBy(['one', 'two', 'three'], 'length');
// => { '3': ['one', 'two'], '5': ['three'] }

函数

1.【throttle】

//节流函数
throttle(function () {
      //回调函数
      })
    }, 1000, { leading: true, trailing: false })
 
//该函数共接收三个参数，第一个表示要执行的回调，第二个表示等待时间，第三个参数为Object，具体看下
//{ leading: true, trailing: false }，节流开始前执行一次，节流时间到达后不再执行
//{ leading: false, trailing: true }，在节流开始前不执行，节流时间到达后再执行一次
//{ leading: true, trailing: true }，指定调用在节流开始前执行，节流时间到达后再执行一次
 
//节流函数在很多业务场景中都用到过，防止用户频繁点击，函数的触发过于频繁都可以用此方法来做限制的；