lodash

一个 JavaScript 的实用工具库, 表现一致性, 模块化, 高性能, 以及 可扩展

Example

_.assign({ 'a': 1 }, { 'b': 2 }, { 'c': 3 });
// → { 'a': 1, 'b': 2, 'c': 3 }

_.map([1, 2, 3], function(n) { return n * 3; });
// → [3, 6, 9]

特点

• ~100% 代码覆盖率
• 遵循 语义化版本控制规范
• 延迟计算链
• _(…) 支持隐式链
• _.ary & _.rearg 改变函数的实参个数和顺序
• _.at 更方便的获取数组或对象的值
• _.attempt 无需 try-catch 来处理可能会出错的执行函数
• _.before 与 _.after 互补
• _.bindKey 实现 “懒传参”
• _.chunk 按给定个数来拆分数组
• _.clone 支持对 Date & RegExp 对象的浅拷贝
• _.cloneDeep 深拷贝数组或对象
• _.curry & _.curryRight 用于创建 柯里化 函数
• _.debounce & _.throttle 处理函数防抖和节流
• _.defaultsDeep 深分配对象的可枚举属性
• _.fill 指定值填充数组
• _.findKey 按 keys 查找对象
• _.flow 与 _.flowRight (即 _.compose) 搭配
• _.forEach 支持提前中断
• _.forIn 遍历对象所有的可枚举属性
• _.forOwn 遍历对象的所有属性
• _.get & _.set 以 path 的方式获取和设置对象属性
• _.gt, _.gte, _.lt, & _.lte 关系比较方法
• _.inRange 检测给定的数值是否在指定范围内
• _.isNative 检测是否是原生函数
• _.isPlainObject & _.toPlainObject 检测是否是普通对象以及转换为普通对象
• _.isTypedArray 检测是否是类型数组
• _.mapKeys 按对象的 key 迭代，并返回新 key 的对象
• _.matches 支持深匹配对象
• _.matchesProperty & _.matches & _.property 互补
• _.merge 相当于递归版 _.extend
• _.method & _.methodOf 创建一个调用方法的函数
• _.modArgs 更高级的功能组合
• _.parseInt 兼容各环境
• _.pull, _.pullAt, & _.remove 方便调整数组
• _.random 支持返回浮点数
• _.restParam & _.spread 应用一个 rest arguments 和 Spread operator 参数传递给函数
• _.runInContext 无影响的 mixins 且更方便模拟
• _.slice 支持裁剪类数组
• _.sortByAll & _.sortByOrder 多个属性排序
• _.support 标记环境功能
• _.template 支持 “imports” 方式 & ES 字符串模板
• _.transform 更强大的 _.reduce 代替方法
• _.unzipWith & _.zipWith 指定如何重组分解后的数组
• _.valuesIn 获取所有可枚举属性的值
• _.xor & _.difference, _.intersection, & _.union 互补
• _.add, _.round, _.sum, 及更多 数学方法
• _.bind, _.curry, _.partial, & 及更多 支持自定参数占位
• _.capitalize, _.trim, & 及更多 string 方法
• _.clone, _.isEqual, & 及更多 接受自定回调函数
• _.dropWhile, _.takeWhile, & 及更多 互补 _.first, _.initial, _.last, & _.rest
• _.findLast, _.findLastKey, & 及更多 右结合方法
• _.includes, _.toArray, & 及更多 接受字符串方式
• _#commit & _#plant 配合链式队列
• _#thru 传递链式队列的值

关于翻译

• 该文档由 think2011 翻译，遵循 MIT协议，翻译质量可能没法特别好，但会保证尽可能反复细心。
• 如果您有任何建议，或者意见，欢迎在此讨论，及时更正 ;-)。

下载

查看 版本区别 来选择适合你的版本

• 核心版 (gzip压缩后 ~4kB)
• 完整版 (gzip压缩后 ~22kB)

引入

浏览器中使用:

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

AMD 规范中使用:

require(['lodash'], function(_) {});

使用 npm 安装:

$ {sudo -H} npm i -g npm$ npm i --save lodash

Node.js/io.js 中使用:

// 直接引用现代版本
var _ = require('lodash');

// 或引用某分类下的所有方法
var array = require('lodash/array');

