Lodash 总结

数组

数组创建

随机创建数组 range

_.range([start=0], end, [step=1])

  let arr = _.range(24)
    console.log(arr)
    
     // [0, 1, 2, 3, ... , 23]

创建相同元素数组 fill

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

   let arr = _.fill(Array(5), 100)
    
    console.log(arr) // [100, 100, 100, 100, 100]

读取数组

获取数组中最后一个元素 last

_.last(array)

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

获取数组中倒数第二个元素 nth

_.nth(array, [n=0])

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

console.log(lastSecondElement) // 4

获取对象数组中某一同名属性的属性值集合 map

.map(collection, [iteratee=.identity])

  let users = [{
          id: 12,
          name: 'Adam',
          hobbies: [
            {name: 'running', index: 100},
            {name: 'cycling', index: 95}
          ]
       },{
          id: 14,
          name: 'Bob',
          hobbies: [
            {name: 'movie', index: 98},
            {name: 'music', index: 85}
          ]
       },{
          id: 16,
          name: 'Charlie',
          hobbies: [
           {name: 'travelling', index: 90},
           {name: 'fishing', index: 88}
          ]
       },{
          id: 18,
          name: 'David',
          hobbies: [
           {name: 'walking', index: 99},
           {name: 'football', index: 85}
         ]                
    
    
       }
    ]
    let userIds = _.map(users, 'id')
    let mostFavouriteHobbies = _.map(users, 'hobbies[0].name')
    
    console.log(userIds)
    // [12, 14, 16, 18]
    console.log(mostFavouriteHobbies)
     // ["running", "movie", "travelling", "walking"]

获取对象数组中某一属性值最大的对象 maxBy

.maxBy(array, [iteratee=.identity])

 let arr = [{a:1, b: 2, c: {d:4}}, {a:3, b: 4, c: {d:6}}]
    let maxBObj = _.maxBy(arr, 'b')
    
    console.log(maxBObj)
     // {a: 3, b: 4, c: {d: 6}}

找出两个数组中元素值相同的元素 intersection

_.intersection([arrays])

let arr1 = [2, 1, {a: 1, b: 2}]
let arr2 = [2, 3, {a: 1, b: 2}]
let intersection = _.intersection(arr1, arr2) 

console.log(intersection) 
// [2]

求数值数组中元素值的平均数 mean

_.mean(array)

let numbers = [1, 2, 3, 4, 5]
let average = _.mean(numbers)

console.log(average)
 // 3

求对象数组中某个属性值的平均数 meanBy

.meanBy(array, [iteratee=.identity])

let objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }]
let average = _.meanBy(objects, 'n')

console.log(average) 
// 5

获取数组中前n个元素，不改变原数组 take

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

let arr = [1, 2, 3, 4, 5]
let part1Arr = _.take(arr, 4)
let part2Arr = _.take(arr, 6)
let part3Arr = _.take([], 5)

console.log(part1Arr) // [1, 2, 3, 4]console.log(part2Arr) // [1, 2, 3, 4, 5]console.log(part3Arr) // []

删除数组

删除数组中值为falsy的元素

_.compact(array)

let arr = [0, 1, false, 2, '', 3, null, undefined, NaN]
let truthyArr = _.compact(arr) 

console.log(truthyArr) 
// [1, 2, 3]

数组格式化

去重 uniq

_.uniq(array)

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

console.log(uniqArr)
 // [2, 1, '2', true]

排序。对象数组，根据对象中的某个属性的值，升序或降序排序

.orderBy(collection, [iteratees=[.identity]], [orders])

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

分割数组 chunk

_.chunk(array, [size=1])

    let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    let [left, right] = _.chunk(arr, 5)
    
    console.log(left) 
    // [1, 2, 3, 4, 5]console.log(right)
     // [6, 7, 8, 9, 10]

脱掉一层[] flatten

_.flatten(array)

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

console.log(cities) // ["南京市", "苏州市", "杭州市", "绍兴市"]

将多维数组转为一维数组 flattenDeep

_.flattenDeep(array)

let flattenedArr = _.flattenDeep([1, [2, [3, [4]], 5]]);

console.log(flattenedArr) // [1, 2, 3, 4, 5]

对象

创建

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

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

let keys = ["x", "y"]
let values = [10, 10]
let obj = _.zipObject(keys, values) 

console.log(obj) // {x: 10, y: 10}

合并对象 assign

_.assign(object, [sources])

