Lodash 一个提供模块化、性能和附加功能的三方库

Loadsh是一款提供了现代浏览器多功能、以及性能优化的工具库，使用loash可以辅助我们实现模块化、并通过类似JS Array中的多个方法等功能以提供更好的应用性能。Loash支持在Nodejs端和浏览器端使用。本篇文章主要介绍Loash仓库的基础使用方式。

关于

如下通过loash库的一些相关信息：

• npm仓库地址：https://www.npmjs.com/package/lodash
• github地址：github.com/lodash/lodash
• 官网地址：lodash.com/

安装

loash可以使用yarn或者npm实现下载安装：

$ npm install --save loash  // 或者使用yarn
$ yarn add -D loash

使用示例

loash支持Nodejs和浏览器，我们通过如下简单的例子来了解如何使用loash工具库。

1、Nodejs使用loash

// Load the full build.
var _ = require('lodash');
// Load the core build.
var _ = require('lodash/core');
// Load the FP build for immutable auto-curried iteratee-first data-last methods.
var fp = require('lodash/fp');

// Load method categories.
var array = require('lodash/array');
var object = require('lodash/fp/object');

// Cherry-pick methods for smaller browserify/rollup/webpack bundles.
var at = require('lodash/at');
var curryN = require('lodash/fp/curryN');

2、浏览器端

浏览器端可以使用直接导入使用或者使用npm使用。代码使用同上nodejs类似。

支持功能

Loash提供众多方法、对象方法等来帮助我们完成一些基础的功能使用。如下介绍部分功能：

1、Arrray方法

• _.chunk(array, [size=1])
  创建一个元素数组，将元素分成长度为 size 的组。如果数组不能被平均分割，最后的块将是剩余的元素。
• _.compact(array)
  创建一个删除了所有错误值的数组。值 false、null、0、''、undefined 和 NaN 是错误的。
• _.concat(array, [values])
  创建一个新的数组连接数组与任何额外的数组和/或值。
• _.difference(array, [values])
  使用 SameValueZero 创建不包含在其他给定数组中的数组值数组以进行相等比较。结果值的顺序和引用由第一个数组确定。
• _.differenceBy(array, [values], [iteratee=_.identity])
  此方法就像_.difference，除非它接受对数组和值的每个元素调用的ITEMEREE，以生成比较它们的标准。结果值的顺序和参考由第一个数组确定。
• _.differenceWith(array, [values], [comparator])
  此方法类似于 _.difference，只是它接受调用比较器来比较数组元素与值的比较器。结果值的顺序和引用由第一个数组确定。使用两个参数调用比较器：(arrVal, othVal)。
• _.drop(array, [n=1])
  创建一个数组切片，其中 n 个元素从头开始删除。
• _.dropRight(array, [n=1])
  创建一个数组切片，其中 n 个元素从末尾删除。
• _.dropRightWhile(array, [predicate=_.identity])
  创建一个数组切片，不包括从末尾删除的元素。元素被丢弃，直到谓词返回假。使用三个参数调用谓词：（值、索引、数组）。
• _.dropWhile(array, [predicate=_.identity])
  创建一个数组切片，不包括从开头删除的元素。元素被丢弃，直到谓词返回假。使用三个参数调用谓词：（值、索引、数组）。
• _.fill(array, value, [start=0], [end=array.length])
  用从开始到但不包括结束的值填充数组元素。
• _.findIndex(array, [predicate=_.identity], [fromIndex=0])
  此方法与 _.find 类似，不同之处在于它返回第一个元素的索引谓词返回 truthy for 而不是元素本身。
• _.findLastIndex(array, [predicate=_.identity], [fromIndex=array.length-1])
  此方法类似于 _.findIndex，只是它从右到左遍历集合的元素。
• _.head(array)
  获取数组的第一个元素
• _.flatten(array)
  即返回一个折叠成一维的数组
• _.flattenDeep(array)
  递归一个折叠的数组。
• _.flattenDepth(array, [depth=1])
  递归一个折叠的数组直至设置深度。