// 或者引用具体方法 (很适合在 browserify/webpack 中做最小化打包)
var chunk = require('lodash/array/chunk');

查看 源码包 了解更多详情

注意: 在 REPL 中不要声明 特殊变量 "_"，安装 n_ 来代替。

模块格式

lodash 还有多种构建模块的格式

• npm 构建格式: 现代, 兼容, & 单个方法
• AMD 构建格式: 现代 & 兼容
• ES 构建格式: 现代

CDN 服务在 cdnjs & jsDelivr，通过 版本定制 构建你需要的模块，在找更多的功能用法? 试试 lodash-fp

深入了解

查看我们的 更新日志, 路线图, 以及 社区里的播客、文章、视频.

兼容性

在 Chrome 43-44, Firefox 38-39, IE 6-11, MS Edge, Safari 5-8, ChakraNode 0.12.2, Node.js 0.8.28, 0.10.40, 0.12.7, & 4.0.0, PhantomJS 1.9.8, RingoJS 0.11, & Rhino 1.7.6 测试通过

自动化测试 & 持续集成 已在运作， 特别感谢 Sauce Labs 提供的浏览器自动化测试。

版本定制

通过版本定制可以很轻松的定制仅包含你所需功能的 lodash 版本 。更棒的是，我们已经帮你处理好了函数依赖和别名对应，查看 版本区别 & 选择一个适合你的版本。

使用 Grunt? 我们准备了 Grunt plugin 协助构建 lodash。

安装 lodash-cli 来作为 lodash 全局命令行工具:

$ {sudo -H} npm i -g npm
$ {sudo -H} npm i -g lodash-cli
$ lodash -h

注意: 请先卸载旧版本，再安装 lodash-cli。

• 兼容版本构建，同时支持新旧运行环境，使用 compat 修饰。 (默认)

lodash compat

• 现代版本构建，针对新的环境，包括 ES5/ES6 支持，使用 modern 修饰。

lodash modern

• 严格模式版本构建, 开启 ES 严格模式，使用 strict 修饰。

lodash strict

• 模块化版本构建，拆散 lodash 为各个模块，使用 modularize 修饰。

lodash modularize

构建命令:

• 使用 category 命令以逗号分隔的方式传入需要的函数分类。可用的函数分类有： “array”, “chain”, “collection”, “date”, “function”, “lang”, “object”, “number”, “string”, & “utility”=。

lodash category=collection,function

• 使用 exports 命令以逗号分隔的方式传入导出 lodash 函数的方式，可用的方式有： “amd”, “commonjs”, “es”, “global”, “iojs”, “node”, “npm”, “none”, & “umd”.

lodash exports=amd,commonjs,iojs

• 使用 iife 命令指定代码替换 包裹 lodash 的 IIFE。

lodash iife="!function(window,undefined){%output%}(this)"

• 使用 include 命令以逗号分隔的方式传入需要包含的函数。

lodash include=each,filter,map

• 使用 minus 命令以逗号分隔的方式传入需要删减的函数/分类。

lodash modern minus=result,shuffle

• 使用 plus 命令以逗号分隔的方式传入需要补充的函数/分类。

lodash category=array plus=random,template

• 使用 template 命令传入路径相匹配的文件生成预编译模板。 注意: 预编译模板分配在 _.templates 对象上。

lodash template="./*.jst"

• 使用 settings 命令设置预编译模板时的模板语法。

lodash settings="{interpolate:/\{\{([\s\S]+?)\}\}/g}"

• 使用 moduleId 命令指定 lodash 的 AMD module ID 或 包含 lodash 的编译模板的 module ID。指定为 none 表示创建编译模板不依赖 lodash。

lodash moduleId=underscore

注意:

• 所有命令可以组合（除了 compat & modern）
• exports 的值 “es” & “npm” 只能与 modularize 命令联用。
• modularize 命令使用最先的 exports 的值作为模块格式，忽略后续的值。
• 除非指定 -o 或 --output，不然所有文件会保存在当前工作目录。
• Node.js 0.10.8-0.10.11 存在 bugs 导致无法最小化构建。

另外还支持以下选项：

