Lodash 基础api

Lodash 常用

此处引用了Lodash使用简记整理的列表,经过二次加工后所得的文章

---

SameValueZero: 类似于 ===

---

lodash打包了Array/Object/String/Function里一些Api，好处是连ES6的也打包了，所以让你想在ES5环境下使用诸如Array reduce includes some every等时可以借lodash来帮忙

Array

.compact(list)

去除list里的空值(null," ",等)

.uniq(list)

去除list重复的值(不包含对象)

.pull(array, [...values]) ==修改数据!==

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

.difference(array, [...values])

创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中 这个方法会返回一个新数组。

.xor([...arrays])

创建一个给定数组唯一值的数组(==非交集==)，使用symmetric difference做等值比较。返回值的顺序取决于他们数组的出现顺序。

.intersection([...arrays])

创建唯一值的数组(交集)，这个数组包含所有给定数组都包含的元素，使用 SameValueZero进行相等性比较。（愚人码头注：可以理解为给定数组的交集）

.countBy(collection, [iteratee=_.identity])

创建一个组成对象，key（键）是经过 iteratee（迭代函数） 执行处理collection中每个元素后返回的结果，每个key（键）对应的值是 iteratee（迭代函数）返回该key（键）的次数（愚人码头注：迭代次数）。 iteratee 调用一个参数：(value)。

.without()

同上 ,区别:不会修改原数据 .find(collection, [predicate=_.identity], [fromIndex=0]) 遍历 collection（集合）元素，返回 predicate（断言函数）第一个返回真值的第一个元素。predicate（断言函数）调用3个参数： (value, index|key, collection)。

filter(list,function(item,index,array))

返回function返回值为true的数组

.remove(array, predicate(item,index,array)) ==修改数据!==

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

reject(list,function(item,index,array))

返回function返回值为false的数组

.union([arrays])

创建一个按顺序排列的唯一值的数组。所有给定数组的元素值使用SameValueZero做等值比较。（愚人码头注： arrays（数组）的并集，按顺序返回，返回数组的元素是唯一的）

.shuffle(collection)

创建一个被打乱值的集合。

.sample(collection)

从collection（集合）中获得一个随机元素。

_.sampleSize(collection, [n=1])

从collection（集合）中获得 n 个随机元素。

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

返回一个顺序的数组

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

返回一个倒序的数组

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

它允许指定 iteratee（迭代函数）结果如何排序。 如果没指定 orders（排序），所有值以升序排序。 否则，指定为"desc" 降序，或者指定为 "asc" 升序，排序对应值。

_.sortBy(collection, [iteratees=[_.identity]])

创建一个元素数组。 以 iteratee 处理的结果升序排序。 这个方法执行稳定排序，也就是说相同元素会保持原始排序。 iteratees 调用1个参数： (value)。

.chunk(list, length)

将list分割成若干长度为lenght的数组

merge(obj1,...obj) ==修改数据!==

Object

.assign(object, [sources]) ==修改数据!==

分配来源对象的可枚举属性到目标对象上。 来源对象的应用规则是从左到右，随后的下一个对象的属性会覆盖上一个对象的属性。

.assignIn(object, [sources]) ==修改数据!==

这个方法类似 _.assign， 除了它会遍历并继承来源对象的属性。

.defaults(object, [sources]) ==修改数据!==

分配来源对象的可枚举属性到目标对象所有解析为 undefined 的属性上。 来源对象从左到右应用。 一旦设置了相同属性的值，后续的将被忽略掉。

.findKey(object, [(item)=>booler])

除了它返回最先被 predicate 判断为真值的元素 key，而不是元素本身

findLastKey()

同上,只不过反向

.forIn(object, [iteratee=_.identity])

使用 iteratee 遍历对象的自身和继承的可枚举属性。 iteratee 会传入3个参数：(value, key, object)。 如果返回 false，iteratee 会提前退出遍历。

.forInRight()

同上,反向

.mapKeys(object, [iteratee=_.identity|string])

这个方法创建一个对象，对象的值与object相同，并且 key 是通过 iteratee 运行 object 中每个自身可枚举属性名字符串 产生的。iteratee调用三个参数： (value, key, object)。

如果 iteratee为字符串,则返回对应项的iteratee的属性值

.mapValues(object, [iteratee=_.identity])