• _.fromPairs(pairs)
  _.toPairs 的反函数；此方法返回一个由键值对组成的对象。
• _.head(array)
  获取数组的第一个元素。
• _.indexOf(array, value, [fromIndex=0])
  使用 SameValueZero 获取数组中第一次出现值的索引以进行相等性比较。如果 fromIndex 是负数，它被用作距数组末尾的偏移量。
• _.initial(array)
  获取数组中除最后一个元素之外的所有元素。
• _.intersection([arrays])
  创建一系列独特的值，这些值都包含在所有给定数组中的samevaluezero进行平等比较。结果值的顺序和参考由第一个数组确定。
• _.intersectionBy([arrays], [iteratee=_.identity])
  此方法类似于 _.intersection，不同之处在于它接受 iteratee，它为每个数组的每个元素调用以生成比较它们的标准。结果值的顺序和引用由第一个数组确定。
• _.intersectionWith([arrays], [comparator])
  此方法类似于 _.intersection，只是它接受被调用以比较数组元素的比较器。结果值的顺序和引用由第一个数组确定。使用两个参数调用比较器：(arrVal, othVal)。
• _.join(array, [separator=','])
  将数组中的所有元素转换为由分隔符分隔的字符串。
• _.last(array)
  获取数组的最后一个元素。
• _.lastIndexOf(array, value, [fromIndex=array.length-1])
  此方法类似于 _.indexOf，只是它从右到左遍历数组的元素。
• _.nth(array, [n=0])
  获取数组索引 n 处的元素。如果 n 为负数，则返回倒数第 n 个元素。
• _.pull(array, [values])
  使用 SameValueZero 从数组中删除所有给定值以进行相等比较。
• _.pullAll(array, values)
  此方法类似于 _.pull，只是它接受要删除的值数组。
• _.pullAllBy(array, values, [iteratee=_.identity])
  此方法就像_..pullall，除了它接受iTerateE，该iTerateE是为数组的每个元素和值调用以生成比较标准的。 iTerateE被一个参数调用：（value）。
