Lodash笔记-Array数组篇

_.chunk 将数组拆分为多个同一长度的区块，若数组最后一部分不够长度，则最后一部分单独为一个区块，返回一个二维数组
_.chunk(数组,区块的长度)

_.compact 将数组中的假值过滤掉，返回新数组，假值有：false、null、0、""、undefined、NaN
_.compact(数组)

_.pull 去除数组中相应的元素
_.pull(数组,要删除的元素值1,要删除的元素值2,...)
例：_.pull([1,1,2,2,3,3,4,4], 2, 3) => [1,1,4,4]

_.pullAt 去除数组中指定索引值的元素，返回移除完成后的数组
例：_.pullAt([1,2,3,4,5,6], 2, 4) => [1,2,4,6] 移除索引值为2和4的元素

_.difference 从第一个数组中，排除掉第二个数组中共同含有的值
_.difference(数组1,数组2)
例：_.difference([1,1,2,2,3,3,4,4],[2,3]) => [1,1,4,4]

_.drop 去除掉数组中的前n个元素，n默认为1
_.drop(数组,要去除掉的元素个数)

_.dropRight 去除掉数组中的后n个元素，n默认为1
_.dropRight(数组,要去除掉的元素个数)

_.fill 从数组的某个元素开始到某个元素结束，将元素内容替换掉，开始位置默认为0，结束位置默认为数组length
_.fill(数组,替换的值,开始位置,结束位置)
注：这个方法会改变原数组，不是返回新数组

_.findIndex 从数组中找出符合条件的元素，返回对应元素的索引值，未找到则返回-1
_.findIndex(数组,条件,从index开始查找)

_.flatten 对多维数组操作，去除一级嵌套，去除的是除最外层以外的第一级嵌套，返回一个新数组
_.flatten(多维数组)
例：_.flatten([1,2,[3,4,[5,[6]],7],8]) => [1,2,3,4,[5,[6]],7,8]

_.flattenDeep 对多维数组操作，递归去除，去除最外层以外的所有嵌套，返回一个新的一维数组
_.flatten(多维数组)
例：_.flatten([1,2,[3,4,[5,[6]],7],8]) => [1,2,3,4,5,6,7,8]

_.flattenDepth 对多维数组操作，递归去除，根据层级数，去除最外层以外的几层嵌套，返回一个新数组
_.flattenDepth(多维数组)
例：_.flatten([1,2,[3,4,[5,[6]],7],8], 2) => [1,2,3,4,5,[6],7,8]

_.head 返回数组的第一个元素，别名_.first

_.last 返回数组的最后一个元素

_.indexOf 返回数组中某个元素的索引值
_.indexOf(数组,要查找的元素,从index开始查找)

_.tail 返回数组除第一个元素外的所有元素，即去除掉第一个元素

_.initial 返回数组除最后一个元素外的所有元素，即去除掉最后一个元素

_.intersection 对多个数组进行操作，返回一个 由众数组共有的元素组成的 数组
_.intersection(数组1,数组2,数组3,...)
例：_.intersection([1,2,3],[2,3,4],[3,4,5]) => [3]

_.join 使用相应的分隔符号，对数组的每个元素进行分隔操作，返回字符串
_.join(数组,分隔符号)
例：join(['1','2','3'], '&') => '1&2&3'

_.nth 返回数组的第n个元素，若n为负数，则返回数组中从末尾开始第n个元素，n为正数时，n从0算起（相当于索引值）
例：_.nth([1,2,3,4,5], 1) => '2'; _.nth([1,2,3,4,5], -1) => '5'

_.remove 移除掉数组中符合函数规则的元素，返回被移除的元素组成的新数组
原数组会被修改，去除了被移除的元素
例：_.remove([1, 2, 3, 4], function(n){ return n%2 == 0 }) => [2, 4]
原数组变为[1, 3]

_.sortedIndex 往数组中插入某个值，通过二分法来计算插入在数组的哪个索引位置来保持数组的排序，返回插入的索引值
_.sortedIndex(数组, 要插入的值)
例：_.sortedIndex([3, 5], 4) => 1

_.uniq 数组去重，返回新的去重后的数组
例：_.uniq([2, 1, 2]) => [2, 1]

_.sortedUniq 数组去重，与_.uniq相似，但此方法可以优化排序数组

_.take 从数组的起始元素开始提取n个元素，返回这n个元素的数组，不加n则默认提取第一个元素
例：_.take([1, 2, 3, 4, 5], 3) => [1, 2, 3]

_.takeRight 与_.take相反，从数组的最后一个元素开始提取n个元素

_.union 给数组的元素使用SameValueZero做等值比较，返回元素的并集，返回的数组元素是唯一的
例：_.union([2], [1, 2]) => [2, 1]

_.zip 数组重组，第一个数组作为新数组的第一个元素，第二个数组作为新数组的第二个元素，以此类推
例：_.zip(['A', 'B'], [20, 30], [true, false]) => [['A', 20, true], ['B', 30, false]]

_.without 去除数组中相应的元素，与_.pull方法类似，但此方法会返回一个新数组
例：_.without([2, 1, 3, 2], 1, 2) => [3]

_.xor 返回一个由数组中的唯一元素组成的新数组
例：_.xor([1, 2 ,3], [2, 4], [1, 2]) => [3, 4] 3和4是数组中的唯一元素

原文地址：https://www.cnblogs.com/jane2160/p/11136636.html