创建一个对象，这个对象的key与object对象相同，值是通过 iteratee 运行 object 中每个自身可枚举属性名字符串产生的。 iteratee调用三个参数： (value, key, object)。

.invert(object)

object的key和value反转, 如果object 有重复的值，后面的值会覆盖前面的值。

.groupBy(collection, [iteratee=_.identity])

创建一个对象，key 是 iteratee 遍历 collection(集合) 中的每个元素返回的==结果==。 分组值的顺序是由他们出现在 collection(集合) 中的顺序确定的。每个键对应的值负责生成 key 的元素组成的数组。iteratee 调用 1 个参数： (value)。

.keyBy(collection, [iteratee=_.identity])

创建一个对象组成， key（键） 是 collection（集合）中的每个元素经过 iteratee（迭代函数） 处理后返回的结果。 每个 key（键）对应的值是生成key（键）的最后一个元素。iteratee（迭代函数）调用1个参数：(value)。

.omit(object, [props])

这个对象由[props]忽略属性之外的object自身和继承的可枚举属性组成。（愚人码头注：可以理解为删除object对象的属性）。

.pick()

保留 props 属性,同上

String

.startsWith([string=''], [target], [position=0])

判断string是否以target 开头,position为检索位置

.endsWith()

同上,检查字符串string是否以给定的target字符串结尾

.truncate([string=''], [options={}])

{
    length:30,
    omission:"...",
    separator:(RegExp||string)   //截断点规则
}

复制代码

截断string字符串，如果字符串超出了限定的最大值。 被截断的字符串后面会以omission 代替，omission 默认是 "..."。

_.template([string=''], [options={}])

Number

.clamp(number, [lower], upper)

返回限制在 lower 和 upper 之间的number值。

_.max _.min _.sum

最大值 最小值 求和,传入参数都是Array类型

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

产生一个包括 lower 与 upper 之间的数。 如果只提供一个参数返回一个0到提供数之间的数。 如果 floating 设为 true，或者 lower 或 upper 是浮点数，结果返回浮点数

.round(number, [precision=0])

根据 precision（精度） 四舍五入 number。

unit 工具

.times(n,iteratee(index))

调用 iteratee n 次，每次调用返回的结果存入到数组中

.uniqueId([prefix=''])

生成唯一ID。 如果提供了 prefix ，会被添加到ID前缀上。

lang 类型

.isNumber

.isInterger 是否为一个整数

.isFunction

.isPlainObject 是否是普通对象。 也就是说该对象由 Object 构造函数创建

.isArray

.isDate

.isElement 是否为DOM元素

.isNil 是否是 null 或者 undefined

.isEmpty 是否为一个空对象，集合，映射或者set

.isEqual 是否相等

注意:这个方法支持比较 arrays, array buffers, booleans, date objects, error objects, maps, numbers, Object objects, regexes, sets, strings, symbols, 以及 typed arrays. Object 对象值比较自身的属性，不包括继承的和可枚举的属性。 不支持函数和DOM节点比较

.isMatch(object, source)

执行一个深度比较，来确定 object 是否含有和 source 完全相等的属性值。

    _.isMatch({a:1,b:2}, { 'b': 2 }); // =>true

复制代码

.clone 浅拷贝 .cloneDeep 深拷贝

Function

.once(func)

创建一个只能调用 func 一次的函数。 重复调用返回第一次调用的结果。 func 调用时， this 绑定到创建的函数，并传入对应参数

.before(n, func)

创建一个调用func的函数，通过this绑定和创建函数的参数调用func，调用次数==不超过== n 次(即最多n-1次)。 之后再调用这个函数，将返回一次最后调用func的结果。

.after(n, func)

此方法创建一个函数，当他被调n或更多次之后将触发func

.debounce(func, [wait=0], [options={}])

创建一个 debounced（防抖动）函数，该函数会从上一次被调用后，延迟 wait 毫秒后调用 func 方法。 debounced函数提供一个 cancel 方法取消延迟的函数调用以及 flush 方法立即调用。 可以提供一个 options 对象决定如何调用 func 方法，options.leading 与|或 options.trailing 决定延迟前后如何触发（愚人码头注：是 先调用后等待 还是 先等待后调用）。 func 调用时会传入最后一次提供给 debounced函数的参数。 后续调用的 debounced函数返回是最后一次 func 调用的结果。