• _.pullAllWith(array, values, [comparator])：此方法与 _.pullAll 类似，不同之处在于它接受调用比较器来将数组元素与值进行比较。使用两个参数调用比较器：(arrVal, othVal)。
• _.pullAt(array, [indexes])：从对应于索引的数组中删除元素并返回已删除元素的数组。
• _.remove(array, [predicate=_.identity])：从数组中删除所有元素，这些元素将返回真相并返回删除元素的数组。谓词带有三个参数：(value, index, array)。
• _.reverse(array)：反向数组，使第一个元素变为最后一个，第二个元素成为第二个元素，依此类推。
• _.slice(array, [start=0], [end=array.length])：创建从开始到但不包括结束的数组切片。
• _.sortedIndex(array, value)：使用二进制搜索来确定应将值插入数组的最低索引，以保持其排序顺序。
• _.sortedIndexBy(array, value, [iteratee=_.identity])：此方法就像_.sortedIndex一样，除了它接受iTerateE，该ITEMERE被调用以获取值和数组的每个元素来计算其排序排名。 iTerateE被一个参数调用：（value）。
• _.sortedLastIndexOf(array, value)：此方法类似于 _.lastIndexOf，不同之处在于它对排序数组执行二分查找。
• _.sortedUniq(array)：此方法类似于_.uniq，除了它是针对排序阵列设计和优化的。
• _.sortedUniqBy(array, [iteratee])：此方法类似于 _.uniqBy，不同之处在于它是为排序数组设计和优化的。
• _.tail(array)：获取数组的第一个元素以外的所有元素。
• _.take(array, [n=1])：创建一个包含 n 个元素的数组切片。
• _.takeRight(array, [n=1])：创建一个数组切片，其中 n 个元素取自末尾。
• _.takeRightWhile(array, [predicate=_.identity])：使用从末尾获取的元素创建数组切片。取元素直到 predicate 返回 false。使用三个参数调用谓词：(value, index, array)。
• _.takeWhile(array, [predicate=_.identity])：使用从头开始获取的元素创建数组切片。取元素直到 predicate 返回 false。使用三个参数调用谓词：(value, index, array)。
• _.union([arrays])：使用 SameValueZero 从所有给定的数组中按顺序创建一个唯一值数组以进行相等比较。
• _.unionBy([arrays], [iteratee=_.identity])：此方法与 _.union 类似，不同之处在于它接受 iteratee，它为每个数组的每个元素调用以生成计算唯一性的标准。结果值是从出现该值的第一个数组中选择的。
• _.unionWith([arrays], [comparator])：此方法类似于 _.union，只是它接受调用比较器来比较数组元素的比较器。结果值是从出现该值的第一个数组中选择的。使用两个参数调用比较器：(arrVal, othVal)。
• _.uniq(array)：创建数组的无重复版本，使用 SameValueZero 进行相等比较，其中仅保留每个元素的第一次出现。结果值的顺序由它们在数组中出现的顺序决定。
• _.uniqBy(array, [iteratee=_.identity])：此方法就像_.uniq一样，除了它接受iTerateE，该元素在数组中的每个元素都调用以生成计算唯一性的标准。结果值的顺序取决于它们在数组中的顺序。
• _.uniqWith(array, [comparator])：此方法类似于 _.uniq，只是它接受调用比较器来比较数组元素的比较器。结果值的顺序由它们在数组中出现的顺序决定。使用两个参数调用比较器：(arrVal, othVal)。
• _.unzip(array)：此方法与 _.zip 类似，不同之处在于它接受分组元素数组并创建一个数组，将元素重新组合为其压缩前配置。
• _.unzipWith(array, [iteratee=_.identity])：此方法类似于 _.unzip，不同之处在于它接受 iteratee 以指定应如何组合重新分组的值。 iteratee 用每个组的元素调用：(...group)。
• _.without(array, [values])：使用 SameValueZero 创建一个排除所有给定值的数组以进行相等比较。
• _.xor([arrays])：创建一个唯一值数组，它是给定数组的对称差异。结果值的顺序由它们在数组中出现的顺序决定。
• _.xorBy([arrays], [iteratee=_.identity])：此方法与 _.xor 类似，不同之处在于它接受迭代器，该迭代器为每个数组的每个元素调用以生成比较它们的标准。结果值的顺序由它们在数组中出现的顺序决定。 iteratee 用一个参数调用： (value).。
• _.xorWith([arrays], [comparator])：此方法类似于 _.xor，只是它接受被调用以比较数组元素的比较器。结果值的顺序由它们在数组中出现的顺序决定。使用两个参数调用比较器：(arrVal, othVal)。
• _.zip([arrays])：创建一系列分组元素，其中第一个包含给定数组的第一个元素，其中第二个包含给定数组的第二个元素，依此类推。
• _.zipObject([props=[]], [values=[]])：此方法就像_. frompairs，除了它接受两个数组，一个属性标识符和一个相应的值之一。
• _.zipWith([arrays], [iteratee=_.identity])：此方法类似于 _.zip，不同之处在于它接受 iteratee 以指定应如何组合分组值。 iteratee 用每个组的元素调用：(...group)。

2、Collection方法

• _.countBy：
  创建一个对象，该对象由通过 iteratee 运行集合的每个元素的结果生成的键组成。每个key对应的值为iteratee返回该key的次数。 iteratee 用一个参数调用：（value）。