-c, --stdout .......... 输出到stdout(译注：类似直接输出在终端那样)
-d, --development ..... 输出非最小化的开发代码
-h, --help ............ 显示帮助信息
-m, --source-map ...... 生成source-map文件
-o, --output .......... 指定输出的路径/文件名
-p, --production ...... 输出最小化后的产品代码
-s, --silent .......... 不显示常规的日志输出
-V, --version ......... 显示当前的 lodash 版本号

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

_.chunk(['a', 'b', 'c', 'd'], 2);
// => [['a', 'b'], ['c', 'd']]

_.chunk(['a', 'b', 'c', 'd'], 3);
// => [['a', 'b', 'c'], ['d']]

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

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

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

var array = [1];
var other = _.concat(array, 2, [3], [[4]]);

console.log(other);
// => [1, 2, 3, [4]]

console.log(array);
// => [1]

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

_.difference([3, 2, 1], [4, 2]);
// => [3, 1]

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

_.differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], Math.floor);
// => [3.1, 1.3]

// 使用了 `_.property` 的回调结果
_.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
// => [{ 'x': 2 }]

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

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];

_.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
// => [{ 'x': 2, 'y': 1 }]

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

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

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

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

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

var resolve = _.partial(_.map, _, 'user');

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

resolve( _.dropRightWhile(users, function(o) { return !o.active; }) );
// => ['barney']

// 使用了 `_.matches` 的回调结果
resolve( _.dropRightWhile(users, { 'user': 'pebbles', 'active': false }) );
// => ['barney', 'fred']

// 使用了 `_.matchesProperty` 的回调结果
resolve( _.dropRightWhile(users, ['active', false]) );
// => ['barney']

// 使用了 `_.property` 的回调结果
resolve( _.dropRightWhile(users, 'active') );
// => ['barney', 'fred', 'pebbles']

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

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

_.dropWhile(users, function(o) { return !o.active; });
// => 结果: ['pebbles']

// 使用了 `_.matches` 的回调处理
_.dropWhile(users, { 'user': 'barney', 'active': false });
// => 结果: ['fred', 'pebbles']

// 使用了 `_.matchesProperty` 的回调处理
_.dropWhile(users, ['active', false]);
// => 结果: ['pebbles']

// 使用了 `_.property` 的回调处理
_.dropWhile(users, 'active');
// => 结果: ['barney', 'fred', 'pebbles']

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

注意: 这个方法会改变数组

var array = [1, 2, 3];

_.fill(array, 'a');
console.log(array);
// => ['a', 'a', 'a']

_.fill(Array(3), 2);
// => [2, 2, 2]

_.fill([4, 6, 8, 10], '*', 1, 3);
// => [4, '*', '*', 10]

这个方法类似 _.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

// 使用了 `_.matches` 的回调结果
_.findIndex(users, { 'user': 'fred', 'active': false });
// => 1

// 使用了 `_.matchesProperty` 的回调结果
_.findIndex(users, ['active', false]);
// => 0

// 使用了 `_.property` 的回调结果
_.findIndex(users, 'active');
// => 2

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

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

_.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
// => 2

// 使用了 `_.matches` 的回调结果
_.findLastIndex(users, { 'user': 'barney', 'active': true });
// => 0

// 使用了 `_.matchesProperty` 的回调结果
_.findLastIndex(users, ['active', false]);
// => 2

// 使用了 `_.property` 的回调结果
_.findLastIndex(users, 'active');
// => 0

向上一级展平数组嵌套

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

递归展平 数组.

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

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

var array = [1, [2, [3, [4]], 5]];

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

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

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

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

获得数组的首个元素

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

_.head([]);
// => undefined

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

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

// 使用了 `fromIndex`
_.indexOf([1, 2, 1, 2], 2, 2);
// => 3

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

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

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

_.intersection([2, 1], [4, 2], [1, 2]);
// => [2]

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

_.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
// => [2.1]

// 使用了 `_.property` 的回调结果
_.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }]

这个方法类似 _.intersection，除了它接受一个 comparator 调用每一个数组和值。iteratee 会传入2个参数：((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 }]

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

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

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

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

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

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

// 使用了 `fromIndex`
_.lastIndexOf([1, 2, 1, 2], 2, 2);
// => 1

反转数组，第一个元素移动到最后一位，第二个元素移动到倒数第二，类似这样。

