loadsh是一个非常实用的工具库，小菜在见到这个工具库就被深深的吸引了。有了这个工具库大部分的处理就不需要自己写工具了，想想就美滋滋。官方的网站https://www.lodashjs.com/，这个是有中文翻译的http://lodash.think2011.net/chunk，小菜这篇博客只是针对自己能够快速查阅所做的一个记录。

1.Array(数组)

适用于数组类型，比如填充数据、查找元素、数组分片等操作

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

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

_.compact(array)

创建一个移除了所有假值的数组。例如：false、null、 0、”“、undefined， 以及NaN 都是 “假值”.

_.concat(array, [values])

创建一个用任何数组 或 值连接的新数组

_.difference(array, [values])

创建一个差异化后的数组，不包括使用 SameValueZero 方法提供的数组。

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

这个方法类似 _.difference，除了它接受一个 iteratee 调用每一个数组和值。iteratee 会传入一个参数：(value)

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

这个方法类似 _.difference，除了它接受一个 comparator 调用每一个数组元素的值。 comparator 会传入2个参数：(arrVal, othVal)。

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

裁剪数组中的前 N 个数组，返回剩余的部分。

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

从右边开始裁剪数组中的 N 个数组，返回剩余的部分。

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

从右边开始裁剪数组，起点从 predicate 返回假值开始。predicate 会传入3个参数：(value, index, array)。

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

裁剪数组，起点从 predicate 返回假值开始。predicate 会传入3个参数：(value, index, array)。

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

指定 值 填充数组，从 start 到 end 的位置，但不包括 end 本身的位置。

findIndex(array, [predicate=.identity])

这个方法类似 _.find。除了它返回最先通过 predicate 判断为真值的元素的 index ，而不是元素本身。

_.findLastIndex

这个方式类似 _.findIndex ， 不过它是从右到左的

_.first->head

获取数组第一个元素

_.flatten

向上一级展平数组嵌套

_.flattenDeep

递归展平 数组.

_.flattenDepth

根据 depth 递归展平 数组 的层级

_.fromPairs

反向版 _.toPairs，这个方法返回一个由键值对构成的对象

_.head

获得数组的首个元素

_.indexOf

根据 value 使用 SameValueZero 等值比较返回数组中首次匹配的 index， 如果 fromIndex 为负值，将从数组尾端索引进行匹配，如果将 fromIndex 设置为 true，将使用更快的二进制检索机制。

_.initial

获取数组中除了最后一个元素之外的所有元素

_.intersection

创建一个包含所有使用 SameValueZero 进行等值比较后筛选的唯一值数组。

_.intersectionBy

这个方法类似 _.intersection，除了它接受一个 iteratee 调用每一个数组和值。iteratee 会传入一个参数：(value)

_.intersectionWith