• _.forEach(collection, [iteratee=_.identity])：遍历集合的元素并为每个元素调用 iteratee。使用三个参数调用 iteratee：(value, index|key, collection)。 Iteratee 函数可以通过显式返回 false 提前退出迭代。
• _.forEachRight(collection, [iteratee=_.identity])：此方法类似于 _.forEach，只是它从右到左遍历集合的元素。
• _.every(collection, [predicate=_.identity])：检查谓词是否为集合的所有元素返回真值。一旦谓词返回假值，迭代就会停止。使用三个参数调用谓词：(value, index|key, collection)。
• _.filter(collection, [predicate=_.identity])：遍历集合的元素，返回所有元素的数组 predicate 返回 truthy for。使用三个参数调用谓词：(value, index|key, collection)。
• _.find(collection, [predicate=_.identity], [fromIndex=0])：遍历集合的元素，返回第一个元素 predicate returns truthy for。使用三个参数调用谓词：(value, index|key, collection)。
• _.findLast(collection, [predicate=_.identity], [fromIndex=collection.length-1])：此方法类似于 _.find，只是它从右到左遍历集合的元素。
• _.flatMap(collection, [iteratee=_.identity])：通过 iteratee 运行集合中的每个元素并展平映射结果来创建展平的值数组。使用三个参数调用 iteratee：(value, index|key, collection)。
• _.flatMapDeep(collection, [iteratee=_.identity])：此方法与 _.flatMap 类似，不同之处在于它以递归方式展平映射结果。
• _.flatMapDepth(collection, [iteratee=_.identity], [depth=1])：此方法类似于 _.flatMap，只是它递归地将映射结果展平到深度时间。
• _.forEach(collection, [iteratee=_.identity])：遍历集合的元素并为每个元素调用 iteratee。使用三个参数调用 iteratee：(value, index|key, collection)。 Iteratee 函数可以通过显式返回 false 提前退出迭代。
• _.forEachRight(collection, [iteratee=_.identity])：此方法类似于 _.forEach，只是它从右到左遍历集合的元素。
• _.groupBy(collection, [iteratee=_.identity])：
  创建一个对象，该对象由通过 iteratee 运行集合的每个元素的结果生成的键组成。分组值的顺序由它们在集合中出现的顺序决定。每个键对应的值是一个负责生成键的元素数组。 iteratee 用一个参数调用：（value）。
• _.includes(collection, value, [fromIndex=0])：检查值是否在集合中。如果 collection 是一个字符串，则检查它是否有值的子字符串，否则使用 SameValueZero 进行相等比较。如果 fromIndex 为负，则将其用作距集合末尾的偏移量。
• _.invokeMap(collection, path, [args])：调用集合中每个元素路径处的方法，返回每个调用方法的结果数组。任何附加参数都提供给每个调用的方法。如果 path 是一个函数，它会被调用并绑定到集合中的每个元素。
• _.keyBy(collection, [iteratee=_.identity])：创建一个对象，该对象由通过 iteratee 运行集合的每个元素的结果生成的键组成。每个键对应的值就是负责生成键的最后一个元素。 iteratee 用一个参数调用：（value）。
• _.map(collection, [iteratee=_.identity])：通过 iteratee 运行集合中的每个元素来创建值数组。
• _.orderBy(collection, [iteratees=[_.identity]], [orders])：此方法类似于 _.sortBy，只是它允许指定要排序的迭代对象的排序顺序。如果未指定顺序，则所有值按升序排序。否则，为相应值的降序指定“desc”顺序，或为相应值的升序指定“asc”顺序。
• _.partition(collection, [predicate=_.identity])：创建一个分为两组的元素数组，第一组包含 predicate 返回 truthy for 的元素，第二组包含 predicate 返回 false for 的元素。使用一个参数调用谓词：（value）。
• _.reduce(collection, [iteratee=_.identity], [accumulator])：将集合缩减为一个值，该值是通过 iteratee 运行集合中每个元素的累积结果，其中每个连续调用都提供前一个的返回值。如果未给出累加器，则使用集合的第一个元素作为初始值。
• _.reduceRight(collection, [iteratee=_.identity], [accumulator])：此方法类似于 _.reduce，只是它从右到左遍历集合的元素。
• _.reject(collection, [predicate=_.identity])：_.filter的对立面；此方法返回谓词不返回真相的集合元素。
• _.sample(collection)：从集合中获取一个随机元素。
• _.sampleSize(collection, [n=1])：从集合的唯一键获取 n 个随机元素，直到集合的大小。
• _.shuffle(collection)：使用 Fisher-Yates 随机播放的版本创建一组随机播放的值。
• _.size(collection)：通过返回类似数组值的长度或对象的自身可枚举字符串键控属性的数量来获取集合的大小。
• _.some(collection, [predicate=_.identity])：检查谓词是否会返回任何收集元素的真相。一旦谓词返回真相，迭代就会停止。谓词带有三个参数：(value, index|key, collection)。
• _.sortBy(collection, [iteratees=[_.identity]])：创建一个元素数组，根据每个迭代器运行集合中每个元素的结果按升序排序。此方法执行稳定排序，即它保留相等元素的原始排序顺序。用一个参数调用迭代器：（value）。

