vue中loadsh的常用方法

Lodash：是一套工具库，它内部封装了诸多对字符串、数组、对象等常见数据类型的处理函数，其中部分是目前ECMAScript尚未制订的规范，但同时被业界所认可的辅助函数。

在vue中的使用

• 安装依赖包
  npm install lodash -save
• 引入
  import _ from ‘lodash’
  Vue.prototype._ = _

lodash的主要辅助函数

- Array:适用于数组类型

_.fill(array, value, [start=0], [end=array.length])
使用 value 值来填充（替换） array，从start位置开始, 到end位置结束（但不包含end位置）。 这个方法会改变 array（不是创建新数组）。

    let a = _.fill([1, 2, 3, 4, 5, 6], 8)
    let b = _.fill([1, 2, 3, 4, 5, 6], 8, 0, 3)
    console.log(a, b)
  }

_.last(array) 获取array中的最后一个元素。

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

_.nth(array, [n=0]) 获取数组中的第几个元素,如果n为负数，则从末尾开始数第几位

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

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

    let objArr = [{ 'a': 9, 'b': 4, 'c': 4 }, { 'a': 5, 'b': 7, 'c': 5 }]
    console.log(_.maxBy(objArr, 'b')) //{ 'a': 5, 'b': 7, 'c': 5 }比较b输出大的那一项
    console.log(_.maxBy(objArr, function (o) { return o.a })) //{ 'a': 9, 'b': 4, 'c': 4 }

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

console.log(_.intersection([1, 2, 4], [1, 2, 6], [1, 2, 9]))   //[1,2]

_.take(array, [n=1]) 获取数组中的从起始位置开始的n个元素,默人为1

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

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

console.log(_.compact([null, 1, 5, undefined, 6])) //[1,5,6]

_.uniq(array) 相当于数组去重，只返回出现过一次的数据组成的数组

console.log(_.uniq([1, 2, 1, 4]))  //[1,2,4]

_.chunk(array, [size=1]) 将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块.返回一个包含拆分区块的新数组（相当于一个二维数组）。

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

** _.flatten(array) **减少最外层嵌套的数组，返回一个新的数组

console.log(_.flatten([1,2,3,[4,5,[6]]))    //[1,2,3,4,5,[6]]  

_.flattenDeep(array) 将多维数组递归为1维数组

console.log(_.flattenDeep([1, [2, 3, 4, [6, 7]]]))  //[1,2,3,4,6,7]

_.zipObject([props=[]], [values=[]]) 取第一个数组中的值作为对象的键，第二个中的值为值，组成一个对象

console.log(_.zipObject(['name', 'age'], ['gx', 21]))    //{name: "gx", age: 21}

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

.countBy(collection, [iteratee=.identity]) 统计值出现的次数，
参数
collection (Array|Object): 一个用来迭代的集合。
[iteratee=_.identity] (Array|Function|Object|string): 一个迭代函数，用来转换key（键）。

console.log(_.countBy([2.6, 5.7, 3.5, 2.9], Math.floor))  //{2: 2, 3: 1, 5: 1}
console.log(_.countBy(['ewwe', 'efd', 'feww', 'ew'], 'length'))  //{2: 1, 3: 1, 4: 2}
console.log(_.countBy(['ewwe', 'efd', 'feww', 'ew'])) //{ewwe: 1, efd: 1, feww: 1, ew: 1}

.forEach(collection, [iteratee=.identity]) 遍历对象，遍历数组
参数
collection (Array|Object): 一个用来迭代的集合。
[iteratee=_.identity] (Function): 每次迭代调用的函数。

   _.forEach([{ 'a': 1, 'b': 2 }], val => {
      console.log(val)   //{a: 1, b: 2}
    })
    _.forEach({ 'a': 1, 'b': 2 }, (value, key) => {
      console.log(value)   //1    //2
    })

.every(collection, [predicate=.identity]) 检验所有元素是否为真值， 这个方法对于对于 空集合返回 true，因为空集合的 任何元素都是 true
参数：
[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。

console.log(_.every([1, 2, 3], Boolean))  //true
console.log(_.every([1, 2, undefined], Boolean))  //false
let textArr = [
      { 'name': 'gx', 'age': 18, 'sex': false },
      { 'name': 'hh', 'age': 18, 'sex': false },
 ]
 console.log(_.every(textArr, 'sex')) //false
console.log(_.every(textArr, ['sex', false])) //true
 console.log(_.every(textArr, { 'name': 'gx', 'age': 18, 'sex': false })) //false

**.filter(collection, [predicate=.identity])**返回过滤后的新数组
参数
collection (Array|Object): 一个用来迭代的集合。
[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。

    let textArr = [
      { 'name': 'gx', 'age': 18, 'sex': false },
      { 'name': 'hh', 'age': 18, 'sex': false },
    ]
    console.log(_.filter(textArr, function (o) { return !o.sex })) //[{name: "gx", age: 18, sex: false} {name: "hh", age: 18, sex: false}]
    console.log(_.filter(textArr, { 'name': 'gx' })) //[{name: "gx", age: 18, sex: false}]

.find(collection, [predicate=.identity], [fromIndex=0]) 查找符合条件的元素，返回第一位true的值，如果没有匹配到返回undefined
参数
collection (Array|Object): 一个用来迭代的集合。
[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
[fromIndex=0] (number): 开始搜索的索引位置。

    let textArr = [
      { 'name': 'gx', 'age': 18, 'sex': true },
      { 'name': 'hh', 'age': 15, 'sex': true },
    ]
    console.log(_.find(textArr, function (o) { return o.age > 15 }))  //{name: "gx", age: 18, sex: false}
    console.log(_.find(textArr, function (o) { return o.age > 15 }, 1)) //undefined
    console.log(_.find(textArr, { 'name': 'hh' }))  //{name: "hh", age: 15, sex: false}
    console.log(_.find(textArr, 'sex')) //{ 'name': 'hh', 'age': 15, 'sex': false }
    

_.includes(collection, value, [fromIndex=0]) 判断一个值或者字符串是否存在，如果找到 value 返回 true， 否则返回 false。
参数
collection (Array|Object|string): 要检索的集合。
value (*): 要检索的值。
[fromIndex=0] (number): 要检索的 索引位置。

    console.log(_.includes('123', '1')) //true
    console.log(_.includes([1, 2, 3], 1, 2))//false
    console.log(_.includes({ 'a': 1, 'b': 2 }, 2)) //true

.map(collection, [iteratee=.identity]) 遍历元素并可以操作元素，返回新的映射后数组
参数
collection (Array|Object): 用来迭代的集合。
[iteratee=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。

    getNum(n) {
      return n * n
    },
    let textArr = [
      { 'name': 'gx', 'age': 18, 'sex': true },
      { 'name': 'hh', 'age': 15, 'sex': false },
    ]
    console.log(_.map(textArr, 'name')) //['gx','hh']
    console.log(_.map([2, 4], getNum)) //[4,16]

_.size(collection)
返回collection（集合）的长度，如果集合是类数组或字符串，返回其 length ；如果集合是对象，返回其可枚举属性的个数。返回值为number

   console.log(_.size('aghbs')) //5
    console.log(_.size([1, 2, 3])) //3
    console.log(_.size({ 'name': '1', 'she': 3 })) //2