101

中文文档

1.6.3发布于 2018/04/16MITCommonJS近 30 天下载 14.5万

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

文档目录49 节

1) 保留101,以尽量减少与香草联署材料的重叠.
2) 不需要建立习惯.
为何不将每个模块作为单个模块发布?
指定( aka 扩展)
财务报告和审定财务报表
应用
绑定
克隆
编曲
汇合
咖喱
默认
三角形
环境
等于
已存在
寻找
查找Index 数据
翻转
组字
有关键路径
有财产
包含
指数By
实例
是宝莲
时空
函数
正整数
是数
是对象
正则Exp
正弦
密钥单位
最后一个
镜头
无
没有
删除
或者说
全部通过
任意通过
选择
抓起来
设置
设定
数值
十进制
许可证

为什么要另建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。以任意数量的对象(返回正本)扩展对象.

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。。。 .

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

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

应用

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

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'

绑定

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

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"

克隆

这是克隆 (仅将这个 bc 出口到 101)

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

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

编曲

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

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

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

汇合

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

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)))

咖喱

返回曲折函数 .

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"

默认

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

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. 支持部分功能(大有数组函数,如映射).

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。。。 . 或多相环境.

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 支持部分功能( 与数组函数相通) .

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

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

已存在

简单存在函数 .

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

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

寻找

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

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

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 将返回一个接受列表作为第一个参数的部分函数 .

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

翻转

返回带有翻转参数的函数

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。。。 .

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) .

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 与 " 有问题 " 方法相似.

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 。包括现相.

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。。。 .

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实例功能版. 支持部分功能( 与数组函数相通) .

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

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

是宝莲

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

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

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

时空

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

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

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

函数

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

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

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

正整数

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

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

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

是数

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

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

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

是对象

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

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

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

正则Exp

检查一个值是否为 RegExp 实例

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

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

正弦

Val 类型 “ string” 的功能版本

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

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

密钥单位

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

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']

最后一个

返回列表的最后一个值

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

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

镜头

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

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' }

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

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']

无

无操作函数

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

没有

功能版本 !。。。 .

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

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

删除

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

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。。。 .

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

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

全部通过

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

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

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

任意通过

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

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

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

选择

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

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返回密钥的值. 支持部分功能(大有数组函数,如映射).

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 克隆. 支持部分功能(大有数组函数,如映射).

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. 支持部分功能(大有数组函数,如映射).

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 }

数值

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

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

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

十进制

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

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

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

许可证

麻省理工学院

版本与发布记录

101 共发布 43 个版本，首次发布于 2014/04/11；过去 12 个月发布了 0 个版本。

版本	发布日期	距今
`1.6.3`latest	2018/04/16	8 年前
`1.6.2`	2016/08/22	10 年前
`1.6.1`	2016/07/18	10 年前
`1.6.0`	2016/06/14	10 年前
`1.5.0`	2016/03/08	10 年前
`1.4.0`	2016/02/23	10 年前

关于 101 的常见问题

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 和提交记录判断。

101