# 101 中文文档

规范地址：https://npmcn.com/package/101/

版本：1\.6\.3
npm 元数据更新时间：2022-06-12T14:05:27.277Z
中文译文更新时间：2026-11-05T17:46:25.688Z
软件包许可：MIT

本文由上游 README 翻译，可能存在偏差，请结合原文核对 API、命令与配置。版权与许可归原作者所有。

原始 npm 页面：https://www.npmjs.com/package/101
原文对照：https://npmcn.com/package/101/?lang=original
项目主页：https://github.com/tjmehta/101
源码仓库：https://github.com/tjmehta/101

## 关键信息（来自 npm 元数据）

- 包体积（解压后）：59.1 kB，50 个文件
- 模块格式：CommonJS
- TypeScript 类型：未声明
- 运行依赖：3 个
- 首次发布：2014-04-11T08:13:12.596Z
- 最新版本发布：2018-04-15T19:05:46.394Z
- 近 30 天下载量：144885（2026-10-04 至 2026-11-02，npm 官方下载统计）
- 已发布版本数：43（近 12 个月 0 个）

## 中文简介

假设 es5+ 可选择性要求的普通javascript utils

## 安装

```sh
npm install 101
```

也可以使用：`pnpm add 101`、`yarn add 101`、`bun add 101`

## README

# ![101](http://i.imgur.com/MFrmMt6.png)