3、Date方法

• _.now()：获取自 Unix 纪元（1970 年 1 月 1 日 00:00:00 UTC）以来经过的毫秒数的时间戳。

4、Function方法

• _.after(n, func)：_.fore的对面;此方法创建一个函数，一旦称为n或更多次，就会调用func。
• _.ary(func, [n=func.length])：创建一个函数，该函数最多使用n个参数来调用func，忽略任何其他参数。
• _.before(n, func)：创建一个调用 func 的函数，使用创建函数的 this 绑定和参数，调用次数少于 n 次。对创建的函数的后续调用将返回最后一次 func 调用的结果。
• _.bind(func, thisArg, [partials])：创建一个调用 func 的函数，该函数使用 thisArg 的 this 绑定和预置到它接收的参数的部分。
• _.bindKey(object, key, [partials])：创建一个函数，该函数调用 object[key] 处的方法，并在其接收的参数前面加上部分。
• _.curry(func, [arity=func.length])：创建一个接受 func 参数的函数，如果至少提供了 arity 个参数，则调用 func 返回其结果，或者返回一个接受剩余 func 参数的函数，依此类推。如果 func.length 不够，可以指定 func 的参数。
• _.curryRight(func, [arity=func.length])：此方法类似于 _.curry，只是参数以 _.partialRight 而非 _.partial 的方式应用于 func。
• _.debounce(func, [wait=0], [options={}])：创建一个 debounced 函数，该函数延迟调用 func 直到自上次调用 debounced 函数后经过 wait 毫秒。 debounced 函数带有取消延迟函数调用的取消方法和立即调用它们的刷新方法。提供选项以指示是否应在等待超时的前沿和/或后沿调用 func。使用提供给去抖函数的最后一个参数调用 func。对 debounced 函数的后续调用将返回最后一次 func 调用的结果。
• _.defer(func, [args])：推迟调用 func，直到当前调用堆栈已清除。调用 func 时会提供任何其他参数。
• _.delay(func, wait, [args])：wait 毫秒后调用 func。调用 func 时会提供任何其他参数。
• _.flip(func)：创建一个函数，以逆转参数调用func。
• _.memoize(func, [resolver])：创建一个函数来记忆 func 的结果。如果提供了解析器，它会根据提供给记忆函数的参数确定用于存储结果的缓存键。默认情况下，提供给记忆函数的第一个参数用作地图缓存键。使用记忆函数的 this 绑定调用 func。
• .negate(predicate)：创建一个函数来否定谓词 func 的结果。 func 谓词是用创建函数的 this 绑定和参数调用的。
• _.once(func)：创建一个仅限于调用 func 一次的函数。重复调用函数返回第一次调用的值。使用创建函数的 this 绑定和参数调用 func。
• _.overArgs(func, [transforms=[_.identity]])：创建一个调用 func 并转换其参数的函数。
• _.partial(func, [partials])：创建一个调用 func 的函数，它在接收到的参数前加上部分。此方法类似于 _.bind，只是它不改变 this 绑定。
• _.partialRight(func, [partials])：此方法类似于 _.partial，只是部分应用的参数附加到它接收的参数。
• _.rearg(func, indexes)：创建一个函数，以根据指定索引排列的参数调用func，其中将第一个索引处的参数值作为第一个参数，第二个索引处的参数值作为第二个参数提供，等等。
• _.rest(func, [start=func.length-1])：创建一个调用 func 的函数，该函数使用创建的函数的 this 绑定以及从 start 和 beyond 作为数组提供的参数。
• _.spread(func, [start=0])：创建一个函数，该函数使用 create 函数的 this 绑定和一个参数数组调用 func，这与 Function#apply 非常相似。
• _.throttle(func, [wait=0], [options={}])：创建一个节流函数，该函数每 wait 毫秒最多只调用一次 func。 throttled 函数带有取消延迟函数调用的取消方法和立即调用它们的刷新方法。提供选项以指示是否应在等待超时的前沿和/或后沿调用 func。使用提供给节流函数的最后一个参数调用 func。对节流函数的后续调用将返回最后一次 func 调用的结果。
• _.unary(func)：创建一个最多接受一个参数的函数，忽略任何其他参数。
• _.wrap(value, [wrapper=identity])：创建一个为包装器提供价值作为其第一个参数的函数。提供给该功能的任何其他参数都附加到提供给包装器的内容上。包装器与创建函数的这种绑定一起调用。

