Lodash

1.什么是Lodash？

Lodash 是一个一致性、模块化、高性能的 JavaScript 实用工具库。其对各种方法、函数的封装，使得使用更加方便。

2.为什么使用Lodash？

Lodash 通过降低 array、number、objects、string 等等的使用难度从而让 JavaScript 变得更简单。 Lodash 的模块化方法非常适用于：

遍历 array、object 和 string
对值进行操作和检测
对值进行操作和检测
创建符合功能的函数

3.安装使用

浏览器环境

    <script src="lodash.js"></script>

通过Npm

    npm i -g npm 
    npm i --save lodash

Node环境中使用

    // 引入所有模块
    var _ = require('lodash');
    // 引入核心模块
    var _ = require('lodash/core');
    // 引入函数式编程模块
    var fp = require('lodash/fp')

常用函数

数组

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

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

    _.chunk([1,2,3,4,5,6,7,8,9],2) // [[1,2],[3,4],[5,6],[7,8],[9]]

_.compact(array)

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

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

_.concat(array, [values])

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

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

_.difference(array, [values])

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

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

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

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

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

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

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

    _.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])

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

    _.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)。

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

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

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


    var array = [1, 2, 3];
 
    _.fill(array, 'a') // => ['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），而不是元素本身。


    var users = [
        { 'user': 'barney',  'active': false },
        { 'user': 'fred',    'active': false },
        { 'user': 'pebbles', 'active': true }
    ];

    _.findIndex(users, function(o) { return o.user == 'barney'; }) // => 0
    _.findIndex(users, { 'user': 'fred', 'active': false }) // => 1
    _.findIndex(users, ['active', false]) // => 0
    _.findIndex(users, 'active') // => 2

.findLastIndex(array, [predicate=.identity], [fromIndex=array.length-1])

这个方式类似_.findIndex，区别是它是从右到左的迭代集合array中的元素。


    var users = [
        { 'user': 'barney',  'active': true },
        { 'user': 'fred',    'active': false },
        { 'user': 'pebbles', 'active': false }
    ];
 
    _.findLastIndex(users, function(o) { return o.user == 'pebbles'; }) // => 2
 
    _.findLastIndex(users, { 'user': 'barney', 'active': true }) // => 0
 
    _.findLastIndex(users, ['active', false]) // => 2
 
    _.findLastIndex(users, 'active') // => 0

_.head(array)

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


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

_.flatten(array)

减少一级array嵌套深度。


    _.flatten([1, [2, [3, [4]], 5]]) // => [1, 2, [3, [4]], 5]

_.flattenDeep(array)

将array递归为一维数组。


    _.flattenDeep([1, [2, [3, [4]], 5]]) //  => [1, 2, 3, 4, 5]

_.flattenDeep(array)

根据 depth 递归减少 array 的嵌套层级


    var array = [1, [2, [3, [4]], 5]];
    _.flattenDepth(array, 1) // => [1, 2, [3, [4]], 5]
    _.flattenDepth(array, 2) // => [1, 2, 3, [4], 5]

_.fromPairs(pairs)

与_.toPairs正好相反；这个方法返回一个由键值对pairs构成的对象。


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

_.indexOf(array, value, [fromIndex=0])

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


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

_.initial(array)

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


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

_.intersection([arrays])

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


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

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

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


    _.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor) // => [2.1] 
    _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x') // => [{ 'x': 1 }]

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

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


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

_.join(array, [separator=','])

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


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

_.last(array)

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


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

_.lastIndexOf(array, value, [fromIndex=array.length-1])

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


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

_.pull(array, [values])

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


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

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

获取array数组的第n个元素。如果n为负数，则返回从数组结尾开始的第n个元素。


   var array = ['a', 'b', 'c', 'd'];
 
    _.nth(array, 1);
    // => 'b'
 
    _.nth(array, -2);
    // => 'c';

_.pullAll(array, values)

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


   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)。


   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)。


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

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

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


   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中对应的元素，并返回被移除元素的数组。


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

.remove(array, [predicate=.identity])

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


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

.remove(array, [predicate=.identity])

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


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

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

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


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

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

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


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

Lodash学习笔记

Lodash

1.什么是Lodash？

2.为什么使用Lodash？

3.安装使用

常用函数

数组