[![NPM](https://nodei.co/npm/101.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/101/)

[![Build Status](https://travis-ci.org/tjmehta/101.svg?branch=master)](https://travis-ci.org/tjmehta/101) [![Coverage Status](https://coveralls.io/repos/tjmehta/101/badge.png)](https://coveralls.io/r/tjmehta/101) [![Dependency Status](https://david-dm.org/tjmehta/101.svg)](https://david-dm.org/tjmehta/101) [![devDependency Status](https://david-dm.org/tjmehta/101/dev-status.svg)](https://david-dm.org/tjmehta/101#info=devDependencies)

# 为什么要另建JS图书馆?

### 1) 保留101,以尽量减少与香草联署材料的重叠.

-   101个提法是用香草JS方法进行良好的工作.
-   101只重复梵地拉联合来文,以提供功能性方案拟订模式,或 得到广泛支持的联署材料版本(目前为ES5)中没有这一方法.
-   其他的库经常重复大量ES5:用于Each,映射,减少,过滤,排序等.

### 2) 不需要建立习惯.

-   101,自然进口,你使用的东西会被捆绑.
-   每种用法都是一个模块 `require('101/<util>')`。 。 。 .
-   目前通用JS(节点,浏览器,webpack等)得到支持,我将根据请求添加其他模块系统支持.
-   其他库可以很大,在优化大小时需要手工创建自定义构建.

### 为何不将每个模块作为单个模块发布?

我通常同意这个哲学,但实际上,坚持模块模式 对微模块(如101模块)来说

-   微型模块在整个项目中的存在可以经常改变,因为人们可能会发现 自己不断更新他们的软件包. json(重复地添加并去除相同的微模块).
-   拆分微模块可导致数百个依赖性的项目,而这种依赖性可能难以维持.

# 安装

`npm install 101`

# 使用量

## 指定( aka 扩展)

就像ES6一样 `Object.assign`。以任意数量的对象(返回正本)扩展对象.

```js
var assign = require('101/assign');

var target = { foo: 1 };
var source1 = { bar: 1 };
var source2 = { baz: 1 };
assign(target, source1) // { foo: 1, bar: 1, baz: 1 } target extended with source objects
assign(target, source1, source2) // { foo: 1, bar: 1, baz: 1 } target extended with source objects
```

## 财务报告和审定财务报表

功能版本 `&&`。与伟大的 `array.reduce`。 。 。 .

```js
var and = require('101/and');

and(true, false); // false
and(true, true);  // true
and(true, "foo");  // "foo"
```

## 应用

功能版本 `function.apply`。 。 。 . 支持部分功能( 与数组函数相通) .

```js
var apply = require('101/apply');
[sum].map(apply(null, [1, 2, 3])); // [6] = [sum(1,2,3)] = [1+2+3]
function sum () {  /* sums all arguments */ }
apply({ prop: 'val' })(function () { return this.prop; });  // 'val'
```

## 绑定

在对象中绑定方法 . 您可以通过包含方法名称的阵列, 将它作为第二 参数或让其空来约束所有可用的方法.

```js
var bindAll = require('101/bind-all');
var obj = {
  init: function() {
    this.on(this.handler);
  },
  on: function(handler) {
    return handler();
  },
  handler: function() {
    console.log(this.msg);
  },
  msg: 'Hello World'
}

obj.init(); // undefined

bindAll(obj);
obj.init(); // "Hello World"

bindAll(obj, ['handler']);
obj.init(); // "Hello World"
```

## 克隆

这是 [克隆](https://www.npmjs.org/package/clone) (仅将这个 bc 出口到 101)

```js
var clone = require('101/clone');
var obj = {
  foo: 1,
  bar: 2
};

clone(obj); // { foo: 1, bar: 2 }
```

## 编曲

功能构成方法. 不错 `array.reduce`。 。 。 .

```js
var compose = require('101/compose');

compose(isNaN, parseInt)('nope'); // isNaN(parseInt('nope')) // true
```

## 汇合

将一系列函数串联为一。 不错 `compose`。 。 。 .

```js
var converge = require('101/converge');

converge(mul, [add, sub])(6, 2); // mul(add(6, 2), sub(6, 2)) // (6+2) * (6-2) = 36

[ {a: true, b: false}
, {a: false, b: false}
, {a: true, b: true}
].filter(converge(and , [pluck("a") , pluck("b")])); // [{a: true, b: true}]

[f, converge(g, [h, i]), j].reduce(compose); // f(g(h(j), i(j)))
```

## 咖喱

返回曲折函数 .

```js
var curry = require('101/curry');

function add(a, b) { return a + b; }

var curriedAdd = curry(add);
var add2 = curriedAdd(2);

add2(6); // 8
add2(8); // 10

function join() { return Array.prototype.slice.call(arguments).join(''); }

curry(join, 3)(1)(0)(1); // "101"
```

## 默认

用默认填充已存在的对象值。 用于设置选项的默认值 。 与 在子对象中也提供默认值。 支持部分功能( 以数组为大) 函数)。 变异第一个参数并返回变异参数.

```js
var defaults = require('101/defaults');
var opts = { foo: 0, bar: 1 };
var defs = { foo: 1, bar: 2, qux: 2 };

defaults(opts, defs); // returns mutated `opts` { foo: 0, bar: 1, qux: 2 }
[opts].map(defaults(defs)); // [ { foo: 0, bar: 1, qux: 2 } ]

var opts = {
  foo: {
    one: 1,
    two: 2
  }
};
var defs = {
  foo: {
    two: 20,
    three: 30
  }
};
defaults(opts, defs); // { foo: { one: 1, two: 2, three: 30 } }
```

## 三角形

删除 obj\[ key\] 的功能版本,该版本在没有被删除的密钥的情况下返回相同的obj. 支持部分功能(大有数组函数,如映射).

```js
var del = require('101/del');
var obj = {
  foo: 1,
  bar: 2
};

del(obj, 'foo'); // { bar: 2 }

// use it with array.map
[obj, obj, obj].map(del('foo')); // [{ bar: 2 }, {same}, {same}]

// supports keypaths by default
var obj = {
  foo: {
    moo: 1,
    boo: 2
  },
  bar: 3
};

del(obj, 'foo.moo'); // { foo: { boo: 2 }, bar:3 }

// pass an array of keys to be deleted 
del(obj, ['foo.moo', 'bar']) // { foo: { boo: 2 } }
```

## 环境

功能版本 `str === process.env.NODE_ENV`。 。 。 . 或多相环境.

```js
var envIs = require('101/env-is');
// process.env.NODE_ENV = development
envIs('development');     // true
envIs('production');      // false
envIs('staging', 'production');     // false
envIs('development', 'production'); // true
```

## 等于

Object.is的功能性执行为浏览器的多填充,而不执行Object.is 支持部分功能( 与数组函数相通) .

```js
var equals = require('101/equals');

equals(1, 1);            // true
[1,2,3].some(equals(1)); // true
equals(1, '1');          // false
```

## 已存在

简单存在函数 .

```js
var exists = require('101/exists');

exists('foo');     // true
exists(null);      // false
exists(undefined); // false
```

## 寻找

就像ES6一样 `array.find`。 。 。 .

查找列表中传递给定函数的第一个值( predicate)并返回它. 如果不提供列表, 查找将返回接受列表作为第一个参数的部分函数 .

```js
var find = require('101/find');
var hasProps = require('101/has-properties');
var arr = [{ a: 1, b: 1 }, { b: 1 }, { c: 1 }];

var item = find(arr, hasProps({ a:1 }));
// returns { a: 1, b: 1 }
// returns null if not found

// partial-function
var partial = find(hasProps({ a: 1 }));
var item = partial(arr);
// returns { a: 1, b: 1 }
// returns null if not found
```

## 查找Index 数据

就像ES6一样 `array.findIndex`。 。 。 .

查找列表中第一个通过给定函数的值( predidect)并返回其索引. 如果不提供列表 findIndex 将返回一个接受列表作为第一个参数的部分函数 .

```js
var findIndex = require('101/find-index');
var arr = [1, 2, 3];

var index = findIndex(arr, function (val, i, arr) {
  return val === 2;
});
// returns 1
// returns -1 if not found
```

## 翻转

返回带有翻转参数的函数

```js
var flip = require('101/flip');
var curry = require('101/curry');
var hasKeypaths = require('101/has-keypaths');

var hasFooBar = curry(flip(hasKeypaths))(['foo.bar']);

hasFooBar({ foo: { bar : true } }); // true


function prefix(pre, str) {
  return pre + str;
}

flip(prefix)('hello', '_'); // "_hello"
```

## 组字

根据提供的共同密钥的值,将数组组合成组. 工作不错 `pluck` 财务报告和审定财务报表 `reduce`。 。 。 .

```js
var groupBy = require('101/group-by');
var arr = [
    {id: 1, foo: 'bar'},
    {id: 2, foo: 'qux'},
    {id: 3, foo: 'qux'}
];

groupBy(arr, 'foo')
/*
{
  bar: [
    {id: 1, foo: 'bar'}
  ],
  qux: [
    {id: 2, foo: 'qux'},
    {id: 3, foo: 'qux'}
  ]
}
*/
// always provide initial value when using with reduce!
arr.reduce(groupBy('foo'), {}) // assumes pluck if passed string
arr.reduce(groupBy(pluck('foo')), {}) // also accepts function
/*
{
  bar: [
    {id: 1, foo: 'bar'}
  ],
  qux: [
    {id: 2, foo: 'qux'},
    {id: 3, foo: 'qux'}
  ]
}
*/
```

## 有关键路径

确定密钥路径是否存在并有指定的值. 支持部分功能( 与数组函数有很大, 以及 101/ find) .

```js
var hasKeypaths = require('101/has-keypaths');
var obj = {
  foo: {
    bar: {
      qux: 1
    }
  }
};

hasKeypaths(obj, ['foo.bar.qux']);      // true
hasKeypaths(obj, { 'foo.bar.qux': 1 }); // true
hasKeypaths(obj, ['foo.qux']);          // false
hasKeypaths(obj, { 'foo.bar': 2 });     // false
hasKeypaths(obj, { 'foo.bar': 1, 'nope': 1 }); // false

// optional 'deep' arg, defaults to true
var barObj = { bar: 1 };
hasKeypaths(obj, { 'foo.bar': barObj });         // true
hasKeypaths(obj, { 'foo.bar': barObj }, true);   // true
hasKeypaths(obj, { 'foo.bar': barObj }, false);  // false
hasKeypaths(obj, { 'foo.bar': obj.foo }, false); // true
hasKeypaths(obj, ['foo.bar'], false);            // true, uses [hasOwnProperty vs in](http://stackoverflow.com/questions/13632999/if-key-in-object-or-ifobject-hasownpropertykey)

// use it with find, findIndex, or filter!
var arr = [obj, { b: 1 }, { c: 1 }];
find(arr, hasKeypaths({ 'foo.bar.qux':1 })); // { foo: { bar: { qux: 1 } } }
find(arr, hasKeypaths(['foo.bar.qux']));     // { foo: { bar: { qux: 1 } } }

// use it to verify options object has required properties
var opts = {
  host: 'localhost',
  port: '3333',
  user: {
    id: 5
  }
};
hasKeypaths(opts, ['host', 'port', 'user.id']); // true

```

## 有财产

确定密钥是否存在,如果指定,则有数值. 支持部分功能( 与数组函数有很大, 以及 101/ find) . 注:我在考虑对这种方法进行贬值,bc 与 " 有问题 " 方法相似.

```js
var hasProps = require('101/has-properties');
var obj = {
  qux: 1
};
obj['foo.bar'] = 1

hasProps(obj, ['foo', 'qux']); // true
hasProps(obj, { qux: 1 }) // true

// optional 'deep' arg, defaults to true
var barObj = { bar: 1 };
hasProps(obj, { 'foo.bar': barObj });         // true
hasProps(obj, { 'foo.bar': barObj }, true);   // true
hasProps(obj, { 'foo.bar': barObj }, false);  // false
hasProps(obj, ['foo.bar'], false);            // true, uses [hasOwnProperty vs in](http://stackoverflow.com/questions/13632999/if-key-in-object-or-ifobject-hasownpropertykey)
// use it with find, findIndex, or filter!
var arr = [{ a: 1, b: 1 }, { b: 1 }, { c: 1 }];
find(arr, hasProps({ a:1 })); // { a: 1, b: 1 }
find(arr, hasProps(['a']));   // { a: 1, b: 1 }
```

## 包含

多填充ES7 提议的Array.prototype.包括. 默认为 Array. prototype 。 包括 现相.

```js
var includes = require('101/includes');
var haystack = ['a', 'b', 'c', 'd', 'e'];
includes(haystack, 'c'); // true

// optional 3rd argument, searchFrom. Begin searching the target array from a specified index.
includes(haystack, 'c', 3); // false
includes(haystack, 'c', 0); // true

// partial argument functionality
var i = includes(haystack);
i('c') // true
i('g') // false

// example composition usage:
var not = require('101/not');
var notIn = not(includes);
[1, 2, 3, 4, 5].filter(notIn([1, 2, 3])); // [4, 5]
```

## 指数By

基于一个提供的共同密钥的值的数组对象. 工作不错 `pluck` 财务报告和审定财务报表 `reduce`。 。 。 .

```js
var arr = [
  {foo: 'bar'},
  {foo: 'qux'}
];

arr.reduce(indexBy('foo'), {}) // assumes pluck if passed string
arr.reduce(indexBy(pluck('foo')), {}) // also accepts function
// {bar: {foo: 'bar'}, qux: {foo: 'qux'}}
// always provide initial value when using with reduce!
arr.reduce(indexBy(pluck('foo')), {}) // {bar: {foo: 'bar'}, qux: {foo: 'qux'}}
```

## 实例

JavaScript实例功能版. 支持部分功能( 与数组函数相通) .

```js
var instanceOf = require('101/instance-of');

['foo', 'bar', 1].map(instanceOf('string')); // [true, true, false]
```

## 是宝莲

功能版本 `typeof val === 'boolean'`。 。 。 . 支持部分功能( 与数组函数相通) .

```js
var isBoolean = require('101/is-boolean');

[true, false, 1].map(isBoolean); // [true, true, false]
```

## 时空

Val 空对象、数组或对象的功能版本

```js
var isEmpty = require('101/is-empty');

isEmpty([]); // true
isEmpty({}); // true
isEmpty(""); // true
isEmpty(" "); // false
```

## 函数

功能版本 `typeof val === 'function'`

```js
var isFunction = require('101/is-function');

[parseInt, function () {}, 'foo'].map(isFunction); // [true, true, false]
```

## 正整数

检查一个值是否是整数实例 .

```js
var isInteger = require('101/is-Integer');

isInteger(101); // true
isInteger(101.01); // false
```

## 是数

Val类型"数字"的功能版本.

```js
var isNumber = require('101/is-number');

['foo', NaN, 1].map(isNumber); // [false, false, true]
```

## 是对象

职能 _严格_ val 类型“ 对象” (而不是数组或正则表达式)

```js
var isObject = require('101/is-object');

[{}, { foo: 1 }, 100].map(isObject); // [true, true, false]
```

## 正则Exp

检查一个值是否为 RegExp 实例

```js
var isRegExp = require('101/is-regexp');

[new RegExp('.*'), /.*/, {}, 1].map(isRegExp); // [true, true, false, false]
```

## 正弦

Val 类型 “ string” 的功能版本

```js
var isString = require('101/is-string');

['foo', 'bar', 1].map(isString); // [true, true, false]
```

## 密钥 单位

返回包含对象全部密钥的数组. 和本地人不一样 `Object.keys` 还包括: `prototype` 键.

```js
var keysIn = require('101/keys-in');
var User = function() {
  this.msg = 'Hello World';
}
User.prototype.isLoggedIn = function() { /* example function */ }

var user = new User();
keysIn(user); // ['msg', 'isLoggedIn']
```

## 最后一个

返回列表的最后一个值

```js
var last = require('101/last');

last([1, 2, 3]); // 3
last('hello');   // 'o'
```

## 镜头

创建透镜访问数据结构. 当将属性密钥作为字符串传递时, 它返回函数 `fn(obj)` 这对这个有帮助 也揭露了 `.set(value, obj)` 财务报告和审定财务报表 `.mod(fn, obj)`。 。 。 .

```js
var fooLens = lens('foo');
var toUpper = function(str) { return str.toUpperCase(); };
var obj = {
  foo: 'foo',
  bar: 'bar'
};

fooLens(obj); // => 'foo'
fooLens.set('moo', obj); // => { foo: 'moo', bar: 'bar' }
fooLens.mod(toUpper, obj); // => { foo: 'MOO', bar: 'bar' }
```

您也可以提供获取和设置功能.

```js
var arr = ['foo', 'bar'];
var first = lens(
    function(arr) { return arr[0]; },
    function(val, arr) { var clone = arr.slice(); clone[0] = val; return clone; }
);

first(arr); // => 'foo'
first.set('moo')(arr); // => ['moo', 'bar']
first.mod(toUpper)(arr); // => ['FOO', 'bar']
```

## 无

无操作函数

```js
require('101/noop'); // function () {}
```

## 没有

功能版本 `!`。 。 。 .

```js
var not = require('101/not');

not(isString)('hey'); // false
not(isString)(100);   // true
```

## 删除

不可移动版本 `delete obj.key`。返回新对象时没有指定的密钥. 支持部分功能(大有数组函数,如映射).

```js
var omit = require('101/omit');
var obj = {
  foo: 1,
  bar: 2
};

omit(obj, 'foo');          // { bar: 1 }
omit(obj, ['foo']);        // { bar: 1 }
omit(obj, ['foo', 'bar']); // { }

// use it with array.map
[obj, obj, obj].map(omit('foo')); // [{ bar: 1 }, { bar: 1 }, { bar: 1 }];
```

## 或者说

功能版本 `||`。 。 。 . 不错 `array.reduce`。 。 。 .

```js
var or = require('101/or');

or(true, true);   // true
or(true, false);  // true
or(false, false); // false
or("foo", false); // "foo"
```

## 全部通过

跨越许多函数和 `&&`'是结果. 支持部分功能(大有数组函数,如映射).

```js
var passAll = require('101/pass-all');

['', 'foo', 'bar', 100].map(passAll(isString, isTruthy)); // [false, true, true, false]
```

## 任意通过

跨越许多函数和 `||`'是结果. 支持部分功能(大有数组函数,如映射).

```js
var passAny = require('101/pass-any');

['', 'foo', 'bar', 100].map(passAny(isString, isNumber)); // [true, true, true, true]
```

## 选择

返回带有指定密钥的新对象(从obj得到密钥值). 支持正则表达式和部分功能(大有数组函数,如映射).

```js
var pick = require('101/pick');
var obj = {
  foo: 1,
  bar: 2,
  qwk: {
    wrk: 1
  },
  'qwk.wrk': 2
};

pick(obj, 'foo');          // { foo: 1 }
pick(obj, RegExp('oo$'));  // { foo: 1 }
pick(obj, ['foo']);        // { foo: 1 }
pick(obj, ['foo', 'bar']); // { foo: 1, bar: 2 }

// use it with array.map
[obj, obj, obj].map(pick('foo')); // [{ foo: 1 }, { foo: 1 }, { foo: 1 }];

// supports keypaths
pick(obj, 'qwk.wrk');      // { qwk: { wrk: 1 } }
pick(obj, '["qwk.wrk"]');  // { 'qwk.wrk': 2 } }
```

## 抓起来

Obj\[key\]的功能版本,从obj返回密钥的值. 支持部分功能(大有数组函数,如映射).

```js
var pluck = require('101/pluck');
var obj = {
  foo: 1,
  bar: 2
};

pluck(obj, 'foo'); // 1

// use it with array.map
[obj, obj, obj].map(pluck('foo')); // [1, 1, 1]

// supports keypaths by default
var obj = {
  foo: {
    bar: 1
  },
  'foo.bar': 2
};

pluck(obj, 'foo.bar'); // 1, supports keypaths by default
pluck(obj, 'foo.bar', false); // 2, pass false to not use keypaths
```

## 设置

不可移动版本 `obj[key] = val`返回带有键上的值的 obj 克隆. 支持部分功能(大有数组函数,如映射).

```js
var put = require('101/put');
var obj = {
  foo: 1,
  bar: 2
};

put(obj, 'baz', 3); // { foo: 1, bar:2, baz: 3 }
obj; // { foo: 1, bar: 2 } (not modified)

// use it with array.map
[obj, obj, obj].map(put('foo', 100)); // [{ foo: 100, bar: 2 }, {copy}, {copy}]
obj; // { foo: 1, bar: 2 } (not modified)

// supports keypaths by default
var obj = {
  bar: 2
};

put(obj, 'foo.qux', 100); // { foo: { qux: 100 }, bar: 2 }
put(obj, {
  'foo.qux': 100
  'yolo': 1
}); // { foo: { qux: 100 }, bar: 2, yolo: 1 }
obj; // { foo: 1, bar: 2 } (not modified)
```

## 设定

Obj \[key\] = val的功能版本,与键和值集返回同为obj. 支持部分功能(大有数组函数,如映射).

```js
var set = require('101/set');
var obj = {
  foo: 1,
  bar: 2
};

set(obj, 'foo'); // 1

// use it with array.map
[obj, obj, obj].map(set('foo', 100)); // [{ foo: 100, bar: 2 }, {same}, {same}]

// supports keypaths by default
var obj = {
  bar: 2
};

set(obj, 'foo.qux', 100); // { foo: { qux: 100 }, bar: 2 }
set(obj, {
  'foo.qux': 100
  'yolo': 1
}); // { foo: { qux: 100 }, bar: 2, yolo: 1 }
```

## 数值

返回包含对象属性值的矩阵

```js
var values = require('101/values');
var obj {
  foo: 'apple',
  bar: 'orange'
};

var objValues = values(obj);
objValues // ['apple', 'orange']
```

## 十进制

独家或 不错 `array.reduce`。 。 。 .

```js
var xor = require('101/xor');

xor(true, true);   // false
xor(true, false);  // true
xor(false, true);  // true
xor(false, false); // false
```

## 许可证

麻省理工学院

## 常见问题

### 101 是什么？

假设 es5\+ 可选择性要求的普通javascript utils

### 如何安装 101？

在项目目录运行 npm install 101，或使用 pnpm add / yarn add / bun add。

### 101 支持 TypeScript 吗？

该包的 package\.json 没有声明类型入口。需要类型提示时，可以在 npm 上查找社区维护的 @types/101 是否存在。

### 101 支持 ESM 还是 CommonJS？

以 CommonJS 形式发布，可以直接 require\(\)；在 ES Module 项目中也可以用 import 引入（Node\.js 会把 module\.exports 作为默认导出）。

### 101 可以商用吗？

101 使用 MIT 许可。宽松许可：允许商业使用、修改和再分发，通常只需在分发时保留原版权与许可声明。以上为概括，不构成法律意见，请以许可原文为准。

### 101 的下载量有多少？

根据 npm 官方下载统计，101 在 2026/10/04 – 2026/11/02 这 30 天内被下载 144,885 次，日均约 4,830 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入，适合横向比较热度，不能直接等同于使用人数。

### 101 还在维护吗？

最新版本 1\.6\.3 发布于 2018/04/16（8 年前）；至今共发布 43 个版本，其中过去 12 个月发布了 0 个；首次发布于 2014/04/11。发布频率只是参考信号：功能稳定的工具可能很少需要更新，建议结合源码仓库的 issue 和提交记录判断。