5、Lang方法

• _.castArray(value)
  如果值不是一个，则将其转换为数组。
• _.clone(value)
  创建价值的浅层克隆。
• _.cloneDeep(value)
  此方法类似于 _.clone，只是它递归地克隆值。
• _.cloneDeepWith(value, [customizer])
  此方法类似于 _.cloneWith，只是它递归地克隆值。
• _.cloneWith(value, [customizer])
  此方法与 _.clone 类似，不同之处在于它接受调用以生成克隆值的自定义程序。如果 customizer 返回 undefined，则克隆由该方法处理。最多可以使用四个参数调用定制器；  (value [, index|key, object, stack])。
• _.conformsTo(object, source)：通过使用对象的相应属性值调用源的谓词属性来检查对象是否符合源。
• _.eq(value, other)：在两个值之间进行相同的比较，以确定它们是否等效。
• _.gt(value, other)：检查值是否大于其他。
• _.gte(value, other)：检查值是否大于或等于其他。
• _.isArguments(value)：检查值是否可能是参数对象。
• _.isArray(value)：检查值是否归类为数组对象。
• _.isArrayBuffer(value)：检查值是否归类为 ArrayBuffer 对象。
• _.isArrayLike(value)：检查值是否类似于数组。如果一个值不是函数并且其 value.length 是大于或等于 0 且小于或等于 Number.MAX_SAFE_INTEGER 的整数，则该值被视为类似数组。
• _.isArrayLikeObject(value)
  此方法类似于 _.isArrayLike，只是它还检查值是否为对象。
• _.isBoolean(value)
  检查值是否被归类为布尔基元或对象。
• _.isBuffer(value)
  检查值是否为缓冲区。
• _.isDate(value)
  检查值是否归类为 Date 对象。
• _.isElement(value)
  检查值是否可能是 DOM 元素。
• _.isEmpty(value)
  检查值是否为空对象、集合、映射或集合。
• _.isEqual(value, other)
  在两个值之间进行深入比较，以确定它们是否等效。
• _.isEqualWith(value, other, [customizer])
  此方法类似于 _.isEqual，只是它接受调用以比较值的自定义程序。
• _.isError(value)
  检查值是否为 Error、EvalError、RangeError、ReferenceError、SyntaxError、TypeError 或 URIError 对象。
• _.isFinite(value)
  检查值是否为有限原始数。
• _.isFunction(value)
  检查 value 是否被归类为 Function 对象。
• _.isInteger(value)
  检查值是否为整数。
• _.isLength(value)
  检查值是否是有效的类数组长度。
• _.isMap(value)
  检查 value 是否被归类为 Map 对象。
• _.isMatch(object, source)
  在对象和源之间执行部分深度比较以确定对象是否包含等效属性值。