注意: 这个方法会改变数组，根据 Array#reverse

var array = [1, 2, 3];

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

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

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

注意: 不同于 _.without，这个方法会改变数组。

var array = [1, 2, 3, 1, 2, 3];

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

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

注意: 不同于 _.difference，这个方法会改变数组。

var array = [1, 2, 3, 1, 2, 3];

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

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

注意: 不同于 _.differenceBy，这个方法会改变数组。

var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];

_.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
console.log(array);
// => [{ 'x': 2 }]

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

注意: 不同于 _.at，这个方法会改变数组。

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

console.log(array);
// => [5, 15]

console.log(evens);
// => [10, 20]

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

注意: Unlike _.filter，这个方法会改变数组。

var array = [1, 2, 3, 4];
var evens = _.remove(array, function(n) {
  return n % 2 == 0;
});

console.log(array);
// => [1, 3]

console.log(evens);
// => [2, 4]

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

注意: 这个方法用于代替 Array#slice 来确保数组正确返回

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

_.sortedIndex([30, 50], 40);
// => 1

_.sortedIndex([4, 5], 4);
// => 0

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

var dict = { 'thirty': 30, 'forty': 40, 'fifty': 50 };

_.sortedIndexBy(['thirty', 'fifty'], 'forty', _.propertyOf(dict));
// => 1

// 使用了 `_.property` 回调结果
_.sortedIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
// => 0

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

_.sortedIndexOf([1, 1, 2, 2], 2);
// => 2

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

_.sortedLastIndex([4, 5], 4);
// => 1

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

// 使用了 `_.property` 的回调结果
_.sortedLastIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
// => 1

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

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

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

_.sortedUniq([1, 1, 2]);
// => [1, 2]

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

_.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
// => [1.1, 2.3]

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

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

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

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

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

_.take([1, 2, 3], 5);
// => [1, 2, 3]

_.take([1, 2, 3], 0);
// => []

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

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

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

_.takeRight([1, 2, 3], 5);
// => [1, 2, 3]

_.takeRight([1, 2, 3], 0);
// => []

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

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

_.takeRightWhile(users, function(o) { return !o.active; });
// => 结果:  ['fred', 'pebbles']

// 使用了 `_.matches` 的回调处理
_.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
// => 结果:  ['pebbles']

// 使用了 `_.matchesProperty` 的回调处理
_.takeRightWhile(users, ['active', false]);
// => 结果:  ['fred', 'pebbles']

// 使用了 `_.property` 的回调处理
_.takeRightWhile(users, 'active');
// => []

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

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

_.takeWhile(users, function(o) { return !o.active; });
// => objects for ['barney', 'fred']

// 使用了 `_.matches` 的回调处理
_.takeWhile(users, { 'user': 'barney', 'active': false });
// =>结果: ['barney']

// 使用了 `_.matchesProperty` 的回调处理
_.takeWhile(users, ['active', false]);
// =>结果: ['barney', 'fred']

// 使用了 `_.property` 的回调处理
_.takeWhile(users, 'active');
// => []

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

_.union([2, 1], [4, 2], [1, 2]);
// => [2, 1, 4]

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

_.unionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
// => [2.1, 1.2, 4.3]

// 使用了 `_.property` 的回调结果
_.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

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

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.unionWith(objects, others, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]

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

_.uniq([2, 1, 2]);
// => [2, 1]

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

_.uniqBy([2.1, 1.2, 2.3], Math.floor);
// => [2.1, 1.2]

// 使用了 `_.property` 的回调结果
_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

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

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 },  { 'x': 1, 'y': 2 }];

_.uniqWith(objects, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]

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

var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]

_.unzip(zipped);
// => [['fred', 'barney'], [30, 40], [true, false]]

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

var zipped = _.zip([1, 2], [10, 20], [100, 200]);
// => [[1, 10, 100], [2, 20, 200]]

_.unzipWith(zipped, _.add);
// => [3, 30, 300]

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

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

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

_.xor([2, 1], [4, 2]);
// => [1, 4]

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

_.xorBy([2.1, 1.2], [4.3, 2.4], Math.floor);
// => [1.2, 4.3]

// 使用了 `_.property` 的回调结果
_.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 2 }]

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

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.xorWith(objects, others, _.isEqual);
// => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]

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