let desObj = {name: '', gender: 'male', job: 'developer'}
let sourceObj = {name: 'Tom', job: ''}
let mergedObj = _.assign(desObj, sourceObj)

console.log(mergedObj)
 // {name: "Tom", gender: "male", job: ""}

深拷贝对象 cloneDeep

_.cloneDeep(value)

let sourceObj = {department_id: 1, permissions: {management: [1, 2, 3, 4], store: [11, 12, 13, 14]}}
let desObj = _.cloneDeep(sourceObj)
desObj.permissions.store.push(15, 16)

console.log(desObj)
// {department_id: 1, permissions: {management: [1, 2, 3, 4], store: [11, 12, 13, 14, 15, 16]}}console.log(sourceObj)
// {department_id: 1, permissions: {management: [1, 2, 3, 4], store: [11, 12, 13, 14]}}

合并多个对象中key值相同的键值对

_.merge(object, [sources])

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"}

读取

判断对象中是否有某个属性 has

_.has(object, path)

let obj = {a: [{b: {c: 3}}]}
let hasC = _.has(obj, 'a[0].b.c')

console.log(hasC) 
// true

获取对象中的某个属性的值 get

_.get(object, path, [defaultValue])

	 let obj = {a: [{b: {c: 3}}]}
    let c = _.get(obj, 'a[0].b.c')
    
    console.log(c) // 3

更新

设置对象中的某个属性的值 set

_.set(object, path, value)

let obj = {a: [{b: {c: 3}}]}
let newObj = _.set(obj, 'a[0].b.c', 4);

console.log(obj.a[0].b.c); // 4

对多个对象相同属性的属性值求和。 sumBy

let customers = {
  new_customer: {0: 33, 1: 5, ... , 23: 0},
  old_customer: {0: 22, 1: 7, ... , 24: 0}
}
let customer = {}
let keys = _.keys(customers.new_customer)
let values = _.values(customers)
_.map(keys, key => {
  customer[key] = _.sumBy(values, key)
})

customers.customer = customer

console.log(customers)
// console
{
  customer: {0: 55, 1: 12, ... , 23: 0}
  new_customer: {0: 33, 1: 5, ... , 23: 0}
  old_customer: {0: 22, 1: 7, ... , 23: 0}
}

数字类型操作

生成一个随机数，范围n~m random

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

let random1 = _.random(2, 5)
let random2 = _.random(5)

console.log(random1) // 2, 3, 4, 5console.log(random2) // 0, 1, 2, 3, 4, 5

判断数据类型 isNumber isInteger isPlainObject

 _.isNumber(value)
 _.isInteger(value)
 
// ...
 
_.isPlainObject(value)

    let variable = 'hello';
    // Numberconsole.log(_.isNumber(variable));
    // Integerconsole.log(_.isInteger(variable));
    // Booleanconsole.log(_.isBoolean(variable));
    // Stringconsole.log(_.isString(variable));
    // Nullconsole.log(_.isNull(variable));
    // Undefinedconsole.log(_.isUndefined(variable));
    // Arrayconsole.log(_.isArray(variable));
    // Functionconsole.log(_.isFunction(variable));
    // Objectconsole.log(_.isPlainObject(variable));
    // Dateconsole.log(_.isDate(variable));
    
    // DOM elementconsole.log(_.isElement(variable));
    

数据类型转换 toArray toInteger toNumber toString

_.toArray

    _.toArray('abc') // ["a", "b", "c"]

- 
_.toInteger

    _.toInteger(3.2); // 3
    _.toInteger('3.2'); // 3

- 
_.toNumber

    _.toNumber('3.2') // 3.2

- 
_.toString

    _.toString(1); // "1"
    _.toString([1, 2, 3]); // "1,2,3"

工具

显式链模式 chain value

var users = [
  { 'user': 'barney',  'age': 36 },
  { 'user': 'fred',    'age': 40 },
  { 'user': 'pebbles', 'age': 1 }
];
 
var youngest = _
  .chain(users)
  .sortBy('age')
  .map(function(o) {
    return o.user + ' is ' + o.age;
  })
  .head()
  .value();
// => 'pebbles is 1'

方法链序列 tap thru

_([1, 2, 3])
 .tap( 
	 function(array) {
	// 改变传入的数组
	   array.pop();
	 }
  )
 .reverse()
 .value();
// => [2, 1]

重复多次某个元素

.times(n, [iteratee=.identity])

   const dateParams = _.times(2, () =>'2018-08-27');
   console.log(dateParams) 
   // ["2018-08-27", "2018-08-27"]