• _.isMatchWith(object, source, [customizer])
  此方法类似于 _.isMatch，不同之处在于它接受被调用以比较值的定制器。如果 customizer 返回 undefined，则比较由该方法处理。使用五个参数调用定制器：（objValue、srcValue、index|key、object、source）。
• _.isNaN(value)：检查值是否为 NaN。
• _.isNative(value)：检查 value 是否是原始的本机函数。
• _.isNil(value)：检查值是否为空或未定义。
• _.isNull(value)：检查值是否为空。
• _.isNumber(value)：检查值是否归类为数字基元或对象。
• _.isObject(value)：检查值是否是对象的语言类型。 （例如数组、函数、对象、正则表达式、new Number(0) 和 new String('')）
• _.isObjectLike(value)：检查值是否类似于对象。如果一个值不为 null 并且具有“object”的 typeof 结果，则该值是类对象的。
• _.isPlainObject(value)：检查值是一个普通的对象，即由对象构造函数创建的对象还是一个具有null的[[原型]]的对象。
• _.isRegExp(value)：检查值是否被归类为 RegExp 对象。
• _.isSafeInteger(value)：检查值是否为安全整数。如果一个整数是一个 IEEE-754 双精度数字，它不是四舍五入的不安全整数的结果，那么它就是安全的。
• _.isSet(value)：检查值是否归类为 Set 对象。
• _.isString(value)：检查值是否归类为 String 基元或对象。
• _.isSymbol(value)：检查值是否被归类为 Symbol 基元或对象。
• _.isTypedArray(value)：检查值是否属于类型化数组。
• _.isUndefined(value)：检查值是否未定义。
• _.isWeakMap(value)：检查值是否被归类为 WeakMap 对象。
• _.isWeakSet(value)：检查 value 是否被归类为 WeakSet 对象。
• _.lt(value, other)：检查值是否小于其他值。
• _.lte(value, other)：检查值是否小于或等于其他值。
• _.toArray(value)：将值转换为数组。
• _.toFinite(value)：将值转换为有限数。
• _.toInteger(value)：将值转换为整数。
• _.toLength(value)：将值转换为适合用作类数组对象长度的整数。
• _.toNumber(value)：将值转换为数字。
• _.toPlainObject(value)：将值转换为普通对象，将值的继承的可枚举字符串键控属性展平为普通对象的自有属性。
• _.toSafeInteger(value)：将值转换为安全整数。可以正确比较和表示安全整数。
• _.toString(value)：将值转换为字符串。对于 null 和 undefined 值，返回一个空字符串。 -0 的符号被保留。

6、Math方法

• _.add(augend, addend)
• _.ceil(number, [precision=0])
• _.divide(dividend, divisor)
• _.floor(number, [precision=0])
• _.max(array)
• _.maxBy(array, [iteratee=_.identity])
• _.mean(array)
• _.meanBy(array, [iteratee=_.identity])
• _.min(array)
• _.minBy(array, [iteratee=_.identity])
• _.multiply(multiplier, multiplicand)
• _.round(number, [precision=0])
• _.sum(array)
• _.sumBy(array, [iteratee=_.identity])

7、Number方法

• _.clamp(number, [lower], upper)
• _.inRange(number, [start=0], end)
• _.random([lower=0], [upper=1], [floating])

8、Object方法