_.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]

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

_.zipObject(['a', 'b'], [1, 2]);
// => { 'a': 1, 'b': 2 }

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

_.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
// => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }

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

_.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
  return a + b + c;
});
// => [111, 222]

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

_.countBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': 1, '6': 2 }

_.countBy(['one', 'two', 'three'], 'length');
// => { '3': 2, '5': 1 }

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

_.every([true, 1, null, 'yes'], Boolean);
// => false

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

// 使用了 `_.matches` 的回调结果
_.every(users, { 'user': 'barney', 'active': false });
// => false

// 使用了 `_.matchesProperty` 的回调结果
_.every(users, ['active', false]);
// => true

// 使用了 `_.property` 的回调结果
_.every(users, 'active');
// => false

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

var resolve = _.partial(_.map, _, 'user');

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

resolve( _.filter(users, function(o) { return !o.active; }) );
// => ['fred']

// 使用了 `_.matches` 的回调结果
resolve( _.filter(users, { 'age': 36, 'active': true }) );
// => ['barney']

// 使用了 `_.matchesProperty` 的回调结果
resolve( _.filter(users, ['active', false]) );
// => ['fred']

// 使用了 `_.property` 的回调结果
resolve( _.filter(users, 'active') );
// => ['barney']

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

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

_.find(users, function(o) { return o.age < 40; });
// => 结果: 'barney'

// 使用了 `_.matches` 的回调结果
_.find(users, { 'age': 1, 'active': true });
// => 结果: 'pebbles'

// 使用了 `_.matchesProperty` 的回调结果
_.find(users, ['active', false]);
// => 结果: 'fred'

// 使用了 `_.property` 的回调结果
_.find(users, 'active');
// => 结果: 'barney'

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

_.findLast([1, 2, 3, 4], function(n) {
  return n % 2 == 1;
});
// => 3

创建一个扁平化的数组，每一个值会传入 iteratee 处理，处理结果会与值合并。 iteratee 会传入3个参数：(value, index|key, array)。

function duplicate(n) {
  return [n, n];
}

_.flatMap([1, 2], duplicate);
// => [1, 1, 2, 2]

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

注意: 与其他集合方法一样，对象的 length 属性也会被遍历，避免这种情况，可以用 .forIn 或者 .forOwn 代替。

_([1, 2]).forEach(function(value) {
  console.log(value);
});
// => 输出 `1` 和 `2`

_.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
  console.log(key);
});
// => 输出 'a' 和 'b' (不保证遍历的顺序)

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

_.forEachRight([1, 2], function(value) {
  console.log(value);
});
// => 输出 `2` 和 `1`

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

_.groupBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': [4.2], '6': [6.1, 6.3] }

// 使用了 `_.property` 的回调结果
_.groupBy(['one', 'two', 'three'], 'length');
// => { '3': ['one', 'two'], '5': ['three'] }

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

_.includes([1, 2, 3], 1);
// => true

_.includes([1, 2, 3], 1, 2);
// => false

_.includes({ 'user': 'fred', 'age': 40 }, 'fred');
// => true

_.includes('pebbles', 'eb');
// => true

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

_.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
// => [[1, 5, 7], [1, 2, 3]]

_.invokeMap([123, 456], String.prototype.split, '');
// => [['1', '2', '3'], ['4', '5', '6']]

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

var array = [
  { 'dir': 'left', 'code': 97 },
  { 'dir': 'right', 'code': 100 }
];

_.keyBy(array, function(o) {
  return String.fromCharCode(o.code);
});
// => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }

_.keyBy(array, 'dir');
// => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }

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

有许多 lodash 的方法以 iteratees 的身份守护其工作，例如： _.every, _.filter, _.map, _.mapValues, _.reject, 以及 _.some

被守护的有:
ary, curry, curryRight, drop, dropRight, every, fill, invert, parseInt, random, range, rangeRight, slice, some, sortBy, take, takeRight, template, trim, trimEnd, trimStart, 以及 words

function square(n) {
  return n * n;
}

_.map([4, 8], square);
// => [16, 64]

_.map({ 'a': 4, 'b': 8 }, square);
// => [16, 64] (无法保证遍历的顺序)

var users = [
  { 'user': 'barney' },
  { 'user': 'fred' }
];