这个方法类似 _.intersection，除了它接受一个 comparator 调用每一个数组和值。iteratee 会传入2个参数：((arrVal, othVal)

_.join

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

_.last

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

_.lastIndexOf

这个方法类似 _.indexOf，除了它是从右到左遍历元素的。 这个方法类似 _.indexOf except that it iterates over elements of array from right to left.

_.nth

获取数组索引n处的元素。如果n为负数，则返回结尾的第n个元素。

_.pull

移除所有经过 SameValueZero 等值比较为 true 的元素

_.pullAll

这个方式类似 _.pull，除了它接受数组形式的一系列值。

_.pullAllBy

这个方法类似 _.pullAll，除了它接受一个 comparator 调用每一个数组元素的值。 comparator 会传入一个参数：(value)。

_.pullAllWith

此方法类似于_.pullAll，除了它接受比较器，该比较器被调用以将数组元素与值进行比较。使用两个参数调用比较器：（arrVal，othVal）。

_.pullAt

根据给的 indexes 移除对应的数组元素并返回被移除的元素。

_.remove

移除经过 predicate 处理为真值的元素，并返回被移除的元素。predicate 会传入3个参数：(value, index, array)

_.reverse

数组反转

_.slice

创建一个裁剪后的数组，从 start 到 end 的位置，但不包括 end 本身的位置。

_.sortedIndex

使用二进制的方式检索来决定 value 应该插入在数组中位置。它的 index 应该尽可能的小以保证数组的排序。

_.sortedIndexBy

这个方法类似 _.sortedIndex，除了它接受一个 iteratee 调用每一个数组和值来计算排序。iteratee 会传入一个参数：(value)。

_.sortedIndexOf

这个方法类似 _.indexOf，除了它是执行二进制来检索已经排序的数组的。

_.sortedLastIndex

这个方法类似 _.sortedIndex，除了它返回在 value 中尽可能大的 index 位置。

_.sortedLastIndexBy

这个方法类似 _.sortedLastIndex，除了它接受一个 iteratee 调用每一个数组和值来计算排序。iteratee 会传入一个参数：(value)。

_.sortedLastIndexOf

这个方法类似 _.lastIndexOf，除了它是执行二进制来检索已经排序的数组的。

_.sortedUniq

这个方法类似 _.uniq，除了它会排序并优化数组。

_.sortedUniqBy(array, [iteratee])

这个方法类似 _.uniqBy，除了它接受一个 iteratee 调用每一个数组和值来排序并优化数组。

_.tail(array)

获取数组中除了第一个元素的剩余数组

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

从数组的起始元素开始提取 N 个元素。

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

从数组的结束元素开始提取 N 个数组

_.takeRightWhile

从数组的最右边开始提取数组，直到 predicate 返回假值。predicate 会传入三个参数：(value, index, array)。

_.takeWhille

从数组的开始提取数组，直到 predicate 返回假值。predicate 会传入三个参数：(value, index, array)。

_.union

创建顺序排列的唯一值组成的数组。所有值经过 SameValueZero 等值比较。

_.unionBy

这个方法类似 _.union，除了它接受一个 iteratee 调用每一个数组和值。iteratee 会传入一个参数：(value)

_.unionWith

这个方法类似 _.union， 除了它接受一个 comparator 调用每一个数组元素的值。 comparator 会传入2个参数：(arrVal, othVal)。

_.uniq

创建一个不重复的数组副本。使用了 SameValueZero 等值比较。只有首次出现的元素才会被保留。

_.uniqBy

这个方法类似 _.uniq，除了它接受一个 iteratee 调用每一个数组和值来计算唯一性。iteratee 会传入一个参数：(value)。

_.uniqWith

这个方法类似 _.uniq，除了它接受一个 comparator 来比较计算唯一性。 comparator 会传入2个参数：(arrVal, othVal)

_.unzip

这个方法类似 _.zip，除了它接收一个打包后的数组并且还原为打包前的状态。

_.unzioWith

这个方法类似 _.unzip，除了它接受一个 iteratee 来决定如何重组解包后的数组。iteratee 会传入4个参数：(accumulator, value, index, group)。每组的第一个元素作为初始化的值

_.without

创建一个移除了所有提供的 values 的数组。使用了 SameValueZero 等值比较。

_.xor

创建一个包含了所有唯一值的数组。使用了 symmetric difference 等值比较。

_.xorBy

这个方法类似 _.xor，除了它接受一个 iteratee 调用每一个数组和值。iteratee 会传入一个参数：(value)。

_.xorWith

这个方法类似 _.xor，除了它接受一个 comparator 调用每一个数组元素的值。 comparator 会传入2个参数：(arrVal, othVal)。

_.zip

创建一个打包所有元素后的数组。第一个元素包含所有提供数组的第一个元素，第二个包含所有提供数组的第二个元素，以此类推。

_.zipObject

这个方法类似 _.fromPairs，除了它接受2个数组，一个作为属性名，一个作为属性值。

_.zipObjectDeep

这个方法类似 _.zipObject，除了它支持属性路径。 This method is like _.zipObject except that it supports property paths.

_.zipWith

这个方法类似 _.zip， 除了它接受一个 iteratee 决定如何重组值。 iteratee 会调用每一组元素。

2.Collection(集合)

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

_.countBy

创建一个组成对象，key是经过 iteratee 处理的集合的结果，value 是处理结果的次数。 iteratee 会传入一个参数：(value)。

_.each->forEach

迭代集合的元素并为每个元素调用iteratee。使用三个参数调用iteratee：（value，index | key，collection）。Iteratee函数可以通过显式返回false来提前退出迭代。

_.each->forEachRight

此方法类似于_.forEach，只是它从右到左遍历集合的元素。

_.every

通过 predicate 检查集合中的元素是否都返回 真值，只要 predicate 返回一次假值，遍历就停止，并返回 false。 predicate 会传入3个参数：(value, index|key, collection)

_.filter

遍历集合中的元素，筛选出一个经过 predicate 检查结果为真值的数组，predicate 会传入3个参数：(value, index|key, collection)。

_.find

遍历集合中的元素，返回最先经 predicate 检查为真值的元素。 predicate 会传入3个元素：(value, index|key, collection)。

_.findLast

这个方法类似 _.find，除了它是从右至左遍历集合的。

_.flatMap

通过遍历iteratee运行集合中的每个元素并展平映射结果，创建一个展平的值数组。使用三个参数调用iteratee：（value，index | key，collection）。

_.flatMapDeep

方法就像_.flatMap，除了它递归地展平映射结果。

_.flatMapDepth

此方法类似于_.flatMap，除了它以递归方式将映射结果展平为深度时间。

_.forEach

调用 iteratee 遍历集合中的元素， iteratee 会传入3个参数：(value, index|key, collection)。 如果显式的返回 false ，iteratee 会提前退出

_.forEachRight

这个方法类似 _.forEach，除了它是从右到左遍历的集合中的元素的。

_.groupBy

创建一个对象组成，key 是经 iteratee 处理的结果， value 是产生 key 的元素数组。 iteratee 会传入1个参数：(value)。

_.includes

检查 值 是否在 集合中，如果集合是字符串，那么检查 值 是否在字符串中。 其他情况用 SameValueZero 等值比较。 如果指定 fromIndex 是负数，从结尾开始检索。

_.invokeMap

调用 path 的方法处理集合中的每一个元素，返回处理的数组。 如何附加的参数会传入到调用方法中。如果方法名是个函数，集合中的每个元素都会被调用到。

_.keyBy

创建一个对象组成。key 是经 iteratee 处理的结果，value 是产生key的元素。 iteratee 会传入1个参数：(value)。

_.map

创建一个经过 iteratee 处理的集合中每一个元素的结果数组。 iteratee 会传入3个参数：(value, index|key, collection)。

_.orderBy

这个方法类似 _.sortBy，除了它允许指定 iteratees 结果如何排序。 如果没指定 orders，所有值以升序排序。 其他情况，指定 “desc” 降序，指定 “asc” 升序其对应值。

_.partition

创建一个拆分为两部分的数组。 第一部分是 predicate 检查为真值的，第二部分是 predicate 检查为假值的。 predicate 会传入3个参数：(value, index|key, collection)。

_.reduce

通过 iteratee 遍历集合中的每个元素。 每次返回的值会作为下一次 iteratee 使用。 如果没有提供 accumulator，则集合中的第一个元素作为 accumulator。 iteratee 会传入4个参数：(accumulator, value, index|key, collection)。

_.reduceRight

这个方法类似 _.reduce ，除了它是从右到左遍历的。

_.reject

反向版 _.filter，这个方法返回 predicate 检查为非真值的元素。

_.sample

从集合中随机获得元素

_.sampleSize

获得从集合中随机获得 N 个元素 Gets n random elements from collection.

_.shuffle

创建一个被打乱元素的集合。 使用了 Fisher-Yates shuffle 版本。

_.size

返回集合的长度或对象中可枚举属性的个数。

_.some

通过 predicate 检查集合中的元素是否存在任意真值的元素，只要 predicate 返回一次真值，遍历就停止，并返回 true。 predicate 会传入3个参数：(value, index|key, collection)。

_.sortBy

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

3.Date(日期)

_.now

获得 Unix 纪元(1970 1月1日 00:00:00 UTC) 直到现在的毫秒数。

4.Function(函数)

适用于函数类型，比如节流、延迟、缓存、设置钩子等操作

_.after

反向版 _.before。 这个方法创建一个新函数，当调用 N 次或者多次之后将触发 func 方法。

_.ary

创建一个最多接受 N 个参数，忽略多余参数的方法。

_.before

创建一个调用 func 的函数。 调用次数不超过 N 次。 之后再调用这个函数，将返回最后一个调用的结果。

_.bind

创建一个函数 func，这个函数的 this 会被绑定在 thisArg。 并且任何附加在 _.bind 的参数会被传入到这个绑定函数上。 这个 _.bind.placeholder 的值，默认是以 _ 作为附加部分参数的占位符。

_.bindKey

创建一个函数。 该方法绑定 object[key] 的方法。 任何附加在 _.bindKey 的参数会预设到该绑定函数上。

_.curry

创建一个函数，该函数接收一个或多个 func 的参数。 当该函数被调用时,如果 func 所需要传递的所有参数都被提供，则直接返回 func 所执行的结果。 否则继续返回该函数并等待接收剩余的参数。 可以使用 func.length 强制需要累积的参数个数。

_.curryRight

这个方法类似 _.curry。 除了它接受参数的方式用 _.partialRight 代替了 _.partial。这个 _.curry.placeholder 的值，默认是以 _ 作为附加部分参数的占位符。

_.debounce

创建一个防抖动函数。 该函数会在 wait 毫秒后调用 func 方法。 该函数提供一个 cancel 方法取消延迟的函数调用以及 flush 方法立即调用。 可以提供一个 options 对象决定如何调用 func 方法， options.leading 与|或 options.trailing 决定延迟前后如何触发。 func 会传入最后一次传入的参数给防抖动函数。 随后调用的防抖动函数返回是最后一次 func 调用的结果。

_.defer

延迟调用 func 直到当前堆栈清理完毕。 任何附加的参数会传入到 func。

_.delay

延迟 wait 毫秒后调用 func。 任何附加的参数会传入到 func。

_.flip

创建一个翻转接收参数的 func 函数。

_.memoize

创建一个会缓存 func 结果的函数。 如果提供了 resolver，就用 resolver 的返回值作为 key 缓存函数的结果。 默认情况下用第一个参数作为缓存的 key。 func 在调用时 this 会绑定在缓存函数上

_.negate

创建一个对 func 结果 取反的函数。 用 predicate 对 func 检查的时候，this 绑定到创建的函数，并传入对应参数。

_.once

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

_.overArgs

创建一个函数，调用时func 参数会先一对一的改变。

_.partial

创建一个函数。 该函数调用 func，并传入预设的参数。 这个方法类似 _.bind，除了它不会绑定 this。 这个 _.partial.placeholder 的值，默认是以 _ 作为附加部分参数的占位符。

_.partialRight

这个函数类似 _.partial，除了它是从右到左预设参数的。 这个 .partialRight.placeholder 的值，默认是以 作为附加部分参数的占位符。

_.rearg

创建一个调用 func 的函数。 所传递的参数根据 indexes 调整到对应位置。 第一个 index 对应到第一个传参，第二个 index 对应到第二个传参，以此类推。

_.rest

创建一个调用 func 的函数。 this 绑定到这个函数 并且 从 start 之后的参数都作为数组传入。

_.spread

创建一个调用 func 的函数。 this 绑定到这个函数上。 把参数作为数组传入，类似于 Function#apply

_.throttle

创建一个节流函数，在 wait 秒内最多执行 func 一次的函数。 该函数提供一个 cancel 方法取消延迟的函数调用以及 flush 方法立即调用。 可以提供一个 options 对象决定如何调用 func 方法， options.leading 与|或 options.trailing 决定 wait 前后如何触发。 func 会传入最后一次传入的参数给这个函数。 随后调用的函数返回是最后一次 func 调用的结果。

_.unary

创建一个最多接受一个参数的函数，忽略多余的参数。

_.wrap

创建一个函数。提供的 value 包装在 wrapper 函数的第一个参数里。 任何附加的参数都提供给 wrapper 函数。 被调用时 this 绑定在创建的函数上。

5.Lang

普遍适用于各种类型，常用于执行类型判断和类型转换

_.castArray

如果 value 不是数组, 那么强制转为数组

_.clone

创建一个 value 的浅拷贝。

_.cloneDeep

这个方法类似 _.clone，除了它会递归拷贝 value。

_.cloneDeepWith

这个方法类似 _.cloneWith，除了它会递归拷贝 value。

_.cloneWith

这个方法类似 _.clone，除了它接受一个 customizer 定制返回的拷贝值。 如果 customizer 返回 undefined 将会拷贝处理方法代替。 customizer 会传入5个参数：(value [, index|key, object, stack])

_.conformsTo

通过使用object的相应属性值调用source的谓词属性来检查对象是否符合源。

_.eq

执行 SameValueZero 比较两者的值确定它们是否相等。

_.gt

检查 value 是否大于 other

_.gte

检查 value 是否大于等于 other

_.isArguments

检查 value 是否是 类 arguments 对象。

_.isArray

检查 value 是否是 Array 类对象。

_.isArrayBuffer

检查 value 是否是 ArrayBuffer 对象。

_.isArrayLike

检查 value 是否是类数组。 如果是类数组的话，应该不是一个函数，而且 value.length 是个整数，大于等于 0，小于或等于 Number.MAX_SAFE_INTEGER

_.isArrayLikeObject

这个方法类似 _.isArrayLike，除了它还检查值是否是个对象。

_.isBoolean

检查 value 是否是原始 boolean 类型或者对象。

_.isBuffer

检查 value 是否是个 buffer

_.isDate

检查 value 是否是 Date 类型

_.isElement

检查 value 是否是可能是 DOM 元素

_.isEmpty

检查 value 是否为空。 判断的依据是除非是有枚举属性的对象，length 大于 0 的 arguments object, array, string 或类jquery选择器。

_.isEqual

执行深比较来决定两者的值是否相等。

_.isEqualWith

这个方法类似 _.isEqual。 除了它接受一个 customizer 定制比较值。 如果 customizer 返回 undefined 将会比较处理方法代替。 customizer 会传入7个参数：(objValue, othValue [, index|key, object, other, stack])

_.isError

检查 value 是否是 Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, 或 URIError object.

_.isFinite

检查 value 是否是原始 finite number。

_.isFunction

检查 value 是否是 Function 对象。

_.isInteger

检查 value 是否是整数。

_.isLength

检查 value 是否是有效长度

_.isMap

检查 value 是否是个 Map 对象

_.isMatch

执行一个深比较来确定object 是否包含有 source 的属性值。

_.isMatchWith

这个方法类似 _.isMatch。 除了它接受一个 customizer 定制比较的值。 如果 customizer 返回 undefined 将会比较处理方法代替。 customizer 会传入5个参数：(objValue, srcValue, index|key, object, source)

_.isNaN

检查 value 是否是 NaN.

_.isNative

检查 value 是否是原生函数

_.isNil

检查 value 是否是 null 或者 undefined。

_.isNull

检查 value 是否是 null.

_.isNumber

检查 value 是否是原始数值型 或者 对象。

_.isObject

检查 value 是否是 Object 的 language type。 (例如： arrays, functions, objects, regexes, new Number(0), 以及 new String(‘’))

_.isObjectLike

检查 value 是否是 类对象。 类对象应该不是 null 以及 typeof 的结果是 “object”。

_.isPlainObject

检查 value 是否是普通对象。 也就是说该对象由 Object 构造函数创建或者 [[Prototype]] 为空。

_.isRegExp

检查 value 是否是 RegExp 对象

_.isSafeInteger

检查 value 是否是安全整数。 这个整数应该是符合 IEEE-754 标准的非双精度浮点数。

_.isSet

检查 value 是否是 Set 对象。

_.isString

检查 value 是否是原始字符串或者对象。

_.isSymbol

检查 value 是否是原始 Symbol 或者对象。

_.isTypedArray

检查 value 是否是TypedArray。

_.isUndefined

检查 value 是否是 undefined.

_.isWeakMap

检查 value 是否是 WeakMap 对象

_.isWeakSet

检查 value 是否是 WeakSet 对象

_.lt

检查 value 是否是 小于 other。

_.lte

检查 value 是否是 小于等于 other.

_.toArray

转换 value 为数组

_.toFinite

将值转换为有限数字。

_.toInteger

转换 value 为整数

_.toLength

转换 value 为用作类数组对象的长度整数。

_.toNumber

转换 value 为数值

_.toPlainObject

转换 value 为普通对象。 包括继承的可枚举属性。

_.toSafeInteger

转换 value 为安全整数。 安全整数可以用于比较和准确的表示。

_.toString

如果 value 不是字符串，将其转换为字符串。 null 和 undefined 将返回空字符串。

6.Math

适用于数值类型，常用于执行数学运算

_.add

相加两个数

_.ceil

根据 precision 向上舍入 number。

_.divide

除以两个数字

_.floor

根据 precision 向下保留 number。

_.max

计算 array 中最大的值。 如果 array 是 空的或者假值将会返回 undefined。

_.maxBy

这个方法类似 _.max 除了它接受 iteratee 调用每一个元素，根据返回的 value 决定排序准则。 iteratee 会传入1个参数：(value)。

_.mean

计算 array 的平均值。

_.meanBy

此方法与_.mean类似，不同之处在于它接受为数组中的每个元素调用的iteratee，以生成要平均的值。使用一个参数调用iteratee :( value）。以来

_.min

计算 array 中最小的值。 如果 array 是 空的或者假值将会返回 undefined。

_.minBy

这个方法类似 _.min。 除了它接受 iteratee 调用每一个元素，根据返回的 value 决定排序准则。 iteratee 会传入1个参数：(value)。

_.multiply

相乘

_.round

根据 precision 四舍五入 number。

_.subtract

相减

_.sum

计算 array 中值的总和

_.sumBy

这个方法类似 _.sum。 除了它接受 iteratee 调用每一个元素，根据返回的 value 决定如何计算。 iteratee 会传入1个参数：(value)。

7.Number(数字)

适用于生成随机数，比较数值与数值区间的关系

_.clamp

返回限制在 min 和 max 之间的值

_.inRange

检查 n 是否在 start 与 end 之间，但不包括 end。 如果 end 没有指定，那么 start 设置为0。 如果 start 大于 end，那么参数会交换以便支持负范围

_.random

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

8.Object(对象)

适用于对象类型，常用于对象的创建、扩展、类型转换、检索、集合等操作

_.assign

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

_.assignIn

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

_.assignInwith

这个方法类似 _.assignIn。 除了它接受一个 customizer决定如何分配值。 如果customizer返回undefined将会由分配处理方法代替。customizer` 会传入5个参数：(objValue, srcValue, key, object, source)

_.assignWith

这个方法类似 _.assign。 除了它接受一个 customizer决定如何分配值。 如果customizer返回undefined将会由分配处理方法代替。customizer` 会传入5个参数：(objValue, srcValue, key, object, source)

_.at

根据 object 的路径获取值为数组。

_.create

创建一个继承 prototype 的对象。 如果提供了 properties，它的可枚举属性会被分配到创建的对象上。

_.defaults

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

_.defaultsDeep

这个方法类似 _.defaults，除了它会递归分配默认属性。

_.entries->toPairs

_.entriesIn->toPairsIn

_.extend->assignIn

_.extendWith->assignInwith

_.findKey

这个方法类似 _.find。 除了它返回最先被 predicate 判断为真值的元素 key，而不是元素本身。

_.findLastKey

这个方法类似 _.findKey。 不过它是反方向开始遍历的。

_.forIn

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

_.forInRight

这个方法类似 _.forIn。 除了它是反方向开始遍历的。

_.forOwn

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

_.forOwnRight

这个方法类似 _.forOwn。 除了它是反方向开始遍历的。

_.functions

返回一个 function 对象自身可枚举属性名的数组。

_.functionsIn

返回一个 function 对象自身和继承的可枚举属性名的数组。

_.get

根据对象路径获取值。 如果解析 value 是 undefined 会以 defaultValue 取代

_.has

检查 path 是否是对象的直接属性。

_.hasIn

检查 path 是否是对象的直接 或者 继承属性。

_.invert

创建一个键值倒置的对象。 如果 object 有重复的值，后面的值会覆盖前面的值。 如果 multiVal 为 true，重复的值则组成数组。

_.invertBy

这个方法类似 _.invert。 除了它接受 iteratee 调用每一个元素，可在返回值中定制key。 iteratee 会传入1个参数：(value)。

_.invoke

调用对象路径的方法

_.keys

创建 object 自身可枚举属性名为一个数组。

_.keysIn

创建 object 自身 或 继承的可枚举属性名为一个数组。

_.mapKeys

反向版 _.mapValues。 这个方法创建一个对象，对象的值与源对象相同，但 key 是通过 iteratee 产生的。

_.mapValues

创建一个对象，对象的key相同，值是通过 iteratee 产生的。 iteratee 会传入3个参数： (value, key, object)

_.merge

递归合并来源对象的自身和继承的可枚举属性到目标对象。 跳过来源对象解析为 undefined 的属性。 数组和普通对象会递归合并，其他对象和值会被直接分配。 来源对象从左到右分配，后续的来源对象属性会覆盖之前分配的属性。

_.mergeWith

这个方法类似 _.merge。 除了它接受一个 customizer 决定如何合并。 如果 customizer 返回 undefined 将会由合并处理方法代替。

_.omit

反向版 _.pick。 这个方法返回忽略属性之外的自身和继承的可枚举属性。

_.omitBy

反向版 _.pickBy。 这个方法返回经 predicate 判断不是真值的属性的自身和继承的可枚举属性。

_.pick

创建一个从 object 中选中的属性的对象。

_.pickBy

创建一个从 object 中经 predicate 判断为真值的属性为对象。 predicate 会传入1个参数：(value)

_.result

这个方法类似 _.get。 除了如果解析到的值是一个函数的话，就绑定 this 到这个函数并返回执行后的结果。

_.set

设置值到对象对应的属性路径上，如果没有则创建这部分路径。 缺少的索引属性会创建为数组，而缺少的属性会创建为对象。 使用 _.setWith 定制创建。

_.setWith

这个方法类似 _.set。 除了它接受一个 customizer 决定如何设置对象路径的值。 如果 customizer 返回 undefined 将会有它的处理方法代替。 customizer 会传入3个参数：(nsValue, key, nsObject) 注意: 这个方法会改变源对象

_.toPairs

创建一个对象自身可枚举属性的键值对数组。

_.toPairsIn

创建一个对象自身和继承的可枚举属性的键值对数组。

_.transform

_.reduce 的代替方法。 这个方法会改变对象为一个新的 accumulator 对象，来自每一次经 iteratee 处理自身可枚举对象的结果。 每次调用可能会改变 accumulator 对象。 iteratee 会传入4个对象：(accumulator, value, key, object)。 如果返回 false，iteratee 会提前退出

_.unset

移除对象路径的属性。 注意: 这个方法会改变源对象

_.update

_.updateWith

_.values

创建 object 自身可枚举属性的值为数组

_.valuesIn

创建 object 自身和继承的可枚举属性的值为数组

9.Seq

常用于创建链式调用，提高执行性能（惰性计算）

_.chain

创建一个经 lodash 包装的对象以启用显式链模式，要解除链必须使用 _#value 方法。

_.tap

这个方法调用一个 interceptor 并返回 value。interceptor 传入一个参数：(value) 目的是 进入 链的中间以便执行操作。

_.thru

这个方法类似 _.tap， 除了它返回 interceptor 的返回结果

_.prototype[Symbol.iterator]

_.prototype.at

这个方法是 _.at 的包装版本

_.prototype.chain

开启包装对象的显式链。

_.prototype.commit

执行链式队列并返回结果

_.prototype.next

获得包装对象的下一个值，遵循 iterator 协议

_.prototype.plant

创建一个链式队列的拷贝，传入的值作为链式队列的值。

_.prototype.reverse

_.prototype.toJSON->value

_.prototype.valueOf->value

10.String(字符串)

_.camelCase

转换字符串为 驼峰写法

_.capitalize

转换字符串首字母为大写，剩下为小写

_.deburr

转换 latin-1 supplementary letters#Character_table) 为基本拉丁字母，并删除变音符。

_.endsWith

检查给定的字符是否是字符串的结尾

_.escape

转义字符 “&”, “<”, “>”, ‘”’, “’”, 以及 “`” 为HTML实体字符。

_.escapeRegExp

转义RegExp 中特殊的字符 “^”, “$”, “", “.”, “*”, “+”, “?”, “(“, “)”, “[”, “]”, “{“, “}”, 以及 “|“。

_.kebabCase

转换字符串为 kebab case。

_.lowerCase

以空格分开单词并转换为小写。

_.lowerFirst

转换首字母为小写。

_.pad

如果字符串长度小于 length 则从左到右填充字符。 如果没法平均分配，则截断超出的长度。

_.padEnd

如果字符串长度小于 length 则在右侧填充字符。 如果超出长度则截断超出的部分

_.padStart

如果字符串长度小于 length 则在左侧填充字符。 如果超出长度则截断超出的部分

_.parseInt

以指定的基数转换字符串为整数。 如果基数是 undefined 或者 0，则基数默认是10，如果字符串是16进制，则基数为16。

_.repeat

重复 N 次字符串

_.replace

替换字符串中匹配的内容为给定的内容

_.snakeCase

转换字符串为 snake case

_.split

以 separator 拆分字符串

_.startCase

转换字符串为 start case

_.startsWith

检查字符串是否以 target 开头。

_.template

创建一个预编译模板方法，可以插入数据到模板中 “interpolate” 分隔符相应的位置。 HTML会在 “escape” 分隔符中转换为相应实体。 在 “evaluate” 分隔符中允许执行JavaScript代码。 在模板中可以自由访问变量。 如果设置了选项对象，则会优先覆盖 _.templateSettings 的值。

_.toLower

转换整体的字符串为小写

_.toUpper

转换整体的字符串为大写

_.trim

从字符串中移除前面和后面的空白 或 指定的字符。

_.trimEnd

移除字符串后面的空白 或 指定的字符。

_.trimStart

移除字符串中前面的空白 或 指定的字符。

_.truncate

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

_.unescape

反向版 _.escape。 这个方法转换 HTML 实体 &, <, >, ", ', 以及 ` 为对应的字符。

_.upperCase

转换字符串为空格分割的大写单词

_.upperFirst

转换首字母为大写。

_.words

拆分字符串中的词为数组

11.Util(工具)

_.attempt

尝试调用函数，返回结果 或者 错误对象。 任何附加的参数都会在调用时传给函数。

_.bindAll

绑定对象的方法到对象本身，覆盖已存在的方法。

_.cond

创建一个函数。 这个函数会遍历 pairs，并执行最先返回真值对应的函数，并绑定 this 及传入创建函数的参数

_.conforms

创建一个函数。 这个函数会调用 source 的属性名对应的 predicate 与传入对象相对应属性名的值进行 predicate 处理。 如果都符合返回 true，否则返回 false

_.constant

创建一个返回 value 的函数

_.defaultTo

_.flow

创建一个函数。 返回的结果是调用提供函数的结果，this 会绑定到创建函数。 每一个连续调用，传入的参数都是前一个函数返回的结果。

_.flowRight

这个方法类似 _.flow，除了它调用函数的顺序是从右往左的。

_.identity

这个方法返回首个提供的参数

_.iteratee

创建一个调用 func 的函数。 如果 func 是一个属性名，传入包含这个属性名的对象，回调返回对应属性名的值。 如果 func 是一个对象，传入的元素有相同的对象属性，回调返回 true。 其他情况返回 false。

_.matches

创建一个深比较的方法来比较给定的对象和 source 对象。 如果给定的对象拥有相同的属性值返回 true，否则返回 false

_.matchesProperty

创建一个深比较的方法来比较给定对象的 path 的值是否是 srcValue。 如果是返回 true，否则返回 false

_.method

创建一个调用给定对象 path 上的函数。 任何附加的参数都会传入这个调用函数中。

_.methodOf

反向版 _.method。 这个创建一个函数调用给定 object 的 path 上的方法， 任何附加的参数都会传入这个调用函数中。

_.mixin

添加来源对象自身的所有可枚举函数属性到目标对象。 如果 object 是个函数，那么函数方法将被添加到原型链上。

_.noConflict

释放 _ 为原来的值，并返回一个 lodash 的引用

_.noop

无论传递什么参数，都返回 undefined。

_.nthArg

创建一个返回第 N 个参数的函数。

_.over

创建一个传入提供的参数的函数并调用 iteratees 返回结果的函数

_.overEvery

创建一个传入提供的参数的函数并调用 iteratees 判断是否 全部 都为真值的函数。

_.overSome

创建一个传入提供的参数的函数并调用 iteratees 判断是否 存在 有真值的函数。

_.property

创建一个返回给定对象的 path 的值的函数。

_.propertyOf

反向版 _.property。 这个方法创建的函数返回给定 path 在对象上的值。

_.range

创建一个包含从 start 到 end，但不包含 end 本身范围数字的数组。 如果 start 是负数，而 end 或 step 没有指定，那么 step 从 -1 为开始。 如果 end 没有指定，start 设置为 0。 如果 end 小于 start，会创建一个空数组，除非指定了 step。

_.rangeRight

这个方法类似 _.range， 除了它是降序生成值的。

_.runInContext

创建一个给定上下文对象的原始的 lodash 函数。

_.stubArray

_.stubFalse

_.stubObject

_.stubString

_.stubTrue

_.times

调用 iteratee N 次，每次调用返回的结果存入到数组中。 iteratee 会传入1个参数：(index)。

_.toPath

创建 value 为属性路径的数组

_uniqueId

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

12.Porperties(属性)

_.VERSION

_.templateSettings

_.templateSettings.escape

_.templateSettings.evaluate

_.templateSettings.imports

_.templateSettings.interpolate

_.templateSettings.variable

13.Methods(方法)

.templateSettings.imports.

14.小菜常用方法

_.map

获取一个数组对象中的value值，并返回一个数组

let arr = [{name:'张三',age:19},{name:'王五',age:20},{name:'老6',age:21}]

_.map(arr,'name')

['张三','王五','老6']

_.assignIn

一个对象属性替换掉另个对象的属性，就是合并

let user = {name:'酱大饼',age:30,child:{name:'酱小兵',age:5}}
let user1 = {name:"王老五"}
_.assignIn(user,user1)

{name:'王老五',age:30,child:{name:'酱小兵',age:5}}

_.cloneDeep

深拷贝

let user = {name:'酱大饼',age:30,child:{name:'酱小兵',age:5}}
let user1 = _.cloneDeep(user)

user1.child.name = '王老五';

//user
{name:'酱大饼',age:30,child:{name:'酱小兵',age:5}}

//user1
{name:'酱大饼',age:30,child:{name:'王老五',age:5}}