• _.assign(object, [sources])
• _.assignIn(object, [sources])
• _.assignInWith(object, sources, [customizer])
• _.assignWith(object, sources, [customizer])
• _.at(object, [paths])
• _.create(prototype, [properties])
• _.defaults(object, [sources])
• _.defaultsDeep(object, [sources])
• _.findKey(object, [predicate=_.identity])
• _.findLastKey(object, [predicate=_.identity])
• _.forIn(object, [iteratee=_.identity])
• _.forInRight(object, [iteratee=_.identity])
• _.forOwn(object, [iteratee=_.identity])
• _.forOwnRight(object, [iteratee=_.identity])
• _.functions(object)
• _.functionsIn(object)
• _.get(object, path, [defaultValue])
• _.has(object, path)
• _.hasIn(object, path)
• _.invert(object)
• _.invertBy(object, [iteratee=_.identity])
• _.invoke(object, path, [args])
• _.keys(object)
• _.keysIn(object)
• _.mapKeys(object, [iteratee=_.identity])
• _.mapValues(object, [iteratee=_.identity])
• _.merge(object, [sources])
• _.mergeWith(object, sources, customizer)
• _.omit(object, [paths])
• _.omitBy(object, [predicate=_.identity])
• _.pick(object, [paths])
• _.pickBy(object, [predicate=_.identity])
• _.result(object, path, [defaultValue])
• _.set(object, path, value)
• _.setWith(object, path, value, [customizer])
• _.toPairs(object)
• _.toPairsIn(object)
• _.transform(object, [iteratee=_.identity], [accumulator])
• _.unset(object, path)
• _.update(object, path, updater)
• _.updateWith(object, path, updater, [customizer])
• _.values(object)
• _.valuesIn(object)

9、Seq方法

• _(value)
• _.chain(value)
• _.tap(value, interceptor)
• _.thru(value, interceptor)
• _.prototype[Symbol.iterator]()
• _.prototype.at([paths])
• _.prototype.chain()
• _.prototype.commit()
• _.prototype.next()
• _.prototype.plant(value)
• _.prototype.reverse()
• _.prototype.value()

10、String 方法

• _.camelCase([string=''])
• _.capitalize([string=''])
• _.deburr([string=''])
• _.endsWith([string=''], [target], [position=string.length])
• _.escape([string=''])
• _.escapeRegExp([string=''])
• _.kebabCase([string=''])
• _.lowerCase([string=''])
• _.lowerFirst([string=''])
• _.pad([string=''], [length=0], [chars=' '])
• _.padEnd([string=''], [length=0], [chars=' '])
• _.padStart([string=''], [length=0], [chars=' '])
• _.parseInt(string, [radix=10])
• _.repeat([string=''], [n=1])
• _.replace([string=''], pattern, replacement)
• _.snakeCase([string=''])
• _.split([string=''], separator, [limit])
• _.startCase([string=''])
• _.startsWith([string=''], [target], [position=0])
• _.template([string=''], [options={}])
• _.toLower([string=''])
• _.toUpper([string=''])
• _.trim([string=''], [chars=whitespace])
• _.trimEnd([string=''], [chars=whitespace])
• _.trimStart([string=''], [chars=whitespace])
• _.truncate([string=''], [options={}])
• _.unescape([string=''])
• _.upperCase([string=''])
• _.upperFirst([string=''])
• _.words([string=''], [pattern])

11、Util方法

• _.attempt(func, [args])
• _.bindAll(object, methodNames)
• _.cond(pairs)
• _.conforms(source)
• _.constant(value)
• _.defaultTo(value, defaultValue)
• _.flow([funcs])
• _.flowRight([funcs])
• _.identity(value)
• _.iteratee([func=_.identity])
• _.matches(source)
• _.matchesProperty(path, srcValue)
• _.method(path, [args])
• _.methodOf(object, [args])
• _.mixin([object=lodash], source, [options={}])
• _.noConflict()
• _.noop()
• _.nthArg([n=0])
• _.over([iteratees=[_.identity]])
• _.overEvery([predicates=[_.identity]])
• _.overSome([predicates=[_.identity]])
• _.property(path)
• _.propertyOf(object)
• _.range([start=0], end, [step=1])
• _.rangeRight([start=0], end, [step=1])
• _.runInContext([context=root])
• _.stubArray()
• _.stubFalse()
• _.stubObject()
• _.stubString()
• _.stubTrue()
• _.times(n, [iteratee=_.identity])
• _.toPath(value)
• _.uniqueId([prefix=''])

12、Properties

• _.VERSION
• _.templateSettings
• _.templateSettings.escape
• _.templateSettings.evaluate
• _.templateSettings.imports
• _.templateSettings.interpolate
• _.templateSettings.variable

13、Methods

• _.templateSettings.imports._