// 使用了 `_.property` 的回调结果
_.map(users, 'user');
// => ['barney', 'fred']

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

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 34 },
  { 'user': 'fred',   'age': 42 },
  { 'user': 'barney', 'age': 36 }
];

// 以 `user` 升序排序 再 以 `age` 降序排序。
_.orderBy(users, ['user', 'age'], ['asc', 'desc']);
// => 结果: [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]

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

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

_.partition(users, function(o) { return o.active; });
// => 结果: [['fred'], ['barney', 'pebbles']]

// 使用了 `_.matches` 的回调结果
_.partition(users, { 'age': 1, 'active': false });
// => 结果: [['pebbles'], ['barney', 'fred']]

// 使用了 `_.matchesProperty` 的回调结果
_.partition(users, ['active', false]);
// => 结果: [['barney', 'pebbles'], ['fred']]

// 使用了 `_.property` 的回调结果
_.partition(users, 'active');
// => 结果: [['fred'], ['barney', 'pebbles']]

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

有许多 lodash 的方法以 iteratees 的身份守护其工作，例如： _.reduce, _.reduceRight, 以及 _.transform.

被守护的有:
assign, defaults, defaultsDeep, includes, merge, orderBy, 以及 sortBy

_.reduce([1, 2], function(sum, n) {
  return sum + n;
}, 0);
// => 3

_.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
  (result[value] || (result[value] = [])).push(key);
  return result;
}, {});
// => { '1': ['a', 'c'], '2': ['b'] } (无法保证遍历的顺序)

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

var array = [[0, 1], [2, 3], [4, 5]];

_.reduceRight(array, function(flattened, other) {
  return flattened.concat(other);
}, []);
// => [4, 5, 2, 3, 0, 1]

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

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

_.reject(users, function(o) { return !o.active; });
// => 结果: ['fred']

// 使用了 `_.matches` 的回调结果
_.reject(users, { 'age': 40, 'active': true });
// => 结果: ['barney']

// 使用了 `_.matchesProperty` 的回调结果
_.reject(users, ['active', false]);
// => 结果: ['fred']

// 使用了 `_.property` 的回调结果
_.reject(users, 'active');
// => 结果: ['barney']

从集合中随机获得元素

_.sample([1, 2, 3, 4]);
// => 2

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

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

_.sampleSize([1, 2, 3], 4);
// => [2, 3, 1]

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

_.shuffle([1, 2, 3, 4]);
// => [4, 1, 3, 2]

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

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

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

_.size('pebbles');
// => 7

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

_.some([null, 0, 'yes', false], Boolean);
// => true

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

// 使用了 `_.matches` 的回调结果
_.some(users, { 'user': 'barney', 'active': false });
// => false

// 使用了 `_.matchesProperty` 的回调结果
_.some(users, ['active', false]);
// => true

// 使用了 `_.property` 的回调结果
_.some(users, 'active');
// => true

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

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 36 },
  { 'user': 'fred',   'age': 42 },
  { 'user': 'barney', 'age': 34 }
];


_.sortBy(users, function(o) { return o.user; });
// => 排序结果 [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]

_.sortBy(users, ['user', 'age']);
// => 排序结果 [['barney', 34], ['barney', 36], ['fred', 42], ['fred', 48]]

_.sortBy(users, 'user', function(o) {
  return Math.floor(o.age / 10);
});
// => 排序结果 [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]

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

_.defer(function(stamp) {
  console.log(_.now() - stamp);
}, _.now());
// => 记录延迟函数调用的毫秒数

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

var saves = ['profile', 'settings'];

var done = _.after(saves.length, function() {
  console.log('done saving!');
});

_.forEach(saves, function(type) {
  asyncSave({ 'type': type, 'complete': done });
});
// => 2次 `asyncSave`之后，输出 'done saving!'。

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

_.map(['6', '8', '10'], _.ary(parseInt, 1));
// => [6, 8, 10]

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

jQuery(element).on('click', _.before(5, addContactToList));
// => 最多允许添加4个联系人到列表里

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

注意: 不同于原生的 Function#bind，这个方法不会设置绑定函数的 length 属性。

var greet = function(greeting, punctuation) {
  return greeting + ' ' + this.user + punctuation;
};

var object = { 'user': 'fred' };

var bound = _.bind(greet, object, 'hi');
bound('!');
// => 'hi fred!'

// 使用了占位符
var bound = _.bind(greet, object, _, '!');
bound('hi');
// => 'hi fred!'

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

这个方法与 _.bind 的不同之处在于允许重写绑定函数即使它还不存在。 浏览 Peter Michaux's article 了解更多详情。

这个 _.bindKey.placeholder 的值，默认是以 _ 作为附加部分参数的占位符。

var object = {
  'user': 'fred',
  'greet': function(greeting, punctuation) {
    return greeting + ' ' + this.user + punctuation;
  }
};

var bound = _.bindKey(object, 'greet', 'hi');
bound('!');
// => 'hi fred!'

object.greet = function(greeting, punctuation) {
  return greeting + 'ya ' + this.user + punctuation;
};

bound('!');
// => 'hiya fred!'

// 使用了占位符
var bound = _.bindKey(object, 'greet', _, '!');
bound('hi');
// => 'hiya fred!'

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

这个 _.curry.placeholder 的值，默认是以 _ 作为附加部分参数的占位符。

注意: 这个方法不会设置 "length" 到 curried 函数上。

var abc = function(a, b, c) {
  return [a, b, c];
};

var curried = _.curry(abc);

curried(1)(2)(3);
// => [1, 2, 3]

curried(1, 2)(3);
// => [1, 2, 3]

curried(1, 2, 3);
// => [1, 2, 3]

// 使用了占位符
curried(1)(_, 3)(2);
// => [1, 2, 3]

这个方法类似 _.curry。 除了它接受参数的方式用 _.partialRight 代替了 _.partial。

这个 _.curry.placeholder 的值，默认是以 _ 作为附加部分参数的占位符。

注意: 这个方法不会设置 "length" 到 curried 函数上。

var abc = function(a, b, c) {
  return [a, b, c];
};

var curried = _.curryRight(abc);

curried(3)(2)(1);
// => [1, 2, 3]

curried(2, 3)(1);
// => [1, 2, 3]

curried(1, 2, 3);
// => [1, 2, 3]

// 使用了占位符
curried(3)(1, _)(2);
// => [1, 2, 3]

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

注意: 如果 leading 和 trailing 都设定为 true。 则 func 允许 trailing 方式调用的条件为: 在 wait 期间多次调用防抖方法。

查看 David Corbacho's article 了解 _.debounce 与 _.throttle 的区别。

// 避免窗口在变动时出现昂贵的计算开销。
jQuery(window).on('resize', _.debounce(calculateLayout, 150));

// 当点击时 `sendMail` 随后就被调用。
jQuery(element).on('click', _.debounce(sendMail, 300, {
  'leading': true,
  'trailing': false
}));

// 确保 `batchLog` 调用1次之后，1秒内会被触发。
var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
var source = new EventSource('/stream');
jQuery(source).on('message', debounced);

// 取消一个 trailing 的防抖动调用
jQuery(window).on('popstate', debounced.cancel);

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

_.defer(function(text) {
  console.log(text);
}, 'deferred');
// 一毫秒或更久一些输出 'deferred'。

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

_.delay(function(text) {
  console.log(text);
}, 1000, 'later');
// => 一秒后输出 'later'。

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

var flipped = _.flip(function() {
  return _.toArray(arguments);
});

flipped('a', 'b', 'c', 'd');
// => ['d', 'c', 'b', 'a']

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

注意: 缓存会暴露在缓存函数的 cache 上。 它是可以定制的，只要替换了 _.memoize.Cache 构造函数，或实现了 Map 的 delete， get， has， 以及 set方法。

var object = { 'a': 1, 'b': 2 };
var other = { 'c': 3, 'd': 4 };

var values = _.memoize(_.values);
values(object);
// => [1, 2]

values(other);
// => [3, 4]

object.a = 2;
values(object);
// => [1, 2]

// 修改结果缓存
values.cache.set(object, ['a', 'b']);
values(object);
// => ['a', 'b']

// 替换 `_.memoize.Cache`
_.memoize.Cache = WeakMap;

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

function isEven(n) {
  return n % 2 == 0;
}

_.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
// => [1, 3, 5]