类似 jQuery 的 dom 操作库。
namespace $ {
class $ extends Select {
find(selector: string): $;
each(fn: types.AnyFn): $;
offset(): $offset.IOffset;
hide(): $;
show(): $;
first(): $;
last(): $;
get(index: number): Element;
eq(index: number): $;
on(event: string, selector: string, handler: types.AnyFn): $;
on(event: string, handler: types.AnyFn): $;
off(event: string, selector: string, handler: types.AnyFn): $;
off(event: string, handler: types.AnyFn): $;
html(): string;
html(value: string): $;
text(): string;
text(value: string): $;
val(): string;
val(value: string): $;
css(name: string): string;
css(name: string, value: string): $;
css(properties: types.PlainObj<string | number>): $;
attr(name: string): string;
attr(name: string, value: string): $;
attr(attributes: types.PlainObj<string>): $;
data(name: string): string;
data(name: string, value: string): $;
data(attributes: types.PlainObj<string>): $;
rmAttr(name: string): $;
remove(): $;
addClass(name: string | string[]): $;
rmClass(name: string): $;
toggleClass(name: string): $;
hasClass(name: string): boolean;
parent(): $;
append(content: string | Element): $;
prepend(content: string | Element): $;
before(content: string | Element): $;
after(content: string | Element): $;
}
}
declare function $(selector: string | Element | Document): $.$;
offset, hide, show, first, last, get, eq, on, off, html, text, val, css, attr, data, rmAttr, remove, addClass, rmClass, toggleClass, hasClass, append, prepend, before, after
const $btn = $('#btn');
$btn.html('eustia');
$btn.addClass('btn');
$btn.show();
$btn.on('click', function() {
// Do something...
});
操作元素属性。
namespace $attr {
function remove(element: $safeEls.El, name: string): void;
}
function $attr(
element: $safeEls.El,
name: string,
value: string
): void;
function $attr(
element: $safeEls.El,
attributes: types.PlainObj<string>
): void;
function $attr(element: $safeEls.El, name: string): string;
获取元素集中第一个元素的指定属性值。
参数名 | 说明 |
---|---|
element | 目标元素集 |
name | 属性名 |
返回值 | 第一个元素的属性值 |
设置元素集中一个或多个属性的值。
参数名 | 说明 |
---|---|
element | 目标元素集 |
name | 属性名 |
val | 属性值 |
参数名 | 说明 |
---|---|
element | 目标元素集 |
attributes | 包含多个要设置属性-值对的对象 |
对元素集中的所有元素,移除指定的属性。
参数名 | 说明 |
---|---|
element | 目标元素集 |
name | 属性名 |
$attr('#test', 'attr1', 'test');
$attr('#test', 'attr1'); // -> test
$attr.remove('#test', 'attr1');
$attr('#test', {
attr1: 'test',
attr2: 'test'
});
操作元素 class。
const $class: {
add(element: $safeEls.El, name: string | string[]): void;
has(element: $safeEls.El, name: string): boolean;
toggle(element: $safeEls.El, name: string): void;
remove(element: $safeEls.El, name: string): void;
};
对元素集中的所有元素,添加指定的 class。
参数名 | 说明 |
---|---|
element | 目标元素集 |
names | 添加的 class |
判断元素集中是否有元素含有指定的 class。
参数名 | 说明 |
---|---|
element | 目标元素集 |
name | class 值 |
返回值 | 如果有,返回真 |
对于元素集中的每个元素,如果含有指定的 class 就将其删除,反之则添加。
参数名 | 说明 |
---|---|
element | 目标元素集 |
name | class 值 |
对于元素集中的所有元素,移除指定的 class。
参数名 | 说明 |
---|---|
element | 目标元素集 |
name | class 值 |
$class.add('#test', 'class1');
$class.add('#test', ['class1', 'class2']);
$class.has('#test', 'class1'); // -> true
$class.remove('#test', 'class1');
$class.has('#test', 'class1'); // -> false
$class.toggle('#test', 'class1');
$class.has('#test', 'class1'); // -> true
操作元素样式。
function $css(element: $safeEls.El, name: string): string;
function $css(
element: $safeEls.El,
name: string,
val: string
): void;
function $css(
element: $safeEls.El,
properties: types.PlainObj<string | number>
): void;
获取元素集中第一个元素的指定样式。
参数名 | 说明 |
---|---|
element | 目标元素集 |
name | 样式名 |
返回值 | 样式值 |
设置元素集中一个或多个样式的值。
参数名 | 说明 |
---|---|
element | 目标元素集 |
name | 样式名 |
val | 样式值 |
参数名 | 说明 |
---|---|
element | 目标元素集 |
properties | 包含多个要设置样式-值对的对象 |
$css('#test', {
color: '#fff',
background: 'black',
opacity: 0.5
});
$css('#test', 'display', 'block');
$css('#test', 'color'); // -> #fff
同 $attr,自动给属性名加 data- 前缀。
function $data(
element: $safeEls.El,
name: string,
value: string
): void;
function $data(
element: $safeEls.El,
attributes: types.PlainObj<string>
): void;
function $data(element: $safeEls.El, name: string): string;
$data('#test', 'attr1', 'eustia');
给指定 dom 元素绑定事件。
const $event: {
on(
element: $safeEls.El,
event: string,
selector: string,
handler: types.AnyFn
): void;
on(element: $safeEls.El, event: string, handler: types.AnyFn): void;
off(
element: $safeEls.El,
event: string,
selector: string,
handler: types.AnyFn
): void;
off(element: $safeEls.El, event: string, handler: types.AnyFn): void;
};
function clickHandler() {
// Do something...
}
$event.on('#test', 'click', clickHandler);
$event.off('#test', 'click', clickHandler);
插入 html 到不同位置。
namespace $insert {
type IInsert = (element: $safeEls.El, content: string | Element) => void;
}
const $insert: {
before: $insert.IInsert;
after: $insert.IInsert;
append: $insert.IInsert;
prepend: $insert.IInsert;
};
插入 html 到元素前。
插入 html 到元素后。
插入 html 到元素内部前。
插入 html 到元素内部后。
参数名 | 说明 |
---|---|
element | 目标元素集 |
content | html 字符串或元素 |
// <div id="test"><div class="mark"></div></div>
$insert.before('#test', '<div>licia</div>');
// -> <div>licia</div><div id="test"><div class="mark"></div></div>
$insert.after('#test', '<div>licia</div>');
// -> <div id="test"><div class="mark"></div></div><div>licia</div>
$insert.prepend('#test', '<div>licia</div>');
// -> <div id="test"><div>licia</div><div class="mark"></div></div>
$insert.append('#test', '<div>licia</div>');
// -> <div id="test"><div class="mark"></div><div>licia</div></div>
获取元素在文档中的位置。
namespace $offset {
interface IOffset {
left: number;
top: number;
width: number;
height: number;
}
}
function $offset(element: $safeEls.El): $offset.IOffset;
参数名 | 说明 |
---|---|
element | 目标元素集 |
返回值 | 元素位置 |
$offset('#test'); // -> {left: 0, top: 0, width: 0, height: 0}
设置或获取元素的 html, text,val 等值。
namespace $property {
interface IProperty {
(element: $safeEls.El, value: string): void;
(element: $safeEls.El): string;
}
}
const $property: {
html: $property.IProperty;
val: $property.IProperty;
text: $property.IProperty;
};
设置或获取元素的 html 值。
设置或获取元素的 text 值。
设置或获取元素的 val 值。
$property.html('#test', 'licia');
$property.html('#test'); // -> licia
移除指定元素集。
function $remove(element: $safeEls.El);
参数名 | 说明 |
---|---|
element | 目标元素集 |
$remove('#test');
将值转换为数组,如果值为字符串,使用 querySelector 获取元素集。
namespace $safeEls {
type El = Element | Element[] | NodeListOf<Element> | string;
}
function $safeEls(val: $safeEls.El): Element[];
参数名 | 说明 |
---|---|
val | 要转换的值 |
返回值 | 元素集 |
$safeEls(document.querySelector('.test'));
$safeEls(document.querySelectorAll('.test'));
$safeEls('.test'); // -> Array of elements with test class
显示元素。
function $show(element: $safeEls.El): void;
参数名 | 说明 |
---|---|
element | 目标元素集 |
$show('#test');
JavaScript 基准测试。
namespace Benchmark {
interface IOptions {
minTime?: number;
maxTime?: number;
minSamples?: number;
delay?: number;
name?: string;
}
interface IResult {
name: string;
mean: number;
variance: number;
deviation: number;
sem: number;
moe: number;
rme: number;
hz: number;
sample: number[];
}
}
class Benchmark {
constructor(fn: types.AnyFn, options?: Benchmark.IOptions);
run(): Promise<Benchmark.IResult>;
static all(
benches: Array<types.AnyFn | Benchmark>,
options?: Benchmark.IOptions
): Promise<Benchmark.IResult[]>;
}
参数名 | 说明 |
---|---|
fn | 要测试的代码 |
options | 测试选项 |
可用选项:
参数名 | 说明 |
---|---|
minTime=50 | 用于减少误差的时间 |
maxTime=5000 | 测试运行最大时间 |
minSamples=5 | 最小样本数量 |
delay=5 | 测试周期间隔 |
name | 测试名称 |
运行基准测试,返回 promise。
[static] 运行多个基准测试。
const benchmark = new Benchmark(
function test() {
!!'Hello World!'.match(/o/);
},
{
maxTime: 1500
}
);
benchmark.run().then(result => {
console.log(String(result));
});
Benchmark.all([
function regExp() {
/o/.test('Hello World!');
},
function indexOf() {
'Hello World!'.indexOf('o') > -1;
},
function match() {
!!'Hello World!'.match(/o/);
}
]).then(results => {
console.log(String(results));
});
如果支持 Blob,直接返回 Blob,否则使用 BlobBuilder 进行兼容。
参数名 | 说明 |
---|---|
parts | Blob 分片 |
options | 选项 |
const blob = new Blob([]);
布隆过滤器实现。
class BloomFilter {
constructor(size?: number, k?: number);
add(val: string): void;
test(val: string): boolean;
}
参数名 | 说明 |
---|---|
size=1024 | 桶数目 |
k=3 | 哈希函数数目 |
添加元素。
参数名 | 说明 |
---|---|
val | 要加的值 |
检测元素是否在过滤器中。
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果可能在返回真,如果绝对不在返回假 |
const bloom = new BloomFilter(256, 3);
bloom.add('Bruce Wayne');
bloom.add('Clark Kent');
bloom.test('Clark Kent'); // -> true
bloom.test('Bruce Wayne'); // -> true
bloom.test('Tony Stark'); // -> false
修改对象的属性值时,无需关心键值的大小写情况。
class Caseless {
constructor(obj: any);
getKey(key: string): string | void;
set(key: string, val: any): void;
get(key: string): any;
remove(key: string): void;
has(key: string): boolean;
}
参数名 | 说明 |
---|---|
obj | 目标对象 |
获取原始键值。
参数名 | 说明 |
---|---|
key | 不区分大小写的键名 |
返回值 | 原始键值 |
设置值。
参数名 | 说明 |
---|---|
key | 不区分大小写的键名 |
val | 要设置的值 |
获取值。
参数名 | 说明 |
---|---|
key | 不区分大小写的键名 |
返回值 | 键值 |
移除值。
参数名 | 说明 |
---|---|
key | 不区分大小写的键名 |
判断是否存在给定的键名。
参数名 | 说明 |
---|---|
key | 不区分大小写的键名 |
返回值 | 如果有,返回真 |
const headers = { 'Content-Type': 'text/javascript' };
const c = new Caseless(headers);
c.set('content-type', 'text/css');
console.log(headers); // -> { 'Content-Type': 'text/css' }
c.getKey('content-type'); // -> 'Content-Type'
c.remove('content-type');
c.has('content-type'); // -> false
可以相互连接的消息通道。
class Channel extends Emitter {
send(msg: any): void;
connect(channel: Channel): void;
disconnect(channel: Channel): void;
isConnected(channel: Channel): boolean;
destroy(): void;
}
发送消息给所有连接的通道。
参数名 | 说明 |
---|---|
msg | 要发送的消息 |
连接到指定通道。
参数名 | 说明 |
---|---|
channel | 要连接的通道 |
断开与指定通道的连接。
参数名 | 说明 |
---|---|
channel | 要断开的通道 |
检查两个通道是否连接。
参数名 | 说明 |
---|---|
channel | 目标通道 |
返回值 | 是否连接 |
销毁通道,断开所有连接的通道。
const channelA = new Channel();
const channelB = new Channel();
channelA.connect(channelB);
channelB.on('message', msg => {
console.log(msg); // -> 'hello'
});
channelA.send('hello');
channelA.on('message', msg => {
console.log(msg); // -> 'world'
});
channelB.send('world');
channelA.isConnected(channelB); // -> true
channelB.isConnected(channelA); // -> true
创建 JavaScript 类。
namespace Class {
class Base {
toString(): string;
}
class IConstructor extends Base {
constructor(...args: any[]);
static extend(methods: any, statics: any): IConstructor;
static inherits(Class: types.AnyFn): void;
static methods(methods: any): IConstructor;
static statics(statics: any): IConstructor;
[method: string]: any;
}
}
function Class(methods: any, statics?: any): Class.IConstructor;
参数名 | 说明 |
---|---|
methods | 公有方法 |
statics | 静态方法 |
返回值 | 用于创建实例的函数 |
const People = Class({
initialize: function People(name, age) {
this.name = name;
this.age = age;
},
introduce: function() {
return 'I am ' + this.name + ', ' + this.age + ' years old.';
}
});
const Student = People.extend(
{
initialize: function Student(name, age, school) {
this.callSuper(People, 'initialize', arguments);
this.school = school;
},
introduce: function() {
return (
this.callSuper(People, 'introduce') +
'\n I study at ' +
this.school +
'.'
);
}
},
{
is: function(obj) {
return obj instanceof Student;
}
}
);
const a = new Student('allen', 17, 'Hogwarts');
a.introduce(); // -> 'I am allen, 17 years old. \n I study at Hogwarts.'
Student.is(a); // -> true
颜色转换。
namespace Color {
interface IColor {
val: number[];
model: string;
}
}
class Color {
constructor(color: string | Color.IColor);
toRgb(): string;
toHex(): string;
toHsl(): string;
static parse(colorStr: string): Color.IColor;
}
参数名 | 说明 |
---|---|
color | 要转换的颜色 |
获取颜色 rgb 格式。
获取颜色十六进制格式。
获取颜色 hsl 格式。
【静态】将颜色字符串转换为含有值及颜色模型的对象。
参数名 | 说明 |
---|---|
color | 颜色字符串 |
返回值 | 含有值及颜色模型的对象 |
Color.parse('rgb(170, 287, 204, 0.5)'); // -> {val: [170, 187, 204, 0.5], model: 'rgb'}
const color = new Color('#abc');
color.toRgb(); // -> 'rgb(170, 187, 204)'
color.toHsl(); // -> 'hsl(210, 25%, 73%)'
对象委托。
class Delegator {
constructor(host: object, target: object | string);
method(name: string, target?: string): Delegator;
getter(name: string, target?: string): Delegator;
setter(name: string, target?: string): Delegator;
access(name: string, target?: string): Delegator;
}
参数名 | 说明 |
---|---|
host | 宿主对象 |
target | 委托目标 |
允许在宿主对象上访问目标方法。
参数名 | 说明 |
---|---|
name | 宿主方法名 |
target=name | 目标方法名 |
创建 getter。
创建 setter。
创建 accessor,效果等于同时调用 setter 和 getter。
const host = {
target: {
a() {
return 'a';
},
b: 'b',
c: 'c',
d: 'd',
e() {
return 'e';
}
}
};
const delegator = new Delegator(host, 'target');
delegator
.method('a')
.getter('b')
.setter('c')
.access('d');
host.a(); // -> 'a'
host.b; // -> 'b'
host.c = 5;
host.target.c; // -> 5
host.d; // -> 'd'
host.d = 5;
host.d; // -> 5
Flux 调度器。
class Dispatcher {
dispatch(payload: any);
register(cb: types.AnyFn): void;
waitFor(ids: string[]): void;
unregister(id: string): void;
isDispatching(): boolean;
}
const dispatcher = new Dispatcher();
dispatcher.register(function(payload) {
switch (
payload.actionType
// Do something
) {
}
});
dispatcher.dispatch({
actionType: 'action'
});
提供观察者模式的 Event emitter 类。
class Emitter {
on(event: string, listener: types.AnyFn): Emitter;
off(event: string, listener: types.AnyFn): Emitter;
once(event: string, listener: types.AnyFn): Emitter;
emit(event: string, ...args: any[]): Emitter;
removeAllListeners(event?: string): Emitter;
static mixin(obj: any): any;
}
绑定事件。
解绑事件。
绑定只触发一次的事件。
参数名 | 说明 |
---|---|
event | 事件名称 |
listener | 事件监听器 |
触发事件。
参数名 | 说明 |
---|---|
event | 事件名称 |
...args | 传递给监听器的参数 |
解绑所有事件。
参数名 | 说明 |
---|---|
event | 事件名称 |
【静态】 将 Emitter 类的方法绑定到指定对象上去。
参数名 | 说明 |
---|---|
obj | 目标对象 |
const event = new Emitter();
event.on('test', function(name) {
console.log(name);
});
event.emit('test', 'licia'); // Logs out 'licia'.
Emitter.mixin({});
Enum 类实现。
class Enum {
size: number;
constructor(map: string[] | { [member: string]: any });
[key: string]: any;
}
参数名 | 说明 |
---|---|
arr | 字符串数组 |
参数名 | 说明 |
---|---|
obj | 键值对 |
const importance = new Enum([
'NONE',
'TRIVIAL',
'REGULAR',
'IMPORTANT',
'CRITICAL'
]);
const val = 1;
if (val === importance.CRITICAL) {
// Do something.
}
二进制文件存储。
class FileBlobStore extends Emitter {
constructor(path: string, data?: types.PlainObj<Buffer>);
set(key: string, buf: Buffer): void;
set(values: types.PlainObj<Buffer>): void;
get(key: string): Buffer | void;
get(keys: string[]): types.PlainObj<Buffer>;
remove(key: string): void;
remove(keys: string[]): void;
clear(): void;
each(fn: (val: Buffer, key: string) => void): void;
save(): void;
}
API 基本与 Store 模块一致,主要不同点是只接收 Buffer 类型。
保存内容到磁盘。
const store = new FileBlobStore('path/to/file');
store.set('name', Buffer.from('licia'));
process.on('exit', () => store.save());
class FileStore extends Store {
constructor(path: string, data?: any);
}
参数名 | 说明 |
---|---|
path | 存储文件路径 |
data | 默认数据 |
const store = new FileStore('path/to/file');
store.set('name', 'licia');
哈希表实现。
class HashTable {
constructor(size?: number);
set(key: string, val: any): void;
get(key: string): any;
has(key: string): boolean;
delete(key: string): void;
}
参数名 | 说明 |
---|---|
size=32 | 桶数目 |
设置值。
参数名 | 说明 |
---|---|
key | 键名 |
val | 键值 |
获取值。
参数名 | 说明 |
---|---|
key | 键名 |
返回值 | 键值 |
检查是否有指定值。
参数名 | 说明 |
---|---|
key | 键名 |
返回值 | 如果值存在,返回真 |
删除值。
const hashTable = new HashTable(128);
hashTable.set('name', 'redhoodsu');
hashTable.get('name'); // -> 'redhoodsu'
hashTable.has('name'); // -> true
hashTable.delete('name');
hashTable.has('name'); // -> false
堆实现。
class Heap {
size: number;
constructor(cmp?: types.AnyFn);
clear(): void;
add(item: any): number;
poll(): any;
peek(): any;
}
堆大小。
参数名 | 说明 |
---|---|
cmp | 比较器 |
清空堆数据。
往堆里添加元素。
参数名 | 说明 |
---|---|
item | 入堆元素 |
返回值 | 当前大小 |
获取并删除堆的根元素。
与 poll 一样,只是不删除。
const heap = new Heap(function(a, b) {
return b - a;
});
heap.add(2);
heap.add(1);
heap.add(4);
heap.add(5);
heap.poll(); // -> 5
console.log(heap.size); // -> 4
V8 内存快照操作库。
class HeapSnapshot {
nodes: LinkedList;
edges: LinkedList;
constructor(profile: any);
}
参数名 | 说明 |
---|---|
profile | 要解析的内存快照 |
解析后的节点信息。
解析后的边信息。
const fs = require('fs');
const data = fs.readFileSync('path/to/heapsnapshot', 'utf8');
const heapSnapshot = new HeapSnapshot(data);
let totalSize = 0;
heapSnapshot.nodes.forEach(node => (totalSize += node.selfSize));
console.log(totalSize);
简单国际化库。
class I18n {
constructor(locale: string, langs: types.PlainObj<any>);
set(locale: string, lang: types.PlainObj<any>): void;
t(path: string | string[], data?: types.PlainObj<any>): string;
locale(locale: string): void;
}
参数名 | 说明 |
---|---|
locale | 地区代码 |
langs | 语言数据 |
添加语言或者向已有的语言新增键值。
参数名 | 说明 |
---|---|
locale | 地区代码 |
lang | 语言数据 |
设置当前地区。
参数名 | 说明 |
---|---|
locale | 地区代码 |
获取翻译文本。
参数名 | 说明 |
---|---|
path | 要获取文本的键值 |
data | 要传递的数据 |
返回值 | 翻译文本 |
const i18n = new I18n('en', {
en: {
welcome: 'Hello, {{name}}!',
curTime(data) {
return 'Current time is ' + data.time;
}
},
cn: {
welcome: '你好,{{name}}!'
}
});
i18n.set('cn', {
curTime(data) {
return '当前时间是 ' + data.time;
}
});
i18n.t('welcome', { name: 'licia' }); // -> 'Hello, licia!'
i18n.locale('cn');
i18n.t('curTime', { time: '5:47 pm' }); // -> '当前时间是 5:47 pm'
JSON 转换器。
class JsonTransformer {
constructor(data: any);
set(key: string, val: any): JsonTransformer;
get(key?: string): any;
map(from: string, to: string, fn: types.AnyFn): JsonTransformer;
map(from: string, fn: types.AnyFn): JsonTransformer;
filter(from: string, to: string, fn: types.AnyFn): JsonTransformer;
filter(from: string, fn: types.AnyFn): JsonTransformer;
remove(keys: string | string[]): JsonTransformer;
compute(
from: string | string[],
to: string,
fn: types.AnyFn
): JsonTransformer;
compute(from: string, fn: types.AnyFn): JsonTransformer;
toString(): string;
}
参数名 | 说明 |
---|---|
data={} | 目标 JSON 对象 |
设置属性值。
参数名 | 说明 |
---|---|
key | 属性路径 |
val | 值 |
如果属性路径为空,整个对象将被值替换。
获取属性值。
参数名 | 说明 |
---|---|
key | 属性路径 |
返回值 | 指定值或整个对象 |
移除属性值。
参数名 | 说明 |
---|---|
key | 属性路径 |
数组 map 的快捷方式。
参数名 | 说明 |
---|---|
from | 源对象路径 |
to | 目标对象路径 |
fn | 真值检测函数 |
数组 filter 的快捷方式。
从多个属性值计算新值。
参数名 | 说明 |
---|---|
from | 源属性路径 |
to | 目标属性路径 |
fn | 计算函数 |
const data = new JsonTransformer({
books: [
{
title: 'Book 1',
price: 5
},
{
title: 'Book 2',
price: 10
}
],
author: {
lastname: 'Su',
firstname: 'RedHood'
}
});
data.filter('books', function(book) {
return book.price > 5;
});
data.compute('author', function(author) {
return author.firstname + author.lastname;
});
data.set('count', data.get('books').length);
data.get(); // -> {books: [{title: 'Book 2', price: 10}], author: 'RedHoodSu', count: 1}
双向链表实现。
namespace LinkedList {
class Node {
value: any;
prev: Node | null;
next: Node | null;
}
}
class LinkedList {
size: number;
head: LinkedList.Node;
tail: LinkedList.Node;
push(val: any): number;
pop(): any;
unshift(val: any): number;
shift(): any;
find(fn: types.AnyFn): LinkedList.Node | void;
delNode(node: LinkedList.Node): void;
forEach(iterator: types.AnyFn, ctx?: any);
toArr(): any[];
}
链表大小。
链表首结点。
链表尾结点。
向链表尾部添加值。
参数名 | 说明 |
---|---|
val | 要添加的值 |
返回值 | 链表大小 |
获取链表尾部值。
向链表头部添加值。
获取链表头部值。
删除节点。
查找节点。
参数名 | 说明 |
---|---|
fn | 真值检测函数 |
返回值 | 第一个通过的节点 |
遍历链表。
将链表转换成 JavaScript 数组。
const linkedList = new LinkedList();
linkedList.push(5);
linkedList.pop(); // -> 5
LocalStorage 存储。
class LocalStore extends Store {
constructor(name: string, data?: {});
}
继承自 Store 类。
参数名 | 说明 |
---|---|
name | LocalStorage 存储名 |
data | 默认数据 |
const store = new LocalStore('licia');
store.set('name', 'licia');
带日志级别的简单日志库。
class Logger extends Emitter {
name: string;
formatter(type: string, argList: any[]): any[];
constructor(name: string, level?: string | number);
setLevel(level: string | number): Logger;
getLevel(): number;
trace(...args: any[]): Logger;
debug(...args: any[]): Logger;
info(...args: any[]): Logger;
warn(...args: any[]): Logger;
error(...args: any[]): Logger;
static level: Enum;
}
参数名 | 说明 |
---|---|
name | 日志名称 |
level=DEBUG | 日志级别 |
设置日志级别。
参数名 | 说明 |
---|---|
level | 日志级别 |
获取当前日志级别。
打日志方法。
TRACE,DEBUG,INFO,WARN,ERROR 和 SILENT。
const logger = new Logger('licia', Logger.level.ERROR);
logger.trace('test');
// Format output.
logger.formatter = function(type, argList) {
argList.push(new Date().getTime());
return argList;
};
logger.on('all', function(type, argList) {
// It's not affected by log level.
});
logger.on('debug', function(argList) {
// Affected by log level.
});
简单 LRU 缓存。
class Lru {
constructor(max: number);
has(key: string): boolean;
remove(key: string): void;
get(key: string): any;
set(key: string, val: any): void;
clear(): void;
}
参数名 | 说明 |
---|---|
max | 最大缓存数 |
检查是否有缓存。
参数名 | 说明 |
---|---|
key | 缓存键名 |
返回值 | 如果有,返回真 |
删除缓存。
参数名 | 说明 |
---|---|
key | 缓存键名 |
获取缓存。
参数名 | 说明 |
---|---|
key | 缓存键名 |
返回值 | 缓存值 |
设置缓存。
参数名 | 说明 |
---|---|
key | 缓存键名 |
val | 缓存值 |
清除所有缓存。
const cache = new Lru(50);
cache.set('test', 'licia');
cache.get('test'); // -> 'licia'
CSS 媒体查询监听器。
class MediaQuery extends Emitter {
constructor(query: string);
setQuery(query: string): void;
isMatch(): boolean;
}
继承自 Emitter 类。
参数名 | 说明 |
---|---|
query | 媒体查询字符串 |
更新查询字符串。
如果媒体查询匹配,返回真。
当媒体查询匹配时触发。
与 match 事件相反。
const mediaQuery = new MediaQuery('screen and (max-width:1000px)');
mediaQuery.isMatch(); // -> false
mediaQuery.on('match', () => {
// Do something...
});
MutationObserver 安全版本,如果不支持,则什么也不做。
const observer = new MutationObserver(function(mutations) {
// Do something.
});
observer.observe(document.documentElement);
observer.disconnect();
优先队列实现。
class PriorityQueue {
size: number;
constructor(cmp?: types.AnyFn);
clear(): void;
enqueue(item: any): number;
dequeue(): any;
peek(): any;
}
队列大小。
参数名 | 说明 |
---|---|
cmp | 比较器 |
清空队列。
元素入列。
参数名 | 说明 |
---|---|
item | 入列元素 |
返回值 | 当前大小 |
获取并删除队列中拥有最高优先级的元素。
同 dequeue,只是不删除。
const queue = new PriorityQueue(function(a, b) {
if (a.priority > b.priority) return 1;
if (a.priority === b.priority) return -1;
return 0;
});
queue.enqueue({
priority: 1000,
value: 'apple'
});
queue.enqueue({
priority: 500,
value: 'orange'
});
queue.dequeue(); // -> { priority: 1000, value: 'apple' }
轻量 Promise 实现。
function get(url) {
return new Promise(function(resolve, reject) {
const req = new XMLHttpRequest();
req.open('GET', url);
req.onload = function() {
req.status == 200
? resolve(req.response)
: reject(Error(req.statusText));
};
req.onerror = function() {
reject(Error('Network Error'));
};
req.send();
});
}
get('test.json').then(function(result) {
// Do something...
});
类似 es6 的 Map,不支持遍历器。
const PseudoMap: typeof Map;
只支持字符串键名,当 Map 存在时会直接使用 Map。
const map = new PseudoMap();
map.set('1', 1);
map.get('1'); // -> 1
队列数据结构。
class Queue {
size: number;
clear(): void;
enqueue(item: any): number;
dequeue(): any;
peek(): any;
forEach(iterator: types.AnyFn, context?: any): void;
toArr(): any[];
}
队列大小。
清空队列。
元素入列。
参数名 | 说明 |
---|---|
item | 入列元素 |
返回值 | 当前大小 |
元素出列。
获取第一个元素但不移除它。
遍历队列。
参数名 | 说明 |
---|---|
iterator | 调用函数 |
ctx | * |
将队列转换为 JavaScript 数组。
const queue = new Queue();
console.log(queue.size); // -> 0
queue.enqueue(2);
queue.enqueue(3);
queue.dequeue(); // -> 2
console.log(queue.size); // -> 1
queue.peek(); // -> 3
console.log(queue.size); // -> 1
不使用链表的 LRU 实现。
class QuickLru {
constructor(max: number);
has(key: string): boolean;
remove(key: string): void;
get(key: string): any;
set(key: string, val: any): void;
clear(): void;
}
参考 hashlru 算法,空间占用相比使用链表更多。
API 与 Lru 模块保持一致。
const cache = new QuickLru(50);
cache.set('test', 'licia');
cache.get('test'); // -> 'licia'
任务就绪回调管理。
class Readiness {
signal(tasks: string | string[]): void;
isReady(tasks: string | string[]): boolean;
ready(tasks: string | string[], fn?: types.AnyFn): Promise<void>;
}
设置任务为就绪状态。
参数名 | 说明 |
---|---|
tasks | 就绪任务 |
注册任务就绪回调。
参数名 | 说明 |
---|---|
tasks | 要监听的任务 |
fn | 任务就绪时触发的回调函数 |
返回值 | 任务就绪时 resolve 的 Promise |
检查任务是否准备就绪。
参数名 | 说明 |
---|---|
tasks | 要检查的任务 |
返回值 | 任务准备就绪,返回真 |
const readiness = new Readiness();
readiness.ready('serverCreated', function() {
// Do something.
});
readiness.signal('serverCreated');
readiness.isReady('serverCreated'); // -> true
简单类 redux 状态管理。
class ReduceStore {
constructor(reducer: types.AnyFn, initialState: any);
subscribe(listener: types.AnyFn): types.AnyFn;
dispatch(action: any): any;
getState(): any;
}
参数名 | 说明 |
---|---|
reducer | 生成下一个状态的函数 |
initialState | 初始状态 |
订阅状态改变事件。
参数名 | 说明 |
---|---|
listener | 回调函数 |
返回值 | 取消订阅函数 |
发出动作。
参数名 | 说明 |
---|---|
action | 描述改变内容的对象 |
返回值 | 传入对象 |
获取当前状态。
const store = new ReduceStore(function(state, action) {
switch (action.type) {
case 'INCREMENT':
return state + 1;
case 'DECREMENT':
return state - 1;
default:
return state;
}
}, 0);
store.subscribe(function() {
console.log(store.getState());
});
store.dispatch({ type: 'INCREMENT' }); // 1
store.dispatch({ type: 'INCREMENT' }); // 2
store.dispatch({ type: 'DECREMENT' }); // 1
检查元素的大小是否发生变化。
class ResizeSensor extends SingleEmitter {
constructor(el: HTMLElement);
destroy(): void;
}
参数名 | 说明 |
---|---|
element | 要监听大小的元素 |
停止监听大小变化事件。
const target = document.getElementById('test');
const sensor = new ResizeSensor(target);
sensor.addListener(function() {
// Trigger if element's size changed.
});
querySelectorAll 的简单包装类。
class Select {
constructor(selector: string | Element | Document);
find(selector: string): Select;
each(fn: types.AnyFn): Select;
}
参数名 | 说明 |
---|---|
selector | 选择器 |
查找子元素。
参数名 | 说明 |
---|---|
selector | 选择器 |
遍历匹配的元素。
参数名 | 说明 |
---|---|
fn | 调用函数 |
const $test = new Select('#test');
$test.find('.test').each(function(idx, element) {
// Manipulate dom nodes
});
限制资源同时访问次数。
class Semaphore {
constructor(counter?: number);
wait(fn: () => void): void;
signal(): void;
}
参数名 | 说明 |
---|---|
counter=1 | 初始计数 |
等待计数器大于 0 时,执行函数。
参数名 | 说明 |
---|---|
fn | 要执行的函数 |
执行队列中未执行任务。
const sem = new Semaphore(10);
require('http')
.createServer((req, res) => {
sem.wait(function() {
res.end('.');
setTimeout(() => sem.signal(), 500);
});
})
.listen(3000);
SessionStorage 存储。
class SessionStore extends Store {
constructor(name: string, data?: any);
}
继承自 Store 类。
参数名 | 说明 |
---|---|
name | SessionStorage 存储名 |
data | 默认数据 |
const store = new SessionStore('licia');
store.set('name', 'licia');
与 Event emitter 类似,但仅有一种事件类型。
class SingleEmitter {
addListener(listener: types.AnyFn): void;
rmListener(listener: types.AnyFn): void;
emit(...args: any[]): void;
rmAllListeners(): void;
static mixin(obj: any): void;
}
添加监听器。
移除监听器。
参数名 | 说明 |
---|---|
listener | 事件监听器 |
移除所有监听器。
触发监听器。
参数名 | 说明 |
---|---|
...args | 传递给监听器的参数 |
【静态】将 SingleEmitter 类的方法绑定到指定对象上去。
参数名 | 说明 |
---|---|
obj | 目标对象 |
const event = new SingleEmitter();
event.addListener(function(name) {
console.log(name);
});
event.emit('licia'); // Logs out 'licia'.
WebSocket 类的简单包装。
class Socket extends Emitter {
constructor(
url: string,
options?: {
protocols?: string | string[];
reconnect?: boolean;
}
);
send(message: any): void;
close(code?: number, reason?: string): void;
connect(): void;
}
继续自 Emitter 类。
参数名 | 说明 |
---|---|
url | WebSocket 地址 |
options | 连接选项 |
可用选项:
参数名 | 说明 |
---|---|
protocols | 协议 |
reconnect=true | 是否尝试重新连接 |
发送数据。
参数名 | 说明 |
---|---|
message | 要发送的数据 |
关闭 WebSocket 连接。
参数名 | 说明 |
---|---|
code | 状态码 |
reason | 关闭原因 |
连接 WebSocket,初始化时就会被调用。
const ws = new Socket('ws://localhost:8001');
ws.on('open', e => ws.send('Hello'));
栈数据结构。
class Stack {
size: number;
clear(): void;
push(item: any): number;
pop(): any;
peek(): any;
forEach(iterator: types.AnyFn, context?: any): void;
toArr(): any[];
}
栈大小。
清空栈。
元素入栈。
参数名 | 说明 |
---|---|
item | 入栈元素 |
返回值 | 当前大小 |
元素出栈。
获取最后一个元素但不移除它。
遍历栈。
参数名 | 说明 |
---|---|
iterator | 调用函数 |
ctx | 函数上下文 |
将栈转换为 JavaScript 数组。
const stack = new Stack();
stack.push(2); // -> 1
stack.push(3); // -> 2
stack.pop(); // -> 3
简单状态机。
class State extends Emitter {
constructor(initial: string, events: any);
is(state: string): boolean;
[event: string]: any;
}
继承自 Emitter 类。
参数名 | 说明 |
---|---|
initial | 初始状态 |
events | 改变状态的事件 |
检查当前状态是否是指定状态。
参数名 | 说明 |
---|---|
state | 要检查的状态 |
返回值 | 如果是,返回真 |
const state = new State('empty', {
load: { from: 'empty', to: 'pause' },
play: { from: 'pause', to: 'play' },
pause: { from: ['play', 'empty'], to: 'pause' },
unload: { from: ['play', 'pause'], to: 'empty' }
});
state.is('empty'); // -> true
state.load();
state.is('pause'); // -> true
state.on('play', function(src) {
console.log(src); // -> 'eustia'
});
state.on('error', function(err, event) {
// Error handler
});
state.play('eustia');
内存存储。
class Store extends Emitter {
constructor(data?: {});
set(key: string, val: any): void;
set(values: {}): void;
get(key: string): any;
get(keys: string[]): {};
remove(key: string): void;
remove(keys: string[]): void;
clear(): void;
each(fn: (...args: any[]) => void): void;
}
继承自 Emitter 类。
参数名 | 说明 |
---|---|
data | 初始数据 |
设置值。
参数名 | 说明 |
---|---|
key | 键名 |
val | 键值 |
设置多个值。
参数名 | 说明 |
---|---|
values | 包含多个键值对的对象 |
该方法被调用时发触发 change 事件。
获取值。
参数名 | 说明 |
---|---|
key | 键名 |
返回值 | 键值 |
获取多个值。
参数名 | 说明 |
---|---|
keys | 键名列表 |
返回值 | 包含多个键值对的对象 |
移除值。
参数名 | 说明 |
---|---|
key | 键名 |
清空数据。
遍历数据。
参数名 | 说明 |
---|---|
fn | 遍历函数 |
const store = new Store('test');
store.set('user', { name: 'licia' });
store.get('user').name; // -> 'licia'
store.clear();
store.each(function(val, key) {
// Do something.
});
store.on('change', function(key, newVal, oldVal) {
// It triggers whenever set is called.
});
解析、处理和生成 Chrome Trace 格式数据。
namespace Trace {
interface IEvent {
name: string;
cat: string;
ph: string;
ts: number;
pid: number;
tid: number;
args: any;
[key: string]: any;
}
class Process {
constructor(id);
id(): string;
name(): string;
addEvent(IEvent): void;
rmEvent(IEvent): void;
getThread(id: number): Thread;
rmThread(id: number): void;
threads(): Thread[];
toJSON(): IEvent[];
}
class Thread {
constructor(id, pid);
id(): string;
name(): string;
addEvent(IEvent): void;
rmEvent(IEvent): void;
events(): IEvent[];
toJSON(): IEvent[];
}
}
class Trace {
constructor(events: Trace.IEvent[]);
addEvent(event: Trace.IEvent);
rmEvent(event: Trace.IEvent);
getProcess(id: number): Trace.Process;
rmProcess(id: number): void;
processes(): Trace.Process[];
toJSON(): Trace.IEvent[];
}
const fs = require('fs');
const data = fs.readFileSync('path/to/trace', 'utf8');
const trace = new Trace(JSON.parse(data));
trace.rmProcess(627);
fs.writeFileSync(
'path/to/trace',
JSON.stringify(trace.toJSON()),
'utf8',
function() {}
);
创建 chrome trace 格式数据。
class Tracing {
constructor(options?: {
pid?: number;
tid?: number;
processName?: string;
threadName?: string;
});
start(cat?: string): void;
stop(): Trace.IEvent[];
metadata(name: string, args: any): void;
begin(cat: string, name: string, args?: any): void;
end(args?: any): void;
asyncBegin(cat: string, name: string, id?: string, args?: any): string;
asyncEnd(id: string, args?: any): void;
instant(
cat: string,
name: string,
scope?: 'g' | 'p' | 't',
args?: any
): void;
id(): string;
}
参数名 | 说明 |
---|---|
options | 录制选项 |
可用选项:
参数名 | 说明 |
---|---|
pid | 进程 id |
tid | 线程 id |
processName | 进程名称 |
threadName | 线程名称 |
开始录制。
参数名 | 说明 |
---|---|
cat | 开启类别 |
停止录制并获取事件列表。
记录开始事件。
参数名 | 说明 |
---|---|
cat | 事件类别 |
name | 事件名称 |
args | 参数 |
记录结束事件。
记录异步开始事件。
记录异步结束事件。
记录 instant 事件。
获取一个唯一 id。
const fs = require('fs');
const tracing = new Tracing();
tracing.start();
tracing.begin('cat', 'name');
// Do something...
tracing.end();
fs.writeFileSync(
'path/to/trace',
JSON.stringify(tracing.stop()),
'utf8',
function() {}
);
字典树数据结构。
class Trie {
add(word: string): void;
remove(word: string): void;
has(word: string): boolean;
words(prefix: string): string[];
clear(): void;
}
添加单词到字典数。
参数名 | 说明 |
---|---|
word | 要添加的单词 |
从字典树中移除单词。
检查字典树中是否存在单词。
获取所有带指定前缀的单词。
参数名 | 说明 |
---|---|
prefix | 单词前缀 |
返回值 | 所有带指定前缀的单词 |
清除字典树中的所有单词。
const trie = new Trie();
trie.add('carpet');
trie.add('car');
trie.add('cat');
trie.add('cart');
trie.has('cat'); // -> true
trie.remove('carpet');
trie.has('carpet'); // -> false
trie.words('car'); // -> ['car', 'cart']
trie.clear();
JavaScript 补间动画库。
class Tween extends Emitter {
constructor(target: any);
to(props: any, duration?: number, ease?: string | Function): Tween;
progress(): number;
progress(progress: number): Tween;
play(): Tween;
pause(): Tween;
paused(): boolean;
}
继承自 Emitter 类。
参数名 | 说明 |
---|---|
obj | 要补间的对象 |
参数名 | 说明 |
---|---|
destination | 目标属性值 |
duration | 补间时长 |
ease | 缓动函数 |
开始播放。
暂停动画。
检查动画是否暂停。
设置或获取动画进度。
参数名 | 说明 |
---|---|
progress | 介于 0 到 1 之间的数字 |
const pos = { x: 0, y: 0 };
const tween = new Tween(pos);
tween
.on('update', function(target) {
console.log(target.x, target.y);
})
.on('end', function(target) {
console.log(target.x, target.y); // -> 100, 100
});
tween.to({ x: 100, y: 100 }, 1000, 'inElastic').play();
简单 url 操作库。
namespace Url {
interface IUrl {
protocol: string;
auth: string;
hostname: string;
hash: string;
query: any;
port: string;
pathname: string;
slashes: boolean;
}
}
class Url {
protocol: string;
auth: string;
hostname: string;
hash: string;
query: any;
port: string;
pathname: string;
slashes: boolean;
constructor(url?: string);
setQuery(name: string, val: string | number): Url;
setQuery(query: types.PlainObj<string | number>): Url;
rmQuery(name: string | string[]): Url;
toString(): string;
static parse(url: string): Url.IUrl;
static stringify(object: Url.IUrl): string;
}
参数名 | 说明 |
---|---|
url=location | url 地址 |
设置 query 值。
参数名 | 说明 |
---|---|
name | query 名 |
val | query 值 |
返回值 | this |
参数名 | 说明 |
---|---|
query | query 对象 |
返回值 | this |
移除 query 值。
参数名 | 说明 |
---|---|
name | query 名 |
返回值 | this |
【静态】将 url 解析成对象。
参数名 | 说明 |
---|---|
url | url 地址 |
返回值 | url 对象 |
【静态】将 url 对象转换为 url 地址。
参数名 | 说明 |
---|---|
url | url 对象 |
返回值 | url 地址 |
url 对象包含以下属性值:
属性名 | 说明 |
---|---|
protocol | 协议名,(如 http:) |
slashes | 协议名后是否有双斜杠 |
auth | 身份验证(例如 用户名:密码) |
hostname | Host 名,不带端口号 |
port | 端口号 |
pathname | URL 路径 |
query | query 对象 |
hash | URL # 字符后边的部分,# 包含在内 |
const url = new Url('http://example.com:8080?eruda=true');
console.log(url.port); // -> '8080'
url.query.foo = 'bar';
url.rmQuery('eruda');
url.toString(); // -> 'http://example.com:8080/?foo=bar'
对象属性值校验。
class Validator {
constructor(options: types.PlainObj<any>);
validate(object: any): string | boolean;
static plugins: any;
static addPlugin(name: string, plugin: types.AnyFn): void;
}
参数名 | 说明 |
---|---|
options | 校验配置 |
校验对象。
参数名 | 说明 |
---|---|
obj | 目标对象 |
返回值 | 校验结果,true 表示通过 |
【静态】添加插件。
参数名 | 说明 |
---|---|
name | 插件名 |
plugin | 校验函数 |
required,number,boolean,string 和 regexp。
Validator.addPlugin('custom', function(val, key, config) {
if (typeof val === 'string' && val.length === 5) return true;
return key + ' should be a string with length 5';
});
const validator = new Validator({
test: {
required: true,
custom: true
}
});
validator.validate({}); // -> 'test is required'
validator.validate({ test: 1 }); // -> 'test should be a string with length 5';
validator.validate({ test: 'licia' }); // -> true
加权轮询调度算法实现。
class Wrr {
size: number;
set(val: any, weight: number): void;
get(val: any): number | void;
remove(val: any): void;
clear(): void;
next(): any;
}
池大小。
设置值和权重,如果值已存在则更新其权重。
参数名 | 说明 |
---|---|
val | 要设置的值 |
weight | 值的权重 |
获取指定值的权重。
参数名 | 说明 |
---|---|
val | 要获取的值 |
返回值 | 值的权重 |
移除指定值。
参数名 | 说明 |
---|---|
val | 要移除的值 |
从池中获取下一个值。
清除所有值。
const pool = new Wrr();
pool.set('A', 4);
pool.set('B', 8);
pool.set('C', 2);
pool.next();
pool.remove('A');
console.log(pool.size); // -> 2
计算字符串集的缩写集合。
function abbrev(...names: string[]): types.PlainObj<string>;
参数名 | 说明 |
---|---|
names | 字符串集 |
返回值 | 缩写集合 |
abbrev('lina', 'luna');
// -> {li: 'lina', lin: 'lina', lina: 'lina', lu: 'luna', lun: 'luna', luna: 'luna'}
创建一个函数,只有在调用 n 次后才会调用一次。
function after<T extends types.AnyFn>(n: number, fn: T): T;
参数名 | 说明 |
---|---|
n | 调用次数 |
fn | 源函数 |
返回值 | 输出函数 |
const fn = after(5, function() {
// -> Only invoke after fn is called 5 times.
});
执行异步 HTTP 请求。
namespace ajax {
function get(
url: string,
data: string | {},
success: types.AnyFn,
dataType?: string
): XMLHttpRequest;
function get(
url: string,
success: types.AnyFn,
dataType?: string
): XMLHttpRequest;
function post(
url: string,
data: string | {},
success: types.AnyFn,
dataType?: string
): XMLHttpRequest;
function post(
url: string,
success: types.AnyFn,
dataType?: string
): XMLHttpRequest;
}
function ajax(options: {
type?: string;
url: string;
data?: string | {};
dataType?: string;
contentType?: string;
success?: types.AnyFn;
error?: types.AnyFn;
complete?: types.AnyFn;
timeout?: number;
}): XMLHttpRequest;
参数名 | 说明 |
---|---|
options | Ajax 选项 |
可用选项:
参数名 | 说明 |
---|---|
type | 请求类型 |
url | 请求地址 |
data | 请求数据 |
dataType=json | 响应类型(json,xml) |
contentType=application/x-www-form-urlencoded | 请求内容类型 |
success | 成功回调 |
error | 失败回调 |
complete | 结束回调 |
timeout | 请求超时 |
type = GET 的快捷方式。
type = POST 的快捷方式。
参数名 | 说明 |
---|---|
url | 请求地址 |
data | 请求数据 |
success | 成功回调 |
dataType | 响应类型 |
ajax({
url: 'http://example.com',
data: { test: 'true' },
error() {},
success(data) {
// ...
},
dataType: 'json'
});
ajax.get('http://example.com', {}, function(data) {
// ...
});
获取对象的所有键名,包括自身的及继承的。
namespace allKeys {
interface IOptions {
prototype?: boolean;
unenumerable?: boolean;
}
}
function allKeys(
obj: any,
options: { symbol: true } & allKeys.IOptions
): Array<string | Symbol>;
function allKeys(
obj: any,
options?: ({ symbol: false } & allKeys.IOptions) | allKeys.IOptions
): string[];
参数名 | 说明 |
---|---|
obj | 目标对象 |
options | 选项 |
返回值 | 包含所有键名的数组 |
可用选项:
参数名 | 说明 |
---|---|
prototype=true | 包含原型键名 |
unenumerable=false | 包含不可枚举键名 |
symbol=false | 包含 Symbol 键名 |
Object 对象原型上的方法不会被获取到。
const obj = Object.create({ zero: 0 });
obj.one = 1;
allKeys(obj); // -> ['zero', 'one']
控制台颜色。
namespace ansiColor {
type IFn = (str: string) => string;
}
const ansiColor: {
black: ansiColor.IFn;
red: ansiColor.IFn;
green: ansiColor.IFn;
yellow: ansiColor.IFn;
blue: ansiColor.IFn;
magenta: ansiColor.IFn;
cyan: ansiColor.IFn;
white: ansiColor.IFn;
gray: ansiColor.IFn;
grey: ansiColor.IFn;
bgBlack: ansiColor.IFn;
bgRed: ansiColor.IFn;
bgGreen: ansiColor.IFn;
bgYellow: ansiColor.IFn;
bgBlue: ansiColor.IFn;
bgMagenta: ansiColor.IFn;
bgCyan: ansiColor.IFn;
bgWhite: ansiColor.IFn;
blackBright: ansiColor.IFn;
redBright: ansiColor.IFn;
greenBright: ansiColor.IFn;
yellowBright: ansiColor.IFn;
blueBright: ansiColor.IFn;
magentaBright: ansiColor.IFn;
cyanBright: ansiColor.IFn;
whiteBright: ansiColor.IFn;
bgBlackBright: ansiColor.IFn;
bgRedBright: ansiColor.IFn;
bgGreenBright: ansiColor.IFn;
bgYellowBright: ansiColor.IFn;
bgBlueBright: ansiColor.IFn;
bgMagentaBright: ansiColor.IFn;
bgCyanBright: ansiColor.IFn;
bgWhiteBright: ansiColor.IFn;
};
black, red, green, yellow, blue, magenta, cyan, white, gray, grey
bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite,
blackBright, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright
bgBlackBright, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright
ansiColor.red('Warning');
将字符串列表转换为映射。
function arrToMap<T>(
arr: string[],
val?: T
): { [key: string]: T };
参数名 | 说明 |
---|---|
arr | 字符串列表 |
val=true | 键值 |
返回值 | 映射 |
const needPx = arrToMap([
'column-count',
'columns',
'font-weight',
'line-weight',
'opacity',
'z-index',
'zoom'
]);
const key = 'column-count';
let val = '5';
if (needPx[key]) val += 'px';
console.log(val); // -> '5px'
window.atob,运行在 node 环境时使用 Buffer 进行模拟。
function atob(str: string): string;
atob('SGVsbG8gV29ybGQ='); // -> 'Hello World'
获取数字的平均值。
function average(...numbers: number[]): number;
参数名 | 说明 |
---|---|
numbers | 要计算的数字 |
返回值 | 平均值 |
average(5, 3, 1); // -> 3
base64 编解码。
const base64: {
encode(bytes: number[]): string;
decode(str: string): number[];
};
将字节数组编码为 base64 字符串。
参数名 | 说明 |
---|---|
bytes | 字节数组 |
返回值 | base64 编码的字符串 |
将 base64 字符串解码为字节数组。
参数名 | 说明 |
---|---|
str | base64 编码的字符串 |
返回值 | 字节数组 |
base64.encode([168, 174, 155, 255]); // -> 'qK6b/w=='
base64.decode('qK6b/w=='); // -> [168, 174, 155, 255]
创建一个函数,只能调用少于 n 次。
function before<T extends types.AnyFn>(n: number, fn: T): T;
参数名 | 说明 |
---|---|
n | 调用次数 |
fn | 源函数 |
返回值 | 输出函数 |
超过 n 次后再次调用函数将直接返回最后一次函数的调用结果。
const fn = before(5, function() {});
fn(); // Allow function to be call 4 times at last.
二分查找实现。
function binarySearch(
array: any[],
val: any,
cmp?: types.AnyFn
): number;
参数名 | 说明 |
---|---|
array | 目标数组 |
val | 要查找的值 |
cmp | 比较器 |
返回值 | 第一次出现的位置,如果没有,返回 -1 |
binarySearch([1, 2, 3], 2); // -> 1
binarySearch([1, 2], 3); // -> -1
binarySearch(
[
{
key: 1
},
{
key: 2
}
],
{ key: 1 },
(a, b) => {
if (a.key === b.key) return 0;
return a.key < b.key ? -1 : 1;
}
); // -> 0
创建一个绑定到指定对象的函数。
function bind(
fn: types.AnyFn,
ctx: any,
...args: any[]
): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 源函数 |
ctx | 绑定对象 |
args | 可选参数 |
返回值 | 输出函数 |
const fn = bind(
function(msg) {
console.log(this.name + ':' + msg);
},
{ name: 'eustia' },
'I am a utility library.'
);
fn(); // -> 'eustia: I am a utility library.'
window.btoa,运行在 node 环境时使用 Buffer 进行模拟。
function btoa(str: string): string;
btoa('Hello World'); // -> 'SGVsbG8gV29ybGQ='
冒泡排序实现。
function bubbleSort(arr: any[], cmp?: types.AnyFn): any[];
参数名 | 说明 |
---|---|
arr | 要排序的数组 |
cmp | 比较器 |
返回值 | 有序数组 |
bubbleSort([2, 1]); // -> [1, 2]
将字节数组转换为字符串。
function bytesToStr(bytes: number[], encoding?: string): string;
参数名 | 说明 |
---|---|
bytes | 字节数组 |
encoding=utf8 | 字符串编码 |
返回值 | 目标字符串 |
bytesToStr([108, 105, 99, 105, 97]); // -> 'licia'
将字节数组转换为 32 位字长数组。
function bytesToWords(bytes: number[]): number[];
在使用 CryptoJS 时会派上用处。
参数名 | 说明 |
---|---|
bytes | 字节数组 |
返回值 | 字长数组 |
bytesToWords([0x12, 0x34, 0x56, 0x78]); // -> [0x12345678]
缓存模块加载,提高应用启动速度。
function cacheRequire(options?: {
dir?: string;
requirePath?: boolean;
code?: boolean;
compileCache?: boolean;
}): void;
参数名 | 说明 |
---|---|
options | 缓存选项 |
可用选项:
参数名 | 说明 |
---|---|
dir | 缓存文件夹 |
requirePath=true | Whether require path should be cached |
code=false | Whether js code should be cached |
compileCache=true | Whether compile cache should be used |
cacheRequire({
dir: 'path/to/cache/dir'
});
将返回 Promise 的函数转换为使用回调的函数。
function callbackify(fn: types.AnyFn): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 返回 Promise 的函数 |
返回值 | 使用回调的函数 |
function fn() {
return new Promise(function(resolve, reject) {
// ...
});
}
const cbFn = callbackify(fn);
cbFn(function(err, value) {
// ...
});
将字符串转换为驼峰式。
function camelCase(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 驼峰式字符串 |
camelCase('foo-bar'); // -> fooBar
camelCase('foo bar'); // -> fooBar
camelCase('foo_bar'); // -> fooBar
camelCase('foo.bar'); // -> fooBar
将字符串的第一个字符转换为大写,其余字符转换为小写。
function capitalize(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
capitalize('rED'); // -> Red
将值转换为属性路径数组。
function castPath(path: string | string[], obj?: any): string[];
参数名 | 说明 |
---|---|
path | 要转换的值 |
obj | 目标对象 |
返回值 | 属性路径数组 |
castPath('a.b.c'); // -> ['a', 'b', 'c']
castPath(['a']); // -> ['a']
castPath('a[0].b'); // -> ['a', '0', 'b']
castPath('a.b.c', { 'a.b.c': true }); // -> ['a.b.c']
字符串居中。
function centerAlign(
str: string | string[],
width?: number
): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
width | 每行宽度 |
返回值 | 居中字符串 |
centerAlign('test', 8); // -> ' test'
centerAlign('test\nlines', 8); // -> ' test\n lines'
centerAlign(['test', 'lines'], 8); // -> ' test\n lines'
在容器内读取 cgroup 信息。
const cgroup: {
cpu: {
stat(): {
usage: number;
};
max(): number;
};
cpuset: {
cpus(): {
effective: number[];
};
};
memory: {
max(): number;
current(): number;
};
version(): number;
};
cgroup.cpu.stat();
根据指定的整数返回 unicode 编码为该整数的字符。
function char(num: number): string;
参数名 | 说明 |
---|---|
num | 要转换的整数 |
返回值 | 对应字符 |
char(65); // -> 'A'
char(97); // -> 'a'
将数组拆分为指定长度的子数组。
function chunk(arr: any[], size?: number): Array<any[]>;
参数名 | 说明 |
---|---|
arr | 源数组 |
size=1 | 子数组的长度 |
返回值 | 目标数组 |
chunk([1, 2, 3, 4], 2); // -> [[1, 2], [3, 4]]
chunk([1, 2, 3, 4], 3); // -> [[1, 2, 3], [4]]
chunk([1, 2, 3, 4]); // -> [[1], [2], [3], [4]]
将数字限定于指定区间。
function clamp(n: number, lower: number, upper: number): number;
function clamp(n: number, upper: number): number;
参数名 | 说明 |
---|---|
n | 要处理的数字 |
lower | 下限 |
upper | 上限 |
返回值 | 限定后的数字 |
clamp(-10, -5, 5); // -> -5
clamp(10, -5, 5); // -> 5
clamp(2, -5, 5); // -> 2
clamp(10, 5); // -> 5
clamp(2, 5); // -> 2
合并 class。
function className(...names: any[]): string;
参数名 | 说明 |
---|---|
names | 要合并的 class |
返回值 | 合并后的 class 字符串 |
className('a', 'b', 'c'); // -> 'a b c'
className('a', false, 'b', 0, 1, 'c'); // -> 'a b 1 c'
className('a', ['b', 'c']); // -> 'a b c'
className('a', { b: false, c: true }); // -> 'a c'
className('a', ['b', 'c', { d: true, e: false }]); // -> 'a b c d';
输出命令行帮助。
namespace cliHelp {
interface IOption {
name: string;
shorthand?: string;
desc: string;
}
interface ICommand {
name: string;
desc: string;
usage: string | string[];
options?: IOption[];
}
interface IData {
name: string;
usage: string | string[];
commands: ICommand[];
}
}
function cliHelp(data: cliHelp.IData | cliHelp.ICommand): string;
参数名 | 说明 |
---|---|
data | 帮助数据 |
返回值 | 命令行帮助 |
const test = {
name: 'test',
desc: 'Generate test files',
usage: ['<module-name> [options]', 'lpad --browser'],
options: [
{
name: 'browser',
shorthand: 'b',
desc: 'True if test should run in a browser'
}
]
};
const data = {
name: 'licia',
usage: '<command> [options]',
commands: [test]
};
cliHelp(data);
cliHelp(test);
对指定对象进行浅复制。
function clone<T>(val: T): T;
任何嵌套的对象或数组只会拷贝其引用。
参数名 | 说明 |
---|---|
val | 要克隆的值 |
返回值 | 克隆值 |
clone({ name: 'eustia' }); // -> {name: 'eustia'}
深复制。
function cloneDeep<T>(val: T): T;
参数名 | 说明 |
---|---|
val | 要克隆的值 |
返回值 | 克隆值 |
const obj = [{ a: 1 }, { a: 2 }];
const obj2 = cloneDeep(obj);
console.log(obj[0] === obj2[1]); // -> false
比较版本号。
function cmpVersion(v1: string, v2: string): number;
参数名 | 说明 |
---|---|
v1 | 版本号 |
v2 | 版本号 |
返回值 | 比较结果 |
cmpVersion('1.1.8', '1.0.4'); // -> 1
cmpVersion('1.0.2', '1.0.2'); // -> 0
cmpVersion('2.0', '2.0.0'); // -> 0
cmpVersion('3.0.1', '3.0.0.2'); // -> 1
cmpVersion('1.1.1', '1.2.3'); // -> -1
创建一个数组,用一个数组的值作为其键名,另一个数组的值作为其值。
function combine(keys: string[], values: any[]): any;
参数名 | 说明 |
---|---|
keys | 键名数组 |
values | 键值数组 |
返回值 | 目标对象 |
combine(['a', 'b', 'c'], [1, 2, 3]); // -> {a: 1, b: 2, c: 3}
返回数组的拷贝并移除其中的虚值。
function compact(arr: any[]): any[];
虚值包括 false,null,0,空字符串,undefined 和 NaN。
参数名 | 说明 |
---|---|
arr | 源数组 |
返回值 | 目标数组 |
compact([0, 1, false, 2, '', 3]); // -> [1, 2, 3]
将多个函数组合成一个函数。
function compose(...fn: types.AnyFn[]): types.AnyFn;
每个函数使用下一个函数的返回值作为参数。
参数名 | 说明 |
---|---|
...fn | 要组合的函数 |
返回值 | 目标函数 |
const welcome = compose(
function(name) {
return 'hi: ' + name;
},
function(name) {
return name.toUpperCase() + '!';
}
);
welcome('licia'); // -> 'hi: LICIA!'
使用 canvas 对图像进行压缩。
function compressImg(
file: File | Blob | string,
cb: types.AnyFn
): void;
function compressImg(
file: File | Blob | string,
options?: {
maxWidth?: number;
maxHeight?: number;
width?: number;
height?: number;
mimeType?: string;
quality?: number;
},
cb?: types.AnyFn
): void;
参数名 | 说明 |
---|---|
file | 图片文件或 url |
options | 选项 |
cb | 回调 |
可用选项:
参数名 | 说明 |
---|---|
maxWidth | 最大宽度 |
maxHeight | 最大高度 |
width | 输出图片宽度 |
height | 输出图片高度 |
mimeType | Mine 类型 |
quality=0.8 | 图片质量,从 0 到 1 |
为了保持图片比例,当宽度设置时高度将被忽略。
如果设置了宽高,最大宽度跟最大高度将被忽略。
const file = new Blob([]);
compressImg(
file,
{
maxWidth: 200
},
function(err, file) {
// ...
}
);
将多个数组合并成一个数组。
function concat(...args: Array<any[]>): any[];
参数名 | 说明 |
---|---|
...arr | 要合并的数组 |
返回值 | 合并后的数组 |
concat([1, 2], [3], [4, 5]); // -> [1, 2, 3, 4, 5]
检查数组中是否有指定值。
function contain(arr: any[] | {} | string, val: any): boolean;
参数名 | 说明 |
---|---|
target | 目标对象 |
val | 要检查的值 |
返回值 | 如果有,返回真 |
contain([1, 2, 3], 1); // -> true
contain({ a: 1, b: 2 }, 1); // -> true
contain('abc', 'a'); // -> true
在容器内读取容器信息。
const container: {
cpuNum(): number;
cpuUsage(period?: number): Promise<number>;
cpuLoad(period?: number): Promise<number>;
memUsage(): number;
memLoad(): number;
};
container.cpuNum();
对数字进行进制转换。
function convertBase(
num: number | string,
from: number,
to: number
): string;
参数名 | 说明 |
---|---|
num | 要转换的数字 |
from | 源进制 |
to | 目标进制 |
返回值 | 转换后的数字 |
convertBase('10', 2, 10); // -> '2'
convertBase('ff', 16, 2); // -> '11111111'
二进制数据格式转换。
namespace convertBin {
function blobToArrBuffer(blob: any): Promise<ArrayBuffer>;
}
function convertBin(bin: any, type: string): any;
参数名 | 说明 |
---|---|
bin | 源二进制数据 |
type | 二进制类型 |
返回值 | 目标二进制数据 |
base64, ArrayBuffer, Array, Uint8Array, Blob(browser), Buffer(node)
因为将 Blob 转换为其它格式是个异步过程,所以你不能直接对它进行转换。
将 Blob 类型转换为 ArrayBuffer 类型。
参数名 | 说明 |
---|---|
blob | Blob 数据 |
返回值 | ArrayBuffer promise |
convertBin('qK6b/w==', 'Uint8Array'); // -> [168, 174, 155, 255]
convertBin.blobToArrBuffer(new Blob([])).then(arrBuffer => {
// Do something...
});
浏览器 cookie 操作库。
namespace cookie {
interface IOptions {
path?: string;
expires?: number;
domain?: string;
secure?: boolean;
}
interface ICookie {
get(key: string, options?: cookie.IOptions): string;
set(key: string, val: string, options?: cookie.IOptions): ICookie;
remove(key: string, options?: cookie.IOptions): ICookie;
}
}
const cookie: cookie.ICookie;
获取 cookie 值。
参数名 | 说明 |
---|---|
key | Cookie 键名 |
返回值 | 对应的 cookie 值 |
设置 cookie 值。
参数名 | 说明 |
---|---|
key | cookie 键名 |
val | cookie 值 |
options | cookie 选项 |
返回值 | cookie 模块 |
移除 cookie 值。
参数名 | 说明 |
---|---|
key | Cookie 键名 |
options | Cookie 选项 |
返回值 | cookie 模块 |
cookie.set('a', '1', { path: '/' });
cookie.get('a'); // -> '1'
cookie.remove('a');
使用 document.execCommand 将文本拷贝到剪贴板。
function copy(text: string, cb?: types.AnyFn): void;
参数名 | 说明 |
---|---|
text | 要拷贝的文本 |
cb | 可选回调 |
copy('text', function(err) {
// Handle errors.
});
CRC1 算法实现。
function crc1(
input: string | number[],
previous?: number
): number;
参数名 | 说明 |
---|---|
input | 信息码 |
previous | 用于累积计算的 CRC1 校验码 |
返回值 | CRC1 校验码 |
crc1('1234567890').toString(16); // -> 'd'
CRC16 算法实现。
function crc16(
input: string | number[],
previous?: number
): number;
参数名 | 说明 |
---|---|
input | 信息码 |
previous | 用于累积计算的 CRC16 校验码 |
返回值 | CRC16 校验码 |
crc16('1234567890').toString(16); // -> 'c57a'
CRC32 算法实现。
function crc32(
input: string | number[],
previous?: number
): number;
参数名 | 说明 |
---|---|
input | 信息码 |
previous | 用于累积计算的 CRC32 校验码 |
返回值 | CRC32 校验码 |
crc32('1234567890').toString(16); // -> '261daee5'
CRC8 算法实现。
function crc8(
input: string | number[],
previous?: number
): number;
参数名 | 说明 |
---|---|
input | 信息码 |
previous | 用于累积计算的 CRC8 校验码 |
返回值 | CRC8 校验码 |
crc8('1234567890').toString(16); // -> '52'
创建对象并指定它的原型。
function create(proto?: object): any;
参数名 | 说明 |
---|---|
proto | 新对象原型 |
返回值 | 目标对象 |
const obj = create({ a: 1 });
console.log(obj.a); // -> 1
用于创建 extend,extendOwn 和 defaults 等模块。
function createAssigner(
keysFn: types.AnyFn,
defaults: boolean
): types.AnyFn;
参数名 | 说明 |
---|---|
keysFn | 获取对象键名的函数 |
defaults | 设置为真时不对值进行覆盖 |
返回值 | 目标函数 |
CreateObjectURL 的包裹函数。
function createUrl(
data: any,
options?: { type?: string }
): string;
参数名 | 说明 |
---|---|
data | 数据 |
options | 当数据不是 File 或者 Blob 对象时使用 |
返回值 | Blob 地址 |
createUrl('test', { type: 'text/plain' }); // -> Blob url
createUrl(['test', 'test']);
createUrl(new Blob([]));
createUrl(new File(['test'], 'test.txt'));
CSS 解析器。
const css: {
parse(css: string): object;
stringify(stylesheet: object, options?: { indent?: string }): string;
};
注释会被移除掉。
将 CSS 字符串转换为 js 对象。
参数名 | 说明 |
---|---|
css | CSS 字符串 |
返回值 | js 对象 |
将 js 对象序列化成 CSS 字符串。
参数名 | 说明 |
---|---|
stylesheet | 要序列化的对象 |
options | 序列化选项 |
返回值 | CSS 字符串 |
选项:
参数名 | 说明 |
---|---|
indent=' ' | 缩进 |
const stylesheet = css.parse('.name { background: #000; color: red; }');
// {type: 'stylesheet', rules: [{type: 'rule', selector: '.name', declarations: [...]}]}
css.stringify(stylesheet);
计算与比较 CSS 选择器/样式的优先级。
namespace cssPriority {
function compare(p1: number[], p2: number[]): number;
}
function cssPriority(
selector: string,
options?: {
important?: boolean;
inlineStyle?: boolean;
position?: number;
}
): number[];
参数名 | 说明 |
---|---|
selector | CSS 选择器 |
options | 样式额外信息 |
返回值 | 优先级数组 |
优先级数组包括六个数字值。
比较优先级。
参数名 | 说明 |
---|---|
p1 | 优先级数组 |
p2 | 优先级数组 |
返回值 | 比较结果 |
cssPriority('a.button > i.icon:before', {
important: true,
inlineStyle: false,
position: 100
}); // -> [1, 0, 0, 2, 3, 100]
检查浏览器是否支持某项 CSS 特性。
function cssSupports(name: string, val?: string): boolean;
参数名 | 说明 |
---|---|
name | Css 属性名 |
val | Css 属性值 |
返回值 | 如果支持,返回真 |
cssSupports('display', 'flex'); // -> true
cssSupports('display', 'invalid'); // -> false
cssSupports('text-decoration-line', 'underline'); // -> true
cssSupports('grid'); // -> true
cssSupports('invalid'); // -> false
函数柯里化。
function curry(fn: types.AnyFn): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 源函数 |
返回值 | 目标函数 |
const add = curry(function(a, b) {
return a + b;
});
const add1 = add(1);
add1(2); // -> 3
解析序列化 Data URL。
const dataUrl: {
parse(
dataUrl: string
): { data: string; mime: string; charset: string; base64: boolean } | null;
stringify(
data: any,
mime: string,
options?: { base64?: boolean; charset?: string }
): string;
};
解析 Data URL。
参数名 | 说明 |
---|---|
dataUrl | Data URL 字符串 |
返回值 | 解析后的对象 |
将数据转化为 Data URL。
参数名 | 说明 |
---|---|
data | 要转化的数据 |
mime | mime 类型 |
options | Stringify options |
返回值 | Data url string |
选项名 | 说明 |
---|---|
base64=true | 是否是 base64 编码 |
charset | 字符集 |
dataUrl.parse('data:,Hello%2C%20World%21'); // -> {data: 'Hello, World!', mime: 'text/plain', charset: '', base64: false}
dataUrl.stringify('Hello, World!', 'text/plain'); // -> 'data:,Hello%2C%20World%21'
简单日期格式化。
function dateFormat(
date: Date,
mask: string,
utc?: boolean,
gmt?: boolean
): string;
function dateFormat(
mask: string,
utc?: boolean,
gmt?: boolean
): string;
参数名 | 说明 |
---|---|
date=new Date | 要格式化的日期对象 |
mask | 日期掩码 |
utc=false | 是否是 UTC |
gmt=false | 是否是 GMT |
返回值 | 格式化日期 |
掩码 | 说明 |
---|---|
d | 月份天数,不补零 |
dd | 月份天数,不足两位补零 |
ddd | 星期几,简称 |
dddd | 星期几,全称 |
m | 月份,数字,不补零 |
mm | 月份,数字,不足两位补零 |
mmm | 月份,简称 |
mmmm | 月份,全称 |
yy | 年份,只显示后两位数字,不足两位补零 |
yyyy | 年份,显示四位数字 |
h | 小时,不补零 (12 小时制) |
hh | 小时,不足两位补零(12 小时制) |
H | 小时,不补零(24 小时制) |
HH | 小时,不足两位补零(24 小时制) |
M | 分钟,不补零 |
MM | 分钟,不足两位补零 |
s | 秒数,不补零 |
ss | 秒数,不足两位补零 |
l L | 毫秒,l 显示 3 位, L 显示 2 位 |
t | 小写显示上午下午,a 或 p |
tt | 小写显示上午下午,am 或 pm |
T | 大写显示上午下午,A 或 P |
TT | 大写显示上午下午,AM 或 PM |
Z | 美国时区缩写,比如 EST 或 MDT |
o | GMT/UTC 时区时差,比如 -0500 或 +0230 |
S | 月份天数序数后缀 (st,nd,rd,或 th) |
UTC: | 是否是 UTC,必须写在最前面 |
dateFormat('isoDate'); // -> 2016-11-19
dateFormat('yyyy-mm-dd HH:MM:ss'); // -> 2016-11-19 19:00:04
dateFormat(new Date(), 'yyyy-mm-dd'); // -> 2016-11-19
返回函数的防反跳版本。
function debounce<T extends types.AnyFn>(fn: T, wait: number): T;
参数名 | 说明 |
---|---|
fn | 源函数 |
wait | 延迟毫秒数 |
返回值 | 目标函数 |
const calLayout = debounce(function() {}, 300);
// $(window).resize(calLayout);
简单的 JavaScript 输出 debug 日志函数。
function debug(name: string): any;
参数名 | 说明 |
---|---|
name | 名称 |
返回值 | 打印格式化日志的函数 |
const d = debug('test');
d('doing lots of uninteresting work');
d.enabled = false;
转换拉丁语-1补充字母和拉丁语扩展字母-A为基本拉丁字母,并且去除组合变音标记。
function deburr(str: string): string;
参数名 | 说明 |
---|---|
str | 要处理的字符串 |
返回值 | 目标字符串 |
deburr('déjà vu'); // -> 'deja vu'
类似 decodeURIComponent 函数,只是输入不合法时不抛出错误并尽可能地对其进行解码。
function decodeUriComponent(str: string): string;
参数名 | 说明 |
---|---|
str | 要解码的字符串 |
返回值 | 解码后的字符串 |
decodeUriComponent('%%25%'); // -> '%%%'
decodeUriComponent('%E0%A4%A'); // -> '\xE0\xA4%A'
填充对象的默认值。
function defaults(obj: any, ...src: any[]): any;
参数名 | 说明 |
---|---|
obj | 目标对象 |
...src | 提供默认值对象 |
返回值 | 目标对象 |
defaults({ name: 'RedHood' }, { name: 'Unknown', age: 24 }); // -> {name: 'RedHood', age: 24}
定义一个模块,需要跟 use 模块配合使用。
function define(
name: string,
requires: string[],
method: types.AnyFn
): void;
function define(name: string, method: types.AnyFn): void;
参数名 | 说明 |
---|---|
name | 模块名 |
requires | 依赖 |
method | 模块主体函数 |
模块主体函数只有被 use 模块使用时才会被执行。
define('A', function() {
return 'A';
});
define('B', ['A'], function(A) {
return 'B' + A;
});
Object.defineProperty(defineProperties) 的快捷方式。
function defineProp<T>(
obj: T,
prop: string,
descriptor: PropertyDescriptor
): T;
function defineProp<T>(
obj: T,
descriptor: PropertyDescriptorMap
): T;
参数名 | 说明 |
---|---|
obj | 要定义的对象 |
prop | 属性路径 |
descriptor | 属性描述 |
返回值 | 传入对象 |
参数名 | 说明 |
---|---|
obj | 要定义的对象 |
prop | 属性描述 |
返回值 | 传入对象 |
const obj = { b: { c: 3 }, d: 4, e: 5 };
defineProp(obj, 'a', {
get: function() {
return this.e * 2;
}
});
// obj.a is equal to 10
defineProp(obj, 'b.c', {
set: function(val) {
// this is pointed to obj.b
this.e = val;
}.bind(obj)
});
obj.b.c = 2;
// obj.a is equal to 4
const obj2 = { a: 1, b: 2, c: 3 };
defineProp(obj2, {
a: {
get: function() {
return this.c;
}
},
b: {
set: function(val) {
this.c = val / 2;
}
}
});
// obj2.a is equal to 3
obj2.b = 4;
// obj2.a is equal to 2
返回第一个不是未定义的参数。
function defined(...args: any[]): any;
参数名 | 说明 |
---|---|
...args | 参数列表 |
返回值 | 第一个定义了的参数 |
defined(false, 2, void 0, 100); // -> false
删除 node.js require 缓存。
function delRequireCache(id: string): void;
参数名 | 说明 |
---|---|
id | 模块名或路径 |
const licia = require('licia');
licia.a = 5;
delRequireCache('licia');
require('licia').a; // -> undefined
在指定时长后执行函数。
function delay(
fn: types.AnyFn,
wait: number,
...args: any[]
): void;
参数名 | 说明 |
---|---|
fn | 源函数 |
wait | 延迟的毫秒数 |
...args | 绑定参数 |
delay(
function(text) {
console.log(text);
},
1000,
'later'
);
// -> Logs 'later' after one second
事件委托。
const delegate: {
add(el: Element, type: string, selector: string, cb: types.AnyFn): void;
remove(el: Element, type: string, selector: string, cb: types.AnyFn): void;
};
添加事件委托。
参数名 | 说明 |
---|---|
el | 父元素 |
type | 事件类型 |
selector | 匹配选择器 |
cb | 事件回调 |
移除事件委托。
const container = document.getElementById('container');
function clickHandler() {
// Do something...
}
delegate.add(container, 'click', '.children', clickHandler);
delegate.remove(container, 'click', '.children', clickHandler);
Node.js util.deprecate 方法,支持浏览器。
function deprecate(fn: types.AnyFn, msg: string): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 即将废弃的方法 |
msg | 调用警告 |
返回值 | 废弃方法,调用时会打印警告 |
const fn = () => {};
const obsoleteFn = deprecate(fn, 'obsoleteFn is deprecated.');
obsoleteFn();
使用 ua 检测浏览器信息。
function detectBrowser(
ua?: string
): {
name: string;
version: number;
};
参数名 | 说明 |
---|---|
ua=navigator.userAgent | 浏览器用户代理 |
返回值 | 包含名称和版本的对象 |
支持浏览器:ie,chrome,edge,firefox,opera,safari,ios(mobile safari),android(android browser)
const browser = detectBrowser();
if (browser.name === 'ie' && browser.version < 9) {
// Do something about old IE...
}
检测是否有 mocha 测试框架在运行。
function detectMocha(): boolean;
detectMocha(); // -> True if mocha is running.
使用 ua 检测操作系统。
function detectOs(ua?: string): string;
参数名 | 说明 |
---|---|
ua=navigator.userAgent | 浏览器用户代理 |
返回值 | 操作系统名称 |
支持操作系统: windows, os x, linux, ios, android, windows phone
if (detectOs() === 'ios') {
// Do something about ios...
}
创建一个数组,该数组的元素不存在于给定的其它数组中。
function difference(arr: any[], ...args: any[]): any[];
参数名 | 说明 |
---|---|
arr | 源数组 |
...args | 要排除的元素 |
返回值 | 目标数组 |
difference([3, 2, 1], [4, 2]); // -> [3, 1]
将字符串转换为点式。
function dotCase(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 点式字符串 |
dotCase('fooBar'); // -> foo.bar
dotCase('foo bar'); // -> foo.bar
在浏览器端触发文件下载。
function download(
data: Blob | File | string | any[],
name: string,
type?: string
): void;
参数名 | 说明 |
---|---|
data | 下载的数据 |
name | 文件名 |
type=text/plain | 数据类型 |
download('test', 'test.txt');
设备像素比工具库。
namespace dpr {
interface IDpr extends Emitter {
get(): number;
}
}
const dpr: dpr.IDpr;
绑定 change 事件。
解绑 change 事件。
获取当前设备像素比。
dpr.on('change', function(dpr) {
console.log(dpr); // -> 2
});
dpr.get(); // -> 1
简单时间格式化。
function durationFormat(duration: number, mask?: string): string;
参数名 | 说明 |
---|---|
duration | 要格式化的时间,单位为毫秒 |
mask='hh:mm:ss' | 时间掩码 |
返回值 | 格式化时间 |
掩码 | 说明 |
---|---|
d | 天数 |
h | 小时数 |
m | 分钟数 |
s | 秒数 |
l | 毫秒数 |
durationFormat(12345678); // -> '03:25:45'
durationFormat(12345678, 'h:m:s:l'); // -> '3:25:45:678'
遍历集合中的所有元素,用每个元素当做参数调用迭代器。
function each<T>(
list: types.List<T>,
iterator: types.ListIterator<T, void>,
ctx?: any
): types.List<T>;
function each<T>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, void>,
ctx?: any
): types.Collection<T>;
参数名 | 说明 |
---|---|
obj | 目标集合 |
iterator | 迭代器 |
ctx | 函数上下文 |
each({ a: 1, b: 2 }, function(val, key) {});
缓动函数,参考 http://jqueryui.com/ 。
const easing: {
linear(percent: number): number;
inQuad(percent: number): number;
outQuad(percent: number): number;
inOutQuad(percent: number): number;
outInQuad(percent: number): number;
inCubic(percent: number): number;
outCubic(percent: number): number;
inQuart(percent: number): number;
outQuart(percent: number): number;
inQuint(percent: number): number;
outQuint(percent: number): number;
inExpo(percent: number): number;
outExpo(percent: number): number;
inSine(percent: number): number;
outSine(percent: number): number;
inCirc(percent: number): number;
outCirc(percent: number): number;
inElastic(percent: number, elasticity?: number): number;
outElastic(percent: number, elasticity?: number): number;
inBack(percent: number): number;
outBack(percent: number): number;
inOutBack(percent: number): number;
outInBack(percent: number): number;
inBounce(percent: number): number;
outBounce(percent: number): number;
};
参数名 | 说明 |
---|---|
percent | 位于 0 到 1 之前的数字 |
返回值 | 计算结果 |
easing.linear(0.5); // -> 0.5
easing.inElastic(0.5, 500); // -> 0.03125
在桌面端浏览器模拟 touch 事件。
function emulateTouch(el: Element): void;
参数名 | 说明 |
---|---|
el | 目标元素 |
const el = document.querySelector('#test');
emulateTouch(el);
el.addEventListener('touchstart', () => {}, false);
检查字符串是否以指定字符串结尾。
function endWith(str: string, suffix: string): boolean;
参数名 | 说明 |
---|---|
str | 目标字符串 |
suffix | 字符串后缀 |
返回值 | 如果是后缀,返回真 |
endWith('ab', 'b'); // -> true
转义 HTML 字符串,替换 &,<,>,",`,和 ' 字符。
function escape(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
escape('You & Me'); // -> 'You & Me'
转义字符串为合法的 JavaScript 字符串字面量。
function escapeJsStr(str: string): string;
http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
escapeJsStr('"\n'); // -> '\\"\\\\n'
转义特殊字符用于 RegExp 构造函数。
function escapeRegExp(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
escapeRegExp('[licia]'); // -> '\\[licia\\]'
加载 css 到页面中。
function evalCss(css: string): HTMLStyleElement;
参数名 | 说明 |
---|---|
css | css 代码 |
返回值 | style 节点 |
evalCss('body{background:#08c}');
在指定的上下文执行 js 代码。
function evalJs(js: string, ctx?: any): void;
参数名 | 说明 |
---|---|
js | JavaScript 代码 |
ctx=global | 上下文 |
evalJs('5+2'); // -> 7
evalJs('this.a', { a: 2 }); // -> 2
检查是否集合中的所有元素都能通过真值检测。
function every<T>(
object: types.List<T>,
iterator?: types.ListIterator<T, boolean>,
context?: any
): boolean;
function every<T>(
object: types.Dictionary<T>,
iterator?: types.ObjectIterator<T, boolean>,
context?: any
): boolean;
参数名 | 说明 |
---|---|
object | 目标集合 |
iterator | 真值检测函数 |
context | 函数上下文 |
返回值 | 如果都能通过,返回真 |
every([2, 4], function(val) {
return val % 2 === 0;
}); // -> true
复制多个对象中的所有属性到目标对象上。
function extend(destination: any, ...sources: any[]): any;
参数名 | 说明 |
---|---|
destination | 目标对象 |
...sources | 源对象 |
返回值 | 目标对象 |
extend({ name: 'RedHood' }, { age: 24 }); // -> {name: 'RedHood', age: 24}
类似 extend,但会递归进行扩展。
function extendDeep(destination: any, ...sources: any[]): any;
参数名 | 说明 |
---|---|
destination | 目标对象 |
...sources | 源对象 |
返回值 | 目标对象 |
extendDeep(
{
name: 'RedHood',
family: {
mother: 'Jane',
father: 'Jack'
}
},
{
family: {
brother: 'Bruce'
}
}
);
// -> {name: 'RedHood', family: {mother: 'Jane', father: 'Jack', brother: 'Bruce'}}
类似 extend,但只复制自己的属性,不包括原型链上的属性。
function extendOwn(destination: any, ...sources: any[]): any;
参数名 | 说明 |
---|---|
obj | 目标对象 |
...sources | 源对象 |
返回值 | 目标对象 |
extendOwn({ name: 'RedHood' }, { age: 24 }); // -> {name: 'RedHood', age: 24}
从源码中提取块注释。
function extractBlockCmts(str: string): string[];
参数名 | 说明 |
---|---|
str | 源码 |
返回值 | 块注释 |
extractBlockCmts('\/*licia*\/'); // -> ['licia']
从文本中提取 url。
function extractUrls(str: string): string[];
参数名 | 说明 |
---|---|
str | 文本 |
返回值 | url 列表 |
const str =
'[Official site: http://eustia.liriliri.io](http://eustia.liriliri.io)';
extractUrls(str); // -> ['http://eustia.liriliri.io']
将 XMLHttpRequest 转换为 promise 的形式。
namespace fetch {
interface IResult {
ok: boolean;
status: number;
statusText: string;
url: string;
clone(): IResult;
text(): Promise<string>;
json(): Promise<any>;
xml(): Promise<Document | null>;
blob(): Promise<Blob>;
headers: {
keys(): string[];
entries(): Array<string[]>;
get(name: string): string;
has(name: string): boolean;
};
}
}
function fetch(
url: string,
options?: {
method?: string;
timeout?: number;
headers?: types.PlainObj<string>;
body?: any;
}
): Promise<fetch.IResult>;
注意:这并不是 fetch 的 pollyfill。
参数名 | 说明 |
---|---|
url | 请求地址 |
options | 请求选项 |
返回值 | 请求 promise |
fetch('test.json', {
method: 'GET',
timeout: 3000,
headers: {},
body: ''
})
.then(function(res) {
return res.json();
})
.then(function(data) {
console.log(data);
});
计算斐波那契数列中某位数字。
function fibonacci(n: number): number;
参数名 | 说明 |
---|---|
n | 序号 n |
返回值 | 斐波那契数列 n 位的数字 |
fibonacci(1); // -> 1
fibonacci(3); // -> 2
将字节数转换为易于阅读的形式。
function fileSize(bytes: number): string;
function fileSize(size: string): number;
参数名 | 说明 |
---|---|
bytes | 文件字节大小 |
返回值 | 易于阅读的文件大小 |
将易于阅读的文件大小转换为字节数。
参数名 | 说明 |
---|---|
size | 易于阅读的文件大小 |
返回值 | 文件字节大小 |
fileSize(5); // -> '5'
fileSize(1500); // -> '1.46K'
fileSize(1500000); // -> '1.43M'
fileSize(1500000000); // -> '1.4G'
fileSize(1500000000000); // -> '1.36T'
使用幻数检测文件类型。
function fileType(
input: Buffer | ArrayBuffer | Uint8Array
):
| {
ext: string;
mime: string;
}
| undefined;
参数名 | 说明 |
---|---|
input | 文件输入 |
返回值 | 包括扩展名和 mime 类型的对象 |
jpg, png, gif, webp, bmp, gz, zip, rar, pdf, exe
const fs = require('fs');
const file = fs.readFileSync('path/to/file');
console.log(fileType(file)); // -> { ext: 'jpg', mime: 'image/jpeg' }
将文件路径转换为文件协议 URL。
function fileUrl(path: string): string;
参数名 | 说明 |
---|---|
path | 文件路径 |
返回值 | 文件协议 URL |
fileUrl('c:\\foo\\bar'); // -> 'file:///c:/foo/bar'
在数组指定位置填充指定值。
function fill(
list: any[],
val: any,
start?: number,
end?: number
): any[];
参数名 | 说明 |
---|---|
list | 源数组 |
val | 填充数组的值 |
start=0 | 起始位置 |
end=arr.length | 结束位置,不包括 |
返回值 | 目标数组 |
fill([1, 2, 3], '*'); // -> ['*', '*', '*']
fill([1, 2, 3], '*', 1, 2); // -> [1, '*', 3]
遍历集合中的每个元素,返回所有通过真值检测的元素组成的数组。
function filter<T>(
list: types.List<T>,
iterator: types.ListIterator<T, boolean>,
context?: any
): T[];
function filter<T>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, boolean>,
context?: any
): T[];
参数名 | 说明 |
---|---|
obj | 要遍历的集合 |
predicate | 真值检测函数 |
ctx | 函数上下文 |
返回值 | 包含所有通过真值检测元素的数组 |
filter([1, 2, 3, 4, 5], function(val) {
return val % 2 === 0;
}); // -> [2, 4]
找到集合中第一个通过真值检测的元素。
function find<T>(
object: types.List<T>,
iterator: types.ListIterator<T, boolean>,
context?: any
): T | undefined;
function find<T>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, boolean>,
context?: any
): T | undefined;
参数名 | 说明 |
---|---|
object | 目标集合 |
iterator | 真值检测函数 |
context | 函数上下文 |
返回值 | 第一个通过的元素 |
find(
[
{
name: 'john',
age: 24
},
{
name: 'jane',
age: 23
}
],
function(val) {
return val.age === 23;
}
); // -> {name: 'jane', age: 23}
返回第一个通过真值检测元素在数组中的位置。
function findIdx(arr: any[], predicate: types.AnyFn): number;
参数名 | 说明 |
---|---|
arr | 目标集合 |
predicate | 真值检测函数 |
返回值 | 第一个符合条件元素的位置 |
findIdx(
[
{
name: 'john',
age: 24
},
{
name: 'jane',
age: 23
}
],
function(val) {
return val.age === 23;
}
); // -> 1
返回对象中第一个通过真值检测的属性键名。
function findKey(
obj: any,
predicate: types.AnyFn,
ctx?: any
): string | void;
参数名 | 说明 |
---|---|
obj | 目标对象 |
predicate | 真值检测函数 |
ctx | 函数上下文 |
返回值 | 符合条件的键名 |
findKey({ a: 1, b: 2 }, function(val) {
return val === 1;
}); // -> a
同 findIdx,只是查找顺序改为从后往前。
function findLastIdx(arr: any[], predicate: types.AnyFn): number;
参数名 | 说明 |
---|---|
arr | 目标集合 |
predicate | 真值检测函数 |
返回值 | 从后往前,第一个符合条件元素的位置 |
findLastIdx(
[
{
name: 'john',
age: 24
},
{
name: 'jane',
age: 23
},
{
name: 'kitty',
age: 24
}
],
function(val) {
return val.age === 24;
}
); // -> 2
递归拍平数组。
function flatten(arr: any[]): any[];
参数名 | 说明 |
---|---|
arr | 源数组 |
返回值 | 目标数组 |
flatten(['a', ['b', ['c']], 'd', ['e']]); // -> ['a', 'b', 'c', 'd', 'e']
检验函数参数。
function fnArgs(types: string[], args: any): void;
参数名 | 说明 |
---|---|
types | 参数类型 |
args | Argument 对象 |
如果检验失败,抛出异常。
function test(a, b, c) {
fnArgs(['number|string', '?Function', '...number'], arguments);
// Do something.
}
test(15);
test('test', () => {});
test('test', () => {}, 5);
test(); // Throw error
test('test', 'test'); // Throw error
test('test', () => {}, 5, 'test'); // Throw error
获取函数的参数名列表。
function fnParams(fn: types.AnyFn | string): string[];
参数名 | 说明 |
---|---|
fn | 目标函数 |
返回值 | 参数名 |
fnParams(function(a, b) {}); // -> ['a', 'b']
简单 FNV-1a 哈希算法实现。
function fnv1a(str: string): number;
参数名 | 说明 |
---|---|
str | 目标字符串 |
返回值 | 哈希结果 |
fnv1a('test'); // -> 2949673445
使用类似于 printf 的方式来格式化字符串。
function format(str: string, ...values: any[]): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
...values | 替换占位符的值 |
返回值 | 目标字符串 |
占位符 | 说明 |
---|---|
%s | 字符串 |
%d, %i | 整数 |
%f | 浮点数 |
%o | 对象 |
format('%s_%s', 'foo', 'bar'); // -> 'foo_bar'
转换数字为分数形式。
function fraction(num: number): string;
参数名 | 说明 |
---|---|
num | 数字 |
返回值 | 对应的分数 |
fraction(1.2); // -> '6/5'
Object.freeze 的快捷方式。
function freeze<T>(obj: T): T;
如果不支持 Object.freeze,使用 Object.defineProperties 进行模拟。
参数名 | 说明 |
---|---|
obj | 目标对象 |
返回值 | 目标对象 |
const a = { b: 1 };
freeze(a);
a.b = 2;
console.log(a); // -> {b: 1}
递归进行 Object.freeze。
function freezeDeep<T>(obj: T): T;
参数名 | 说明 |
---|---|
obj | 目标对象 |
返回值 | 目标对象 |
const a = { b: { c: 1 } };
freezeDeep(a);
a.b.c = 2;
console.log(a); // -> {b: {c: 1}}
node.js fs 模块的 promise 版本。
const fs: {
readFile(path: string, encoding: string): Promise<string>;
readFile(path: string): Promise<Buffer>;
exists(path: string): Promise<boolean>;
unlink(path: string): Promise<void>;
writeFile(path: string, data: string, options?: string): Promise<void>;
writeFile(path: string, data: Buffer): Promise<void>;
readdir(path: string): Promise<string[]>;
rmdir(path: string): Promise<void>;
[key: string]: any;
};
fs.readFile('test.js')
.then(function(data) {
// Do something
})
.catch(function(err) {
// Handle errors
});
全屏接口封装。
namespace fullscreen {
interface IFullscreen extends Emitter {
request(el?: Element): void;
exit(): void;
toggle(el?: Element): void;
isActive(): boolean;
getEl(): Element | null;
isEnabled(): boolean;
}
}
const fullscreen: fullscreen.IFullscreen;
进入全屏。
参数名 | 说明 |
---|---|
el | 全屏元素 |
退出全屏。
切换全屏。
参数名 | 说明 |
---|---|
el | 全屏元素 |
是否全屏。
获取全屏元素。
是否可以进入全屏。
fullscreen.request();
fullscreen.isActive(); // -> false, not a synchronous api
fullscreen.on('error', () => {});
fullscreen.on('change', () => {});
模糊搜索。
function fuzzySearch(
needle: string,
haystack: any[],
options?: {
caseSensitive?: boolean;
key?: string | string[];
}
): any[];
参数名 | 说明 |
---|---|
needle | 搜索字符串 |
haystacks | 搜索集合 |
options | 搜索选项 |
可用选项:
参数名 | 说明 |
---|---|
caseSensitive=false | 是否大小写敏感 |
key | 搜索项是对象时的字符串路径 |
fuzzySearch('lic', ['licia', 'll', 'lic']); // -> ['lic', 'licia']
fuzzySearch(
'alpha-test',
[
{
name: 'alpha-test-1'
},
{
name: 'beta-test'
}
],
{
key: 'name'
}
); // -> [{ name: 'alpha-test-1' }]
使用欧几里德算法求最大公约数。
function gcd(a: number, b: number): number;
参数名 | 说明 |
---|---|
a | 要计算的数字 |
b | 要计算的数字 |
返回值 | 最大公约数 |
gcd(121, 44); // -> 11
获取有效的 TCP 端口。
function getPort(
port?: number | number[],
host?: string
): Promise<number>;
参数名 | 说明 |
---|---|
port | 首选端口 |
host | 地址 |
返回值 | 有效端口 |
如果首选端口无法使用,将会返回一个有效的随机端口。
getPort([3000, 3001], '127.0.0.1').then(port => {
console.log(port);
});
获取对象的原型。
function getProto(obj: any): any;
参数名 | 说明 |
---|---|
obj | 目标对象 |
返回值 | 对象原型,如果不存在,返回 null |
const a = {};
getProto(Object.create(a)); // -> a
获取 url 参数值。
function getUrlParam(
name: string,
url?: string
): string | undefined;
参数名 | 说明 |
---|---|
name | 参数名 |
url=location | 目标 url |
返回值 | 参数值 |
getUrlParam('test', 'http://example.com/?test=true'); // -> 'true'
像 Go 一样处理错误。
function golangify<T, U = Error>(
fn: (...args: any[]) => Promise<T>
): (...args: any[]) => Promise<[T | undefined, U | null]>;
function golangify<T, U = Error>(
p: Promise<T>
): Promise<[T | undefined, U | null]>;
参数名 | 说明 |
---|---|
fn | 返回 Promise 的函数 |
返回值 | 同上,但 Promise 的结果形式为 [result, error] |
参数名 | 说明 |
---|---|
p | 要转换的 Promise |
返回值 | 目标 Promise,结果形式为 [result, error] |
(async () => {
let fnA = golangify(async () => {
throw Error('err');
});
await fnA(); // -> [undefined, Error]
let fnB = golangify(async num => num * 2);
await fnB(2); // -> [4, null]
await golangify(Promise.reject(Error('err'))); // -> [undefined, Error]
await golangify(Promise.resolve(4)); // -> [4, null]
})();
创建 HTML 元素。
function h(
tag: string,
attrs?: types.PlainObj<any>,
...child: Array<string | HTMLElement>
): HTMLElement;
参数名 | 说明 |
---|---|
tag | 标签名 |
attrs | 属性 |
...child | 子节点 |
返回值 | 目标元素 |
const el = h(
'div#test.title',
{
onclick: function() {},
title: 'test'
},
'inner text'
);
document.body.appendChild(el);
检查属性是否是对象自身的属性(原型链上的不算)。
function has(obj: {}, key: string): boolean;
参数名 | 说明 |
---|---|
obj | 目标对象 |
key | 键名 |
返回值 | 如果是自身的属性,返回真 |
has({ one: 1 }, 'one'); // -> true
堆排序实现。
function heapSort(arr: any[], cmp?: types.AnyFn): any[];
参数名 | 说明 |
---|---|
arr | 要排序的数组 |
cmp | 比较器 |
返回值 | 有序数组 |
heapSort([2, 1]); // -> [1, 2]
hex 编解码。
const hex: {
encode(bytes: number[]): string;
decode(str: string): number[];
};
将字节数组编码为 hex 字符串。
参数名 | 说明 |
---|---|
bytes | 字节数组 |
返回值 | hex 编码的字符串 |
将 hex 字符串解码为字节数组。
参数名 | 说明 |
---|---|
str | hex 编码的字符串 |
返回值 | 字节数组 |
hex.encode([168, 174, 155, 255]); // -> 'a8ae9bff'
hex.decode('a8ae9bff'); // -> [168, 174, 155, 255]
高亮代码。
function highlight(
str: string,
lang?: string,
style?: {
comment?: string;
string?: string;
number?: string;
keyword?: string;
operator?: string;
}
): string;
参数名 | 说明 |
---|---|
str | 代码字符串 |
lang=js | 语言,js,html 或者 css |
style | 高亮样式 |
返回值 | 高亮后的 html 代码字符串 |
可设置样式:
comment,string,number,keyword,operator
highlight('const a = 5;', 'js', {
keyword: 'color:#569cd6;'
}); // -> '<span class="keyword" style="color:#569cd6;">const</span> a <span class="operator" style="color:#994500;">=</span> <span class="number" style="color:#0086b3;">5</span>;'
监听,修改函数参数和结果。
function hookFn<T>(
fn: T,
options: {
before?: types.AnyFn;
after?: types.AnyFn;
error?: types.AnyFn;
}
): T;
参数名 | 说明 |
---|---|
fn | 要监听修改的函数 |
options | 监听选项 |
返回值 | 包装后的函数 |
可用选项:
参数名 | 说明 |
---|---|
before | 参数处理函数 |
after | 结果处理函数 |
error | 异常处理函数 |
let sum = function(a, b) {
if (a > 100) {
throw Error('a is bigger than 100');
}
return a + b;
};
let totalSum = 0;
sum = hookFn(sum, {
before(a, b) {
return [+a, +b];
},
after(result) {
totalSum += result;
return totalSum;
},
error() {
return totalSum;
}
});
sum('2', '5'); // -> 7
监听键盘触发对应的事件。
namespace hotkey {
interface IOptions {
element?: HTMLElement;
}
}
const hotkey: {
on(key: string, options: hotkey.IOptions, listener: types.AnyFn): void;
on(key: string, listener: types.AnyFn): void;
off(key: string, options: hotkey.IOptions, listener: types.AnyFn): void;
off(key: string, listener: types.AnyFn): void;
};
注册键盘按键监听器。
参数名 | 说明 |
---|---|
key | 按键 |
options | 选项 |
listener | 监听器 |
选项:
参数名 | 说明 |
---|---|
element=document | 目标元素 |
注销监听器。
const container = document.getElementById('container');
hotkey.on(
'k',
{
element: container
},
function() {
console.log('k is pressed');
}
);
function keyDown() {}
hotkey.on('shift+a, shift+b', keyDown);
hotkey.off('shift+a', keyDown);
将 hsl 格式的颜色值转换为 rgb 格式。
function hslToRgb(hsl: number[]): number[];
参数名 | 说明 |
---|---|
hsl | hsl 值 |
返回值 | rgb 值 |
hslToRgb([165, 59, 50, 0.8]); // -> [52, 203, 165, 0.8]
HTML 解析器。
const html: {
parse(html: string): any[];
stringify(tree: any[]): string;
};
将 HTML 字符串转换为 js 对象。
参数名 | 说明 |
---|---|
html | HTML 字符串 |
返回值 | js 对象 |
将 js 对象序列化成 HTML 字符串。
参数名 | 说明 |
---|---|
tree | 要序列化的对象 |
返回值 | HTML 字符串 |
const tree = html.parse('<div id="name">licia</div>');
// -> [{tag: 'div', attrs: {id: 'name'}, content: ['licia']}]
html.stringify(tree);
返回传入的第一个参数。
function identity<T>(val: T): T;
参数名 | 说明 |
---|---|
val | 任何值 |
返回值 | 第一个参数 |
identity('a'); // -> 'a'
返回指定值第一次在数组中出现的位置。
function idxOf(arr: any[], val: any, fromIdx?: number): number;
参数名 | 说明 |
---|---|
arr | 目标数组 |
val | 要查找的值 |
fromIdx=0 | 查找起始位置 |
返回值 | 第一次出现的位置,如果没有,返回 -1 |
idxOf([1, 2, 1, 2], 2, 2); // -> 3
对文本的每一行进行缩进处理。
function indent(
str: string,
char?: string,
len?: number
): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
char | 缩进字符 |
len | 缩进长度 |
返回值 | 目标字符串 |
indent('foo\nbar', ' ', 4); // -> ' foo\n bar'
使构造函数继承另一个构造函数原型链上的方法。
function inherits(
Class: types.AnyFn,
SuperClass: types.AnyFn
): void;
参数名 | 说明 |
---|---|
Class | 子类 |
SuperClass | 父类 |
function People(name) {
this._name = name;
}
People.prototype = {
getName: function() {
return this._name;
}
};
function Student(name) {
this._name = name;
}
inherits(Student, People);
const s = new Student('RedHood');
s.getName(); // -> 'RedHood'
ini 文件解析器。
const ini: {
parse(ini: string): any;
stringify(
obj: any,
options?: {
section?: string;
whitespace: boolean;
}
): string;
};
将 ini 文件转换为 js 对象。
参数名 | 说明 |
---|---|
ini | ini 文件 |
返回值 | js 对象 |
将 js 对象序列化成 ini 文件格式。
参数名 | 说明 |
---|---|
obj | 要序列化的对象 |
options | 序列化选项 |
返回值 | ini 文件 |
选项:
参数名 | 说明 |
---|---|
section | 顶部名称 |
whitespace=false | 是否在 = 周围添加空格 |
const config = ini.parse(`
; This is a comment
library = licia
[user.info]
name = surunzi
alias[] = redhoodsu
alias[] = red
`); // -> {library: 'licia', user: {info: {name: 'surunzi', alias: ['redhoodsu', 'red']}}}
ini.stringify(config);
插入排序实现。
function insertionSort(arr: any[], cmp?: types.AnyFn): any[];
参数名 | 说明 |
---|---|
arr | 要排序的数组 |
cmp | 比较器 |
返回值 | 有序数组 |
insertionSort([2, 1]); // -> [1, 2]
计算所有数组的交集。
function intersect(...arr: Array<any[]>): any[];
参数名 | 说明 |
---|---|
...arr | 源数组 |
返回值 | 交集 |
intersect([1, 2, 3, 4], [2, 1, 10], [2, 1]); // -> [1, 2]
计算两个区间的交集。
namespace intersectRange {
interface IRange {
start: number;
end: number;
}
}
function intersectRange(
a: intersectRange.IRange,
b: intersectRange.IRange
): intersectRange.IRange | void;
参数名 | 说明 |
---|---|
a | 区间 a |
b | 区间 b |
返回值 | 如果存在区间交集,返回它 |
intersectRange({ start: 0, end: 12 }, { start: 11, end: 13 });
// -> {start: 11, end: 12}
intersectRange({ start: 0, end: 5 }, { start: 6, end: 7 });
// -> undefined
Facebook 的 invariant 模块。
function invariant(
condition: boolean,
format?: string,
a?: string,
b?: string,
c?: string,
d?: string,
e?: string,
f?: string
): void;
invariant(true, 'This will not throw');
// No errors
invariant(false, 'This will throw an error with this message');
// Error: Invariant Violation: This will throw an error with this message
生成一个新对象,该对象的键名和键值进行调换。
function invert(obj: any): any;
参数名 | 说明 |
---|---|
obj | 源对象 |
返回值 | 目标对象 |
如果对象存在重复的键值,后面的值会覆盖前面的值。
invert({ a: 'b', c: 'd', e: 'f' }); // -> {b: 'a', d: 'c', f: 'e'}
检查 url 是否是绝对地址。
function isAbsoluteUrl(url: string): boolean;
参数名 | 说明 |
---|---|
url | 目标 url |
返回值 | 如果是绝对地址,返回真 |
isAbsoluteUrl('http://www.surunzi.com'); // -> true
isAbsoluteUrl('//www.surunzi.com'); // -> false
isAbsoluteUrl('surunzi.com'); // -> false
检查值是否是参数类型。
function isArgs(val: any): val is IArguments;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是参数类型,返回真 |
isArgs(
(function() {
return arguments;
})()
); // -> true
检查值是否是数组类型。
function isArr(val: any): val is any[];
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是数组类型,返回真 |
isArr([]); // -> true
isArr({}); // -> false
检查值是否是 ArrayBuffer 类型。
function isArrBuffer(val: any): val is ArrayBuffer;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 ArrayBuffer 类型,返回真 |
isArrBuffer(new ArrayBuffer(8)); // -> true
检查值是否是类数组对象。
function isArrLike(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是类数组对象,返回真 |
对于函数,返回假。
isArrLike('test'); // -> true
isArrLike(document.body.children); // -> true;
isArrLike([1, 2, 3]); // -> true
检查值是否是 Async 函数。
function isAsyncFn(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Async 函数,返回真 |
isAsyncFn(function*() {}); // -> false
isAsyncFn(function() {}); // -> false
isAsyncFn(async function() {}); // -> true
检查值是否是 Blob 类型。
function isBlob(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Blob 类型,返回真 |
isBlob(new Blob([])); // -> true;
isBlob([]); // -> false
检查值是否是布尔类型。
function isBool(val: any): val is boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是布尔类型,返回真 |
isBool(true); // -> true
isBool(false); // -> true
isBool(1); // -> false
检测是否运行于浏览器环境。
const isBrowser: boolean;
console.log(isBrowser); // -> true if running in a browser
检查值是否是 Buffer 类型。
function isBuffer(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Buffer 类型,返回真 |
isBuffer(new Buffer(4)); // -> true
检查两个数字是否近似相等。
function isClose(
a: number,
b: number,
relTol?: number,
absTol?: number
): boolean;
abs(a-b) <= max(relTol * max(abs(a), abs(b)), absTol)
参数名 | 说明 |
---|---|
a | 要比较的数字 |
b | 要比较的数字 |
relTol=1e-9 | 相对误差 |
absTol=0 | 绝对误差 |
返回值 | 如果近似相等,返回真 |
isClose(1, 1.0000000001); // -> true
isClose(1, 2); // -> false
isClose(1, 1.2, 0.3); // -> true
isClose(1, 1.2, 0.1, 0.3); // -> true
检查值是否存在循环引用。
function isCyclic(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果存在循环引用,返回真 |
isCyclic({}); // -> false
const obj = { a: 1 };
obj.b = obj;
isCyclic(obj); // -> true
检测是否暗黑模式。
function isDarkMode(): boolean;
console.log(isDarkMode()); // true if dark mode
检查字符串是否是有效的 Data Url。
function isDataUrl(str: string): boolean;
参数名 | 说明 |
---|---|
str | 要检查的字符串 |
返回值 | 如果是有效的 Data Url,返回真 |
isDataUrl('http://eustia.liriliri.io'); // -> false
isDataUrl('data:text/plain;base64,SGVsbG8sIFdvcmxkIQ%3D%3D'); // -> true
检查值是否是 Date 类型。
function isDate(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Date 类型,返回真 |
isDate(new Date()); // -> true
检查路径是否是文件夹。
function isDir(path: string): Promise<boolean>;
参数名 | 说明 |
---|---|
path | 要检查的路径 |
返回值 | 如果是文件夹,返回真 |
isDir('/foo/bar');
检测进程是否运行在 docker 容器内。
function isDocker(): boolean;
console.log(isDocker()); // -> true if running inside a docker container.
检查值是否是 DOM 元素。
function isEl(val: any): val is Element;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 DOM 元素,返回真 |
isEl(document.body); // -> true
简单检查值是否是合法的邮件地址。
function isEmail(val: string): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是合法的邮件地址,返回真 |
isEmail('[email protected]'); // -> true
检查值是否是空对象或空数组。
function isEmpty(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果为空,返回真 |
isEmpty([]); // -> true
isEmpty({}); // -> true
isEmpty(''); // -> true
对两个对象进行深度比较,如果相等,返回真。
function isEqual(val: any, other: any): boolean;
参数名 | 说明 |
---|---|
val | 要比较的对象 |
other | 要比较的对象 |
返回值 | 如果相等,返回真 |
isEqual([1, 2, 3], [1, 2, 3]); // -> true
检查值是否是 Error 类型。
function isErr(val: any): val is Error;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Error 类型,返回真 |
isErr(new Error()); // -> true
检查数字是否是偶数。
function isEven(num: number): boolean;
参数名 | 说明 |
---|---|
num | 要检查的数字 |
返回值 | 如果是偶数,返回真 |
isEven(0); // -> true
isEven(1); // -> false
isEven(2); // -> true
检查值是否是 File 类型。
function isFile(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 File 类型,返回真 |
isFile(new File(['test'], 'test.txt', { type: 'text/plain' })); // -> true
检查值是否是有限数字。
function isFinite(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是有限数字,返回真 |
isFinite(3); // -> true
isFinite(Infinity); // -> false
检查值是否是函数。
function isFn(val: any): val is Function;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是函数,返回真 |
Generator 函数返回真。
isFn(function() {}); // -> true
isFn(function*() {}); // -> true
isFn(async function() {}); // -> true
检查值是否是全角字符。
function isFullWidth(codePoint: number): boolean;
参数名 | 说明 |
---|---|
codePoint | Unicode 码点 |
返回值 | 如果字符是全角,返回真 |
isFullWidth('a'.codePointAt(0)); // -> false
isFullWidth(','.codePointAt(0)); // -> false
isFullWidth('我'.codePointAt(0)); // -> true
isFullWidth(','.codePointAt(0)); // -> true
检查值是否是 Generator 函数。
function isGeneratorFn(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Generator 函数,返回真 |
isGeneratorFn(function*() {}); // -> true
isGeneratorFn(function() {}); // -> false
检查元素是否隐藏。
function isHidden(
el: Element,
options?: {
display?: boolean;
visibility?: boolean;
opacity?: boolean;
size?: boolean;
viewport?: boolean;
overflow?: boolean;
}
): boolean;
参数名 | 说明 |
---|---|
el | 目标元素 |
options | 检查选项 |
返回值 | 如果元素隐藏,返回真 |
可用选项:
参数名 | 说明 |
---|---|
display=true | 检查是否显示 |
visibility=false | 检查 visibility css 属性 |
opacity=false | 检查 opacity css 属性 |
size=false | 检查宽高 |
viewport=false | 检查是否在可视区域 |
overflow=false | 检查是否因 overflow 隐藏 |
isHidden(document.createElement('div')); // -> true
检查值是否是整数。
function isInt(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是整数,返回真 |
isInt(5); // -> true
isInt(5.1); // -> false
isInt({}); // -> false
检查值是否是 IP 地址。
namespace isIp {
function v4(str: string): boolean;
function v6(str: string): boolean;
}
function isIp(str: string): boolean;
参数名 | 说明 |
---|---|
str | 要检查的字符串 |
返回值 | 如果是 IP 地址,返回真 |
检查值是否是 IPv4 地址。
检查值是否是 IPv6 地址。
isIp('192.168.191.1'); // -> true
isIp('1:2:3:4:5:6:7:8'); // -> true
isIp('test'); // -> false
isIp.v4('192.168.191.1'); // -> true
isIp.v6('1:2:3:4:5:6:7:8'); // -> true
检查值是否是有效的 JSON。
function isJson(val: string): boolean;
该模块使用 JSON.parse()
和 try... catch
进行检测。
参数名 | 说明 |
---|---|
val | JSON 字符串 |
返回值 | 如果是有效的 JSON,返回真 |
isJson('{"a": 5}'); // -> true
isJson("{'a': 5}"); // -> false
检查年份是否是闰年。
function isLeapYear(year: number): boolean;
参数名 | 说明 |
---|---|
year | 要检查的年份 |
返回值 | 如果是闰年,返回真 |
isLeapYear(2000); // -> true
isLeapYear(2002); // -> false
检测是否运行在 mac 操作系统上。
const isMac: boolean;
console.log(isMac); // -> true if running on mac
检查值是否是 Map 对象。
function isMap(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Map 类型,返回真 |
isMap(new Map()); // -> true
isMap(new WeakMap()); // -> false
检查对象所有键名和键值是否在指定的对象中。
function isMatch(obj: any, src: any): boolean;
参数名 | 说明 |
---|---|
obj | 目标对象 |
src | 进行匹配的对象 |
返回值 | 如果匹配,返回真 |
isMatch({ a: 1, b: 2 }, { a: 1 }); // -> true
检测是否运行于微信小程序环境中。
const isMiniProgram: boolean;
console.log(isMiniProgram); // -> true if running in mini program.
使用 ua 检测是否运行于移动端浏览器。
function isMobile(ua?: string): boolean;
参数名 | 说明 |
---|---|
ua=navigator.userAgent | 浏览器用户代理 |
返回值 | 如果是移动端浏览器,返回真 |
isMobile(navigator.userAgent);
检测值是否是 NaN。
function isNaN(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 NaN,返回真 |
跟全局 isNaN 不同的是,Undefined 不是 NaN。
isNaN(0); // -> false
isNaN(NaN); // -> true
检查值是否是原生函数。
function isNative(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是原生函数,返回真 |
isNative(function() {}); // -> false
isNative(Math.min); // -> true
检查值是否是 null 或 undefined,等价于 value == null。
function isNil(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 null 或 undefined,返回真 |
isNil(null); // -> true
isNil(void 0); // -> true
isNil(undefined); // -> true
isNil(false); // -> false
isNil(0); // -> false
isNil([]); // -> false
检测是否运行于 node 环境中。
const isNode: boolean;
console.log(isNode); // -> true if running in node
检查值是否是 Null 类型。
function isNull(val: any): val is null;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Null 类型,返回真 |
isNull(null); // -> true
检测值是否是数字类型。
function isNum(val: any): val is number;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是数字,返回真 |
isNum(5); // -> true
isNum(5.1); // -> true
isNum({}); // -> false
检查值是否是数字,包括数字字符串。
function isNumeric(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是数字,返回真 |
isNumeric(1); // -> true
isNumeric('1'); // -> true
isNumeric(Number.MAX_VALUE); // -> true
isNumeric(0xff); // -> true
isNumeric(''); // -> false
isNumeric('1.1.1'); // -> false
isNumeric(NaN); // -> false
检查值是否是对象。
function isObj(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是对象,返回真 |
isObj({}); // -> true
isObj([]); // -> true
检查数字是否是奇数。
function isOdd(num: number): boolean;
参数名 | 说明 |
---|---|
num | 要检查的数字 |
返回值 | 如果是奇数,返回真 |
isOdd(0); // -> false
isOdd(1); // -> true
isOdd(2); // -> false
检查值是否是用 Object 构造函数创建的对象。
function isPlainObj(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 plain object,返回真 |
isPlainObj({}); // -> true
isPlainObj([]); // -> false
isPlainObj(function() {}); // -> false
检查 TCP 端口是否可用。
function isPortFree(
port: number,
host?: string
): Promise<boolean>;
参数名 | 说明 |
---|---|
port | TCP 端口 |
host | 地址 |
返回值 | 如果端口可用,返回真 |
isPortFree(3000).then(isFree => {
// Do something.
});
检查整数是否是质数。
function isPrime(num: number): boolean;
参数名 | 说明 |
---|---|
num | 要检查的数字 |
返回值 | 如果是质数,返回真 |
isPrime(11); // -> true
isPrime(8); // -> false
检测值是否是字符串,数字,布尔值或 null。
function isPrimitive(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是原始类型,返回真 |
isPrimitive(5); // -> true
isPrimitive('abc'); // -> true
isPrimitive(false); // -> true
检查值是否是类 promise 对象。
function isPromise(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是类 promise 对象,返回真 |
isPromise(new Promise(function() {})); // -> true
isPromise({}); // -> false
检查值是否是正则类型。
function isRegExp(val: any): val is RegExp;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是正则类型,返回真 |
isRegExp(/a/); // -> true
检查路径是否是相对路径。
function isRelative(path: string): boolean;
参数名 | 说明 |
---|---|
path | 要检查的路径 |
返回值 | 如果是相对路径,返回真 |
isRelative('README.md'); // -> true
判断是否运行在 retina 屏幕的设备上。
const isRetina: boolean;
console.log(isRetina); // -> true if high DPR
检查进程是否运行中。
function isRunning(pid: number): boolean;
参数名 | 说明 |
---|---|
pid | 进程 id |
返回值 | 如果进程运行中,返回真 |
isRunning(123456); // true if running
检查值是否是 Set 类型。
function isSet(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Set 类型,返回真 |
isSet(new Set()); // -> true
isSet(new WeakSet()); // -> false
检查值是否是 ShadowRoot 对象。
function isShadowRoot(val: any): val is ShadowRoot;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 ShadowRoot,返回真 |
isShadowRoot(document.body); // -> false
检查数组是否有序。
function isSorted(arr: any[], cmp?: types.AnyFn): boolean;
参数名 | 说明 |
---|---|
arr | 目标数组 |
cmp | 比较器 |
返回值 | 如果数组有序,返回真 |
isSorted([1, 2, 3]); // -> true
isSorted([3, 2, 1]); // -> false
检查值是否是字符串。
function isStr(val: any): val is string;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是字符串,返回真 |
isStr('licia'); // -> true
检查字符串是否为空。
function isStrBlank(str: string): boolean;
参数名 | 说明 |
---|---|
str | 要检查的字符串 |
返回值 | 如果字符串为空,返回真 |
isStrBlank('licia'); // -> false
isStrBlank(''); // -> true
isStrBlank(' '); // -> true
isStrBlank('\r\n '); // -> true
检查值是否是 Node.js Stream 类型。
function isStream(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Node.js Stream 类型,返回真 |
const stream = require('stream');
isStream(new stream.Stream()); // -> true
检查值是否是 Symbol 类型。
function isSymbol(val: any): val is symbol;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 Symbol 类型,返回真 |
isSymbol(Symbol('test')); // -> true
检查值是否 TypedArray 类型。
function isTypedArr(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果值是 TypedArray 类型,返回真 |
isTypedArr([]); // -> false
isTypedArr(new Uint8Array(8)); // -> true
检查值是否是 undefined。
function isUndef(val: any): val is undefined;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 undefined,返回真 |
isUndef(void 0); // -> true
isUndef(null); // -> false
简单检查值是否是有效的 url 地址。
function isUrl(val: string): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是有效的 url 地址,返回真 |
isUrl('http://www.example.com?foo=bar¶m=test'); // -> true
检查值是否是 WeakMap 类型。
function isWeakMap(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 WeakMap 类型,返回真 |
isWeakMap(new Map()); // -> false
isWeakMap(new WeakMap()); // -> true
检查值是否是 WeakSet 类型。
function isWeakSet(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要检查的值 |
返回值 | 如果是 WeakSet 类型,返回真 |
isWeakSet(new Set()); // -> false
isWeakSet(new WeakSet()); // -> true
检测是否运行在 windows 操作系统上。
const isWindows: boolean;
console.log(isWindows); // -> true if running on windows
使用 JSON parse 和 stringify 方法对指定对象进行复制。
function jsonClone<T>(val: T): T;
参数名 | 说明 |
---|---|
val | 要克隆的值 |
返回值 | 克隆值 |
jsonClone({ name: 'licia' }); // -> { name: 'licia' }
简单 jsonp 实现。
function jsonp(options: {
url: string;
data?: any;
success?: types.AnyFn;
param?: string;
name?: string;
error?: types.AnyFn;
complete?: types.AnyFn;
timeout?: number;
}): void;
参数名 | 说明 |
---|---|
options | jsonp 选项 |
可用选项:
参数名 | 说明 |
---|---|
url | 请求地址 |
data | 请求数据 |
success | 成功回调 |
param=callback | 回调参数名 |
name | 回调函数名 |
error | 失败回调 |
complete | 结束回调 |
timeout | 请求超时 |
jsonp({
url: 'http://example.com',
data: { test: 'true' },
success: function(data) {
// ...
}
});
将字符串转换为短横线式。
function kebabCase(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 短横线式字符串 |
kebabCase('fooBar'); // -> foo-bar
kebabCase('foo bar'); // -> foo-bar
kebabCase('foo_bar'); // -> foo-bar
kebabCase('foo.bar'); // -> foo-bar
键码键名转换。
function keyCode(name: string): number;
function keyCode(code: number): string;
获取键码对应的键名。
参数名 | 说明 |
---|---|
code | 键码 |
返回值 | 对应的键名 |
获取键名对应的键码。
参数名 | 说明 |
---|---|
name | 键名 |
返回值 | 对应的键码 |
keyCode(13); // -> 'enter'
keyCode('enter'); // -> 13
返回包含对象自身可遍历所有键名的数组。
function keys(obj: any): string[];
参数名 | 说明 |
---|---|
obj | 目标对象 |
返回值 | 所有键名 |
keys({ a: 1 }); // -> ['a']
杀死进程。
function kill(pid: number): void;
参数名 | 说明 |
---|---|
pid | 进程 ID |
kill(9420);
获取数组的最后一个元素。
function last(arr: any[]): any;
参数名 | 说明 |
---|---|
arr | 目标数组 |
返回值 | 数组的最后一个元素 |
last([1, 2]); // -> 2
模块懒加载,底层使用 Proxy。
function lazyImport<T>(
importFn: (moduleId: string) => T,
dirname?: string
): (moduleId: string) => T;
参数名 | 说明 |
---|---|
importFn | 实际引入模块的方法 |
dirname | 当前脚本所在目录 |
返回值 | 用于引入模块的新方法 |
const r = lazyImport(require);
const _ = r('underscore');
_.isNumber(5);
模块懒加载。
function lazyRequire<T>(
requireFn: (moduleId: string) => T
): (moduleId: string) => T;
const r = lazyRequire(require);
const _ = r('underscore');
// underscore is required only when _ is called.
_().isNumber(5);
计算字符串编辑距离,使用 levenshtein 算法。
function levenshtein(a: string, b: string): number;
参数名 | 说明 |
---|---|
a | 字符串 a |
b | 字符串 b |
返回值 | a 和 b 的字符串编辑距离 |
levenshtein('cat', 'cake'); // -> 2
将文本中的 url 地址转换为超链接。
function linkify(str: string, hyperlink?: types.AnyFn): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
hyperlink | 转换超链接函数 |
返回值 | 目标字符串 |
const str = 'Official site: http://eustia.liriliri.io';
linkify(str); // -> 'Official site: <a href="http://eustia.liriliri.io">http://eustia.liriliri.io</a>'
linkify(str, function(url) {
return '<a href="' + url + '" target="_blank">' + url + '</a>';
});
往页面插入样式链接。
function loadCss(src: string, cb?: types.AnyFn): void;
参数名 | 说明 |
---|---|
src | 样式文件地址 |
cb | 加载完回调 |
loadCss('style.css', function(isLoaded) {
// Do something...
});
加载指定地址的图片。
function loadImg(src: string, cb?: types.AnyFn): void;
参数名 | 说明 |
---|---|
src | 图片地址 |
cb | 加载完回调 |
loadImg('http://eustia.liriliri.io/img.jpg', function(err, img) {
console.log(img.width, img.height);
});
往页面插入脚本链接。
function loadJs(src: string, cb?: types.AnyFn): void;
参数名 | 说明 |
---|---|
src | 脚本地址 |
cb | 加载完回调 |
loadJs('main.js', function(isLoaded) {
// Do something...
});
获取数组中最长的一项。
function longest(arr: string[]): string;
参数名 | 说明 |
---|---|
arr | 目标数组 |
返回值 | 最长的一项 |
longest(['a', 'abcde', 'abc']); // -> 'abcde'
转换字符串为小写。
function lowerCase(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
lowerCase('TEST'); // -> 'test'
对字符串进行左填充。
function lpad(str: string, len: number, chars?: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
len | 填充长度 |
chars | 填充字符串 |
返回值 | 目标字符串 |
lpad('a', 5); // -> ' a'
lpad('a', 5, '-'); // -> '----a'
lpad('abc', 3, '-'); // -> 'abc'
lpad('abc', 5, 'ab'); // -> 'ababc'
删除字符串头部指定字符或空格。
function ltrim(str: string, chars?: string | string[]): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
chars | 删除字符 |
返回值 | 目标字符串 |
ltrim(' abc '); // -> 'abc '
ltrim('_abc_', '_'); // -> 'abc_'
ltrim('_abc_', ['a', '_']); // -> 'bc_'
对集合的每个元素调用转换函数生成与之对应的数组。
function map<T, TResult>(
list: types.List<T>,
iterator: types.ListIterator<T, TResult>,
context?: any
): TResult[];
function map<T, TResult>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, TResult>,
context?: any
): TResult[];
参数名 | 说明 |
---|---|
object | 源集合 |
iterator | 转换函数 |
context | 函数上下文 |
返回值 | 目标集合 |
map([4, 8], function(n) {
return n * n;
}); // -> [16, 64]
类似 map,但针对对象,生成一个新对象。
function mapObj<T, TResult>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, TResult>,
context?: any
): types.Dictionary<TResult>;
参数名 | 说明 |
---|---|
object | 源对象 |
iterator | 转换函数 |
context | 函数上下文 |
返回值 | 目标对象 |
mapObj({ a: 1, b: 2 }, function(val, key) {
return val + 1;
}); // -> {a: 2, b: 3}
传入对象返回函数,如果传入参数中包含该对象则返回真。
function matcher(attrs: any): types.AnyFn;
参数名 | 说明 |
---|---|
attrs | 要匹配的对象 |
返回值 | 真值检测函数 |
const filter = require('licia/filter');
const objects = [
{ a: 1, b: 2, c: 3 },
{ a: 4, b: 5, c: 6 }
];
filter(objects, matcher({ a: 4, c: 6 })); // -> [{a: 4, b: 5, c: 6}]
获取数字中的最大值。
function max(...num: number[]): number;
参数名 | 说明 |
---|---|
...num | 要计算的数字 |
返回值 | 最大值 |
max(2.3, 1, 4.5, 2); // 4.5
MD5 算法实现。
function md5(msg: string | number[]): string;
参数名 | 说明 |
---|---|
msg | 密文 |
返回值 | MD5 摘要 |
md5('licia'); // -> 'e59f337d85e9a467f1783fab282a41d0'
Web Storage 接口的纯内存实现。
const memStorage: typeof window.localStorage;
当 localStorage 或者 sessionStorage 无法使用时可以使用其作为替代。
const localStorage = window.localStorage || memStorage;
localStorage.setItem('test', 'licia');
缓存函数计算结果。
function memoize(
fn: types.AnyFn,
hashFn?: types.AnyFn
): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 源函数 |
hashFn | 计算缓存键名函数 |
返回值 | 目标函数 |
const fibonacci = memoize(function(n) {
return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
});
将数组合并到第一个数组里。
function mergeArr<T, U>(
first: ArrayLike<T>,
...arrays: ArrayLike<U>[]
): ArrayLike<T | U>;
参数名 | 说明 |
---|---|
first | 要修改的数组 |
arrays | 合并到第一个数组的数组 |
返回值 | 第一个数组 |
const a = [1, 2];
mergeArr(a, [3, 4], [5, 6]);
console.log(a); // -> [1, 2, 3, 4, 5, 6]
归并排序实现。
function mergeSort(arr: any[], cmp?: types.AnyFn): any[];
注意:它不改变原数组。
参数名 | 说明 |
---|---|
arr | 要排序的数组 |
cmp | 比较器 |
返回值 | 有序数组 |
mergeSort([2, 1]); // -> [1, 2]
meta 操作库,将 name 和 content 属性值转换为键值对。
namespace meta {
function remove(nameList: string | string[]): void;
}
function meta(): {};
function meta(key: string): string;
function meta(keys: string[]): {};
function meta(key, value): void;
function meta(pairs: {}): void;
获取指定 meta 值。如果忽略 meta 名,所有的 meta 键值对都被返回。
参数名 | 说明 |
---|---|
name | meta 名 |
返回值 | meta 值 |
设置 meta 值。
参数名 | 说明 |
---|---|
name | meta 名 |
content | meta 值 |
参数名 | 说明 |
---|---|
metas | 包含所有 meta 键值对的对象 |
移除指定 meta。
参数名 | 说明 |
---|---|
name | meta 名 |
// <meta name="a" content="1"/> <meta name="b" content="2"/> <meta name="c" content="3"/>
meta(); // -> {a: '1', b: '2', c: '3'}
meta('a'); // -> '1'
meta(['a', 'c']); // -> {a: '1', c: '3'}
meta('d', '4');
meta({
d: '5',
e: '6',
f: '7'
});
meta.remove('d');
meta.remove(['e', 'f']);
获取对象中所有方法名。
function methods(obj: any): string[];
参数名 | 说明 |
---|---|
obj | 目标对象 |
返回值 | 方法名列表 |
methods(console); // -> ['Console', 'assert', 'dir', ...]
常用 mime 类型。
function mime(name: string): string | undefined;
参数名 | 说明 |
---|---|
name | 扩展名 |
返回值 | mime 类型 |
参数名 | 说明 |
---|---|
name | mime 类型 |
返回值 | 扩展名 |
该模块只包含常用的文件类型。
mime('jpg'); // -> 'image/jpeg'
mime('bmp'); // -> 'image/bmp'
mime('video/mp4'); // -> 'mp4'
mime('test'); // -> undefined
获取数字中的最小值。
function min(...num: number[]): number;
参数名 | 说明 |
---|---|
...num | 要计算的数字 |
返回值 | 最小值 |
min(2.3, 1, 4.5, 2); // 1
递归地创建文件夹。
namespace mkdir {
function sync(dir: string, mode?: number): void;
}
function mkdir(
dir: string,
mode?: number,
cb?: types.AnyFn
): void;
function mkdir(dir: string, cb?: types.AnyFn): void;
参数名 | 说明 |
---|---|
dir | 文件夹路径 |
mode=0777 | 文件夹模式 |
cb | 回调 |
同步版本。
mkdir('/tmp/foo/bar/baz', function(err) {
if (err) console.log(err);
else console.log('Done');
});
mkdir.sync('/tmp/foo2/bar/baz');
简单的类 moment.js 实现。
namespace moment {
class M {
constructor(value: string | Date);
format(mask: string): string;
isValid(): boolean;
isLeapYear(): boolean;
isSame(that: M): boolean;
valueOf(): number;
isBefore(that: M): boolean;
isAfter(that: M): boolean;
year(): number;
year(number): M;
month(): number;
month(number): M;
date(): number;
date(number): M;
hour(): number;
hour(number): M;
minute(): number;
minute(number): M;
second(): number;
second(number): M;
millisecond(): number;
millisecond(number): M;
unix(): number;
clone(): M;
toDate(): Date;
toArray(): number[];
toJSON(): string;
toISOString(): string;
toObject(): any;
toString(): string;
set(unit: string, num: number): M;
startOf(unit: string): M;
endOf(unit: string): M;
daysInMonth(): number;
add(num: number, unit: string): M;
subtract(num: number, unit: string): M;
diff(input: M | string | Date, unit: string, asFloat: boolean): number;
}
}
function moment(value: string | Date): moment.M;
它只支持一小部分的 moment.js api。
format,isValid,isLeapYear,isSame,isBefore,isAfter,year, month,date,hour,minute,second,millisecond,unix,clone, toDate,toArray,toJSON,toISOString,toObject,toString,set, startOf,endOf,add,subtract,diff
时区以及 quarter 和 week 单位。
注意:格式化功能使用 dateFormat 模块,所以掩码格式并不完全与 moment.js 一致。
moment('20180501').format('yyyy-mm-dd'); // -> '2018-05-01'
将 DOM 树变化成目标 DOM 树。
function morphDom(from: Node, to: Node | string): Node;
参数名 | 说明 |
---|---|
from | 原始 DOM 树 |
to | 要变化的 DOM 树 |
返回值 | 变化后的 DOM 树 |
const el1 = document.createElement('div');
el1.className = 'test';
const el2 = document.createElement('div');
el2.className = 'licia';
morphDom(el1, el2);
console.log(el1.className); // -> 'licia'
摩尔斯电码编解码。
const morse: {
encode(txt: string): string;
decode(morse: string): string;
};
将文本转换为摩尔斯电码。
参数名 | 说明 |
---|---|
txt | 要编码的文本 |
返回值 | 摩尔斯电码 |
将摩尔斯电码转换为文本。
参数名 | 说明 |
---|---|
morse | 摩尔斯电码 |
返回值 | 解码后的文本 |
const str = morse.encode('Hello, world.');
// -> '.... . .-.. .-.. --- --..-- ....... .-- --- .-. .-.. -.. .-.-.-'
morse.decode(str); // -> 'Hello, world.'
时长字符串与毫秒转换库。
function ms(str: string): number;
function ms(num: number): string;
转换时长字符串为毫秒。
参数名 | 说明 |
---|---|
str | 字符串格式 |
返回值 | 毫秒 |
转换毫秒为时长字符串。
参数名 | 说明 |
---|---|
num | 毫秒 |
返回值 | 字符串格式 |
ms('1s'); // -> 1000
ms('1m'); // -> 60000
ms('1.5h'); // -> 5400000
ms('1d'); // -> 86400000
ms('1y'); // -> 31557600000
ms('1000'); // -> 1000
ms(1500); // -> '1.5s'
ms(60000); // -> '1m'
以自然顺序排序数组。
namespace naturalSort {
interface INaturalSort {
<T extends any[]>(arr: T): T;
comparator(a: any, b: any): number;
}
}
const naturalSort: naturalSort.INaturalSort;
参数名 | 说明 |
---|---|
arr | 要排序的数组 |
返回值 | 有序数组 |
naturalSort(['img12', 'img11', '$img', '_img', '1', '2', '12']);
// -> ['1', '2', '12', '$img', 'img11', 'img12', '_img']
naturalSort([2, '1', 13]); // -> ['1', 2, 13]
创建一个将原函数结果取反的函数。
function negate<T extends types.AnyFn>(predicate: T): T;
参数名 | 说明 |
---|---|
predicate | 源函数 |
返回值 | 目标函数 |
function even(n) {
return n % 2 === 0;
}
[1, 2, 3, 4, 5, 6].filter(negate(even)); // -> [1, 3, 5]
能够同时运行在 node 和浏览器端的 next tick 实现。
function nextTick(cb: types.AnyFn): void;
参数名 | 说明 |
---|---|
cb | 调用函数 |
如果支持 process.nextTick,则调用它,否则使用 setImmediate 或 setTimeout 进行兼容。
nextTick(function() {
// Do something...
});
一个什么也不做的空函数。
function noop(): void;
noop(); // Does nothing
标准化 HTTP 头部名。
function normalizeHeader(header: string): string;
参数名 | 说明 |
---|---|
header | 源头部名 |
返回值 | 目标头部名 |
normalizeHeader('content-type'); // -> 'Content-Type'
normalizeHeader('etag'); // -> 'ETag'
标准化文件路径中的斜杠。
function normalizePath(path: string): string;
参数名 | 说明 |
---|---|
path | 源路径 |
返回值 | 目标路径 |
normalizePath('\\foo\\bar\\'); // -> '/foo/bar/'
normalizePath('./foo//bar'); // -> './foo/bar'
标准化电话号码为 E.164 格式。
function normalizePhone(
phone: string,
options: {
countryCode: number;
trunkPrefix?: boolean;
}
): string;
参数名 | 说明 |
---|---|
phone | 电话号码 |
options | 标准化选项 |
返回值 | E.164 格式电话号码 |
可用选项:
参数名 | 说明 |
---|---|
countryCode | 国家代码 |
trunkPrefix=false | 如果本地格式有长途字冠,设为真 |
normalizePhone('13512345678', {
countryCode: 86
}); // -> '+8613512345678'
normalizePhone('(415) 555-2671', {
countryCode: 1
}); // -> '+14155552671'
normalizePhone('020 7183 8750', {
countryCode: 44,
trunkPrefix: true
}); // -> '+442071838750'
Web Notifications 接口简单包装。
namespace notify {
class Notification extends Emitter {
constructor(title: string, options?: object);
show(): void;
}
}
function notify(title: string, options?: object): void;
参数名 | 说明 |
---|---|
title | 通知标题 |
options | 通知选项 |
你可以传入所有在 Web Notification 中支持的选项。
如果你想要监听并处理像 close,show,click 或者 error 等事件,使用这个类创建实例。
notify('licia', {
body: 'This is the notification content'
});
const notification = new notify.Notification('licia', {
body: 'This is the notification content'
});
notification.on('error', err => console.log(err));
notification.on('click', e => console.log(e));
notification.show();
获取当前时间戳。
function now(): number;
now(); // -> 1468826678701
Object.prototype.toString 的别名。
function objToStr(val: any): string;
参数名 | 说明 |
---|---|
val | 目标值 |
返回值 | 字符串表示 |
objToStr(5); // -> '[object Number]'
类似 pick,但结果相反。
function omit(
obj: any,
filter: string | string[] | Function
): any;
参数名 | 说明 |
---|---|
obj | 源对象 |
filter | 对象过滤器 |
返回值 | 目标对象 |
omit({ a: 1, b: 2 }, 'a'); // -> {b: 2}
omit({ a: 1, b: 2, c: 3 }, ['b', 'c']); // -> {a: 1}
omit({ a: 1, b: 2, c: 3, d: 4 }, function(val, key) {
return val % 2;
}); // -> {b: 2, d: 4}
创建只能调用一次的函数。
function once(fn: types.AnyFn): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 源函数 |
返回值 | 目标函数 |
function init() {}
const initOnce = once(init);
initOnce();
initOnce(); // -> init is invoked once
打开 url 地址或文件。
function open(target: string): any;
参数名 | 说明 |
---|---|
target | 要打开的目标 |
返回值 | 子进程对象 |
open('https://eustia.liriliri.io/');
在浏览器中打开文件选择框。
function openFile(options?: {
accept?: string;
multiple?: boolean;
}): Promise<File[]>;
参数名 | 说明 |
---|---|
options | 选项 |
返回值 | 文件列表 |
可用选项:
参数名 | 说明 |
---|---|
accept | 文件类型 |
multiple=false | 是否支持多选 |
openFile({ multiple: true }).then(fileList => {
console.log(fileList);
});
用于高效的函数上下文绑定。
function optimizeCb(
fn: types.AnyFn,
ctx: any,
argCount?: number
): types.AnyFn;
转换数字为序数形式。
function ordinal(num: number): string;
参数名 | 说明 |
---|---|
num | 要转换的数字 |
返回值 | 目标序数 |
ordinal(1); // -> '1st'
ordinal(2); // -> '2nd'
屏幕方向工具库。
namespace orientation {
interface IOrientation extends Emitter {
get(): string;
}
}
const orientation: orientation.IOrientation;
绑定 change 事件。
解绑 change 事件。
获取当前屏幕方向(横屏 landscape 或 竖屏 portrait)。
orientation.on('change', function(direction) {
console.log(direction); // -> 'portrait'
});
orientation.get(); // -> 'landscape'
对字符串进行左右填充。
function pad(str: string, len: number, chars?: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
len | 填充长度 |
chars | 填充字符串 |
返回值 | 目标字符串 |
pad('a', 5); // -> ' a '
pad('a', 5, '-'); // -> '--a--'
pad('abc', 3, '-'); // -> 'abc'
pad('abc', 5, 'ab'); // -> 'babca'
pad('ab', 5, 'ab'); // -> 'ababa'
将对象转换为包含【键名,键值】对的数组。
function pairs(obj: any): Array<any[]>;
参数名 | 说明 |
---|---|
obj | 目标对象 |
返回值 | 键值对数组 |
pairs({ a: 1, b: 2 }); // -> [['a', 1], ['b', 2]]
同时执行多个函数。
function parallel(tasks: types.AnyFn[], cb?: types.AnyFn): void;
参数名 | 说明 |
---|---|
tasks | 函数数组 |
cb | 结束回调 |
parallel(
[
function(cb) {
setTimeout(function() {
cb(null, 'one');
}, 200);
},
function(cb) {
setTimeout(function() {
cb(null, 'two');
}, 100);
}
],
function(err, results) {
// results -> ['one', 'two']
}
);
命令行参数简单解析。
function parseArgs(
args: string[],
options: {
names: any;
shorthands: any;
}
): any;
参数名 | 说明 |
---|---|
args | 参数数组 |
options | 解析选项 |
返回值 | 解析结果 |
选项名 | 说明 |
---|---|
names | 选项名及类型 |
shorthands | 选项名缩写 |
parseArgs(['eustia', '--output', 'util.js', '-w'], {
names: {
output: 'string',
watch: 'boolean'
},
shorthands: {
output: 'o',
watch: 'w'
}
});
// -> {remain: ['eustia'], output: 'util.js', watch: true}
HTML 解析器。
function parseHtml(
html: string,
handlers: {
start?: (tag: string, attrs: any, unary: boolean) => void;
end?: (tag: string) => void;
comment?: (text: string) => void;
text?: (text: string) => void;
}
): void;
参数名 | 说明 |
---|---|
html | 要解析的 HTML |
handler | 处理函数 |
parseHtml('<div>licia</div>', {
start: (tag, attrs, unary) => {},
end: tag => {},
comment: text => {},
text: text => {}
});
返回局部填充参数的函数,与 bind 模块相似。
function partial(
fn: types.AnyFn,
...partials: any[]
): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 源函数 |
...partials | 局部填充参数 |
返回值 | 目标函数 |
const sub5 = partial(function(a, b) {
return b - a;
}, 5);
sub5(20); // -> 15
将字符串转换为帕斯卡式。
function pascalCase(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 帕斯卡式字符串 |
pascalCase('fooBar'); // -> FooBar
pascalCase('foo bar'); // -> FooBar
pascalCase('foo_bar'); // -> FooBar
pascalCase('foo.bar'); // -> FooBar
高精度时间戳。
function perfNow(): number;
const start = perfNow();
// Do something.
console.log(perfNow() - start);
过滤对象。
function pick(
object: any,
filter: string | string[] | Function
): any;
参数名 | 说明 |
---|---|
object | 源对象 |
filter | 对象过滤器 |
返回值 | 目标对象 |
pick({ a: 1, b: 2 }, 'a'); // -> {a: 1}
pick({ a: 1, b: 2, c: 3 }, ['b', 'c']); // -> {b: 2, c: 3}
pick({ a: 1, b: 2, c: 3, d: 4 }, function(val, key) {
return val % 2;
}); // -> {a: 1, c: 3}
将所有的 stream 流连接起来。
import stream = require('stream');
function pipe(...streams: stream.Stream[]): void;
参数名 | 说明 |
---|---|
...streams | 要连接的 stream 流 |
const fs = require('fs');
const through = require('licia/through');
pipe(
fs.createReadStream('in.txt'),
through(function(chunk, enc, cb) {
this.push(chunk);
cb();
}),
fs.createWriteStream('out.txt')
);
提取数组对象中指定属性值,返回一个数组。
function pluck(object: any, key: string | string[]): any[];
参数名 | 说明 |
---|---|
obj | 目标集合 |
key | 属性路径 |
返回值 | 指定属性值列表 |
const stooges = [
{ name: 'moe', age: 40 },
{ name: 'larry', age: 50 },
{ name: 'curly', age: 60 }
];
pluck(stooges, 'name'); // -> ['moe', 'larry', 'curly']
获取 pointer 事件名,如果不支持使用 touch 或 mouse 事件替代。
function pointerEvent(type: 'down' | 'move' | 'up'): string;
参数名 | 说明 |
---|---|
type | 事件类型,down,move 或 up |
返回值 | pointer 事件名 |
pointerEvent('down'); // -> 'pointerdown' if supported
获取数字的精度。
function precision(num: number): number;
参数名 | 说明 |
---|---|
num | 要检查的数字 |
返回值 | 精度 |
precision(1.234); // -> 3;
预获取指定的 url。
function prefetch(url: string): Promise<void>;
参数名 | 说明 |
---|---|
url | 目标 url |
如果支持,它将使用<link rel=prefetch>
进行预加载。
prefetch('https://eustia.liriliri.io/');
给 css 属性名增加浏览器前缀。
namespace prefix {
function dash(name: string): string;
}
function prefix(name: string): string;
参数名 | 说明 |
---|---|
name | 源属性名 |
返回值 | 目标属性名 |
同上,但返回短横线命名方式的版本。
prefix('text-emphasis'); // -> 'WebkitTextEmphasis'
prefix.dash('text-emphasis'); // -> '-webkit-text-emphasis'
prefix('color'); // -> 'color'
转换使用回调的异步函数,使其返回 Promise。
function promisify(
fn: types.AnyFn,
multiArgs?: boolean
): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 源函数 |
multiArgs=false | 回调是否有多个结果 |
返回值 | 目标函数 |
如果 multiArgs 设为真,返回的 Promise 会将回调的结果合并成一个数组。
const fs = require('fs');
const readFile = promisify(fs.readFile);
readFile('test.js', 'utf-8').then(function(data) {
// Do something with file content.
});
返回一个函数,该函数返回任何传入对象的指定属性。
function property(path: string | string[]): types.AnyFn;
参数名 | 说明 |
---|---|
path | 属性路径 |
返回值 | 目标函数 |
const obj = { a: { b: 1 } };
property('a')(obj); // -> {b: 1}
property(['a', 'b'])(obj); // -> 1
解析序列化 url 的 query 部分。
const query: {
parse(str: string): any;
stringify(object: any): string;
};
将 query 字符串解析成对象。
参数名 | 说明 |
---|---|
str | query 字符串 |
返回值 | query 对象 |
将对象序列化成 query 字符串。
参数名 | 说明 |
---|---|
obj | query 对象 |
返回值 | query 字符串 |
query.parse('foo=bar&eruda=true'); // -> {foo: 'bar', eruda: 'true'}
query.stringify({ foo: 'bar', eruda: 'true' }); // -> 'foo=bar&eruda=true'
query.parse('name=eruda&name=eustia'); // -> {name: ['eruda', 'eustia']}
快排实现。
function quickSort(arr: any[], cmp?: types.AnyFn): any[];
参数名 | 说明 |
---|---|
arr | 要排序的数组 |
cmp | 比较器 |
返回值 | 有序数组 |
quickSort([2, 1]); // -> [1, 2]
requestAnimationFrame 快捷方式。
namespace raf {
function cancel(id: number): void;
}
function raf(cb: types.AnyFn): number;
如果原生 requestAnimationFrame 不支持,使用 setTimeout 进行兼容。
const id = raf(function tick() {
// Animation stuff
raf(tick);
});
raf.cancel(id);
在给定区间内生成随机数。
function random(
min: number,
max?: number,
floating?: boolean
): number;
参数名 | 说明 |
---|---|
min | 最小值 |
max | 最大值 |
floating=false | 是否允许浮点数 |
返回值 | 随机数 |
random(1, 5); // -> an integer between 0 and 5
random(5); // -> an integer between 0 and 5
random(1.2, 5.2, true); /// -> a floating-point number between 1.2 and 5.2
随机字节序列生成器。
function randomBytes(size: number): Uint8Array;
如果支持,使用 node 的 crypto 模块或浏览器的 crypto 对象。
参数名 | 说明 |
---|---|
size | 字节序列长度 |
返回值 | 随机字节序列 |
randomBytes(5); // -> [55, 49, 153, 30, 122]
随机颜色生成器。
function randomColor(): string;
function randomColor(options: {
count?: number;
hue?: number;
lightness?: number;
format?: string;
seed?: number;
}): string | string[];
参数名 | 说明 |
---|---|
options | 随机选项 |
返回值 | 随机颜色 |
可用选项:
参数名 | 说明 |
---|---|
count=1 | 生成数 |
hue | 色调,取值为 0 - 360 |
lightness | 亮度,取值为 0 - 1 |
format=hex | 颜色格式,hex,hsl 或者 rgb |
seed | 随机种子 |
randomColor({
count: 2
}); // -> ['#fed7f4', '#526498']
简单 id 生成器,类似于 nanoid。
function randomId(size?: number, symbols?: string): string;
参数名 | 说明 |
---|---|
size=21 | id 长度 |
symbols | 生成 id 字符,默认为 a-zA-Z0-9_- |
randomId(); // -> 'oKpy4HwU8E6IvU5I03gyQ'
randomId(5); // -> 'sM6E9'
randomId(5, 'abc'); // -> 'cbbcb'
随机获取数组中的某项。
function randomItem(arr: any[]): any;
参数名 | 说明 |
---|---|
arr | 目标数组 |
返回值 | 随机项 |
randomItem([1, 2, 3]); // -> 2
创建整数数组。
function range(
start: number,
end?: number,
step?: number
): number[];
参数名 | 说明 |
---|---|
start | 起始值 |
end | 结束值 |
step=1 | 相邻差 |
返回值 | 整数数组 |
range(5); // -> [0, 1, 2, 3, 4]
range(0, 5, 2); // -> [0, 2, 4]
RC4 对称加密算法实现。
const rc4: {
encrypt(key: string, str: string): string;
decrypt(key: string, str: string): string;
};
RC4 加密,结果表示为 base64 字符串。
RC4 解密,传入 base64 字符串。
参数名 | 说明 |
---|---|
key | 密钥 |
str | 源字符串 |
返回值 | 目标字符串 |
rc4.encrypt('licia', 'Hello world'); // -> 'j9y2VpSfR3AdNN8='
rc4.decrypt('licia', 'j9y2VpSfR3AdNN8='); // -> 'Hello world'
dom 准备好时调用回调函数,类似于 jQuery 的 ready 方法。
function ready(fn: types.AnyFn): void;
参数名 | 说明 |
---|---|
fn | 回调函数 |
ready(function() {
// It's safe to manipulate dom here.
});
合并多个值成一个值。
function reduce<T, TResult>(
list: types.List<T>,
iterator: types.MemoIterator<T, TResult>,
memo?: TResult,
context?: any
): TResult;
function reduce<T, TResult>(
list: types.Dictionary<T>,
iterator: types.MemoObjectIterator<T, TResult>,
memo?: TResult,
context?: any
): TResult;
参数名 | 说明 |
---|---|
obj | 目标集合 |
iteratee=identity | 合并函数 |
initial | 初始值 |
ctx | 函数上下文 |
返回值 | 合并值 |
reduce(
[1, 2, 3],
function(sum, n) {
return sum + n;
},
0
); // -> 6
类似于 reduce,只是从后往前合并。
function reduceRight<T, TResult>(
list: types.Collection<T>,
iterator: types.MemoIterator<T, TResult>,
memo?: TResult,
context?: any
): TResult;
reduceRight(
[[1], [2], [3]],
function(a, b) {
return a.concat(b);
},
[]
); // -> [3, 2, 1]
类似 filter,但结果相反。
function reject<T>(
list: types.List<T>,
iterator: types.ListIterator<T, boolean>,
context?: any
): T[];
function reject<T>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, boolean>,
context?: any
): T[];
参数名 | 说明 |
---|---|
obj | 要遍历的集合 |
predicate | 真值检测函数 |
ctx | 函数上下文 |
返回值 | 包含所有未通过真值检测元素的数组 |
reject([1, 2, 3, 4, 5], function(val) {
return val % 2 === 0;
}); // -> [1, 3, 5]
移除集合中所有通过真值检测的元素,返回包含所有删除元素的数组。
function remove<T, TResult>(
list: types.List<T>,
iterator: types.ListIterator<T, boolean>,
context?: any
): TResult[];
与 filter 不同,该模块会改变原数组。
参数名 | 说明 |
---|---|
list | 要遍历的集合 |
iterator | 真值检测函数 |
context | 函数上下文 |
返回值 | 包含所有删除元素的数组 |
const arr = [1, 2, 3, 4, 5];
const evens = remove(arr, function(val) {
return val % 2 === 0;
});
console.log(arr); // -> [1, 3, 5]
console.log(evens); // -> [2, 4]
重复字符串指定次数。
function repeat(str: string, n: number): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
n | 重复次数 |
返回值 | 目标字符串 |
repeat('a', 3); // -> 'aaa'
repeat('ab', 2); // -> 'abab'
repeat('*', 0); // -> ''
替换字符串中所有指定字符串。
function replaceAll(
str: string,
substr: string,
newSubstr: string
): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
substr | 被替换的子串 |
newSubstr | 替换的子串 |
返回值 | 所有子串被替换后的新字符串 |
replaceAll('hello world goodbye world', 'world', 'licia'); // -> 'hello licia goodbye licia'
将给定序号后的参数合并成一个数组。
function restArgs(
fn: types.AnyFn,
startIndex?: number
): types.AnyFn;
参数名 | 说明 |
---|---|
function | 源函数 |
startIndex | 合并参数起始位置 |
返回值 | 目标函数 |
const paramArr = restArgs(function(rest) {
return rest;
});
paramArr(1, 2, 3, 4); // -> [1, 2, 3, 4]
将数组元素颠倒,不改变原数组。
function reverse(arr: any[]): any[];
参数名 | 说明 |
---|---|
arr | 源数组 |
返回值 | 目标数组 |
reverse([1, 2, 3]); // -> [3, 2, 1]
将 rgb 格式的颜色值转换为 hsl 格式。
function rgbToHsl(rgb: number[]): number[];
参数名 | 说明 |
---|---|
rgb | rgb 值 |
返回值 | hsl 值 |
rgbToHsl([52, 203, 165, 0.8]); // -> [165, 59, 50, 0.8]
requestIdleCallback 的快捷方式。
namespace ric {
function cancel(id: number): void;
}
function ric(cb: types.AnyFn): number;
如果原生 requestIdleCallback 不支持,使用 setTimeout 进行兼容。
const id = ric(function() {
// Called during a browser's idle periods
});
ric.cancel(id);
遍历所有可能的路径和域名将 cookie 删除。
function rmCookie(key: string): void;
参数名 | 说明 |
---|---|
key | cookie 名 |
rmCookie('test');
递归地删除文件夹。
function rmdir(dir: string, cb?: types.AnyFn): void;
参数名 | 说明 |
---|---|
dir | 文件夹路径 |
cb | 回调 |
rmdir('/tmp/foo/bar/baz', function(err) {
if (err) console.log(err);
else console.log('Done');
});
根对象引用,对于 nodeJs,取 global
对象,对于浏览器,取 window
对象。
const root: any;
对字符串进行右填充。
function rpad(str: string, len: number, chars?: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
len | 填充长度 |
chars | 填充字符 |
返回值 | 目标字符串 |
rpad('a', 5); // -> 'a '
rpad('a', 5, '-'); // -> 'a----'
rpad('abc', 3, '-'); // -> 'abc'
rpad('abc', 5, 'ab'); // -> 'abcab'
删除字符串尾部指定字符或空格。
function rtrim(str: string, chars?: string | string[]): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
chars | 删除字符 |
返回值 | 目标字符串 |
rtrim(' abc '); // -> ' abc'
rtrim('_abc_', '_'); // -> '_abc'
rtrim('_abc_', ['c', '_']); // -> '_ab'
创建回调函数,内部模块使用。
function safeCb(
val?: any,
ctx?: any,
argCount?: number
): types.AnyFn;
删除对象属性。
function safeDel(obj: any, path: string | string[]): any;
参数名 | 说明 |
---|---|
obj | 目标对象 |
path | 属性路径 |
返回值 | 删除值或 undefined |
const obj = { a: { aa: { aaa: 1 } } };
safeDel(obj, 'a.aa.aaa'); // -> 1
safeDel(obj, ['a', 'aa']); // -> {}
safeDel(obj, 'a.b'); // -> undefined
获取对象属性值,路径不存在时不报错。
function safeGet(obj: any, path: string | string[]): any;
参数名 | 说明 |
---|---|
obj | 目标对象 |
path | 属性路径 |
返回值 | 属性值或 undefined |
const obj = { a: { aa: { aaa: 1 } } };
safeGet(obj, 'a.aa.aaa'); // -> 1
safeGet(obj, ['a', 'aa']); // -> {aaa: 1}
safeGet(obj, 'a.b'); // -> undefined
设置对象属性值。
function safeSet(
obj: any,
path: string | string[],
val: any
): void;
如果路径的某一层不存在,将会创建一个空对象。
参数名 | 说明 |
---|---|
obj | 目标对象 |
path | 属性路径 |
val | 要设置的值 |
const obj = {};
safeSet(obj, 'a.aa.aaa', 1); // obj = {a: {aa: {aaa: 1}}}
safeSet(obj, ['a', 'aa'], 2); // obj = {a: {aa: 2}}
safeSet(obj, 'a.b', 3); // obj = {a: {aa: 2, b: 3}}
安全地使用 storage,使其在旧浏览器及 safari 无痕模式下能正常运行。
function safeStorage(type?: string): typeof window.localStorage;
参数名 | 说明 |
---|---|
type='local' | 模式,local 或 session |
返回值 | 指定 storage |
const localStorage = safeStorage('local');
localStorage.setItem('licia', 'util');
检查两个 url 是否同源。
function sameOrigin(url1: string, url2: string): boolean;
参数名 | 说明 |
---|---|
url1 | 要检查的 url |
url2 | 要检查的 url |
返回值 | 同源,返回真 |
const url1 = 'http://example.com/a.html';
const url2 = 'http://example.com/b.html';
const url3 = 'http://licia.liriliri.io';
sameOrigin(url1, url2); // -> true
sameOrigin(url1, url3); // -> false
从集合中随机抽取部分样本。
function sample(obj: any, n: number): any[];
参数名 | 说明 |
---|---|
obj | 目标集合 |
n | 样本数量 |
返回值 | 样本 |
sample([2, 3, 1], 2); // -> [2, 3]
sample({ a: 1, b: 2, c: 3 }, 1); // -> [2]
以动画的形式滚动到指定目标。
function scrollTo(
target: Element | string | number,
options: {
tolerance?: number;
duration?: number;
easing?: string | Function;
callback?: types.AnyFn;
}
);
参数名 | 说明 |
---|---|
target | 滚动目标 |
options | 滚动选项 |
选项名 | 说明 |
---|---|
tolerance=0 | 偏移 |
duration=800 | 时长 |
easing=outQuart | 缓动函数 |
callback=noop | 结束回调 |
scrollTo('body', {
tolerance: 0,
duration: 800,
easing: 'outQuart',
callback: function() {}
});
随机数生成器。
function seedRandom(
seed: number,
min?: number,
max?: number,
floating?: boolean
): () => number;
参数名 | 说明 |
---|---|
seed | 随机种子 |
min=0 | 最小值 |
max=1 | 最大值 |
floating=true | 是否允许浮点数 |
返回值 | 生成随机数字序列的函数 |
const random = seedRandom(19920719, 0, 100, false);
random(); // -> 7
random(); // -> 68
选择排序实现。
function selectionSort(arr: any[], cmp?: types.AnyFn): any[];
参数名 | 说明 |
---|---|
arr | 要排序的数组 |
cmp | 比较器 |
返回值 | 有序数组 |
selectionSort([2, 1]); // -> [1, 2]
CSS 选择器解析器。
namespace selector {
interface IToken {
type: string;
value: string;
}
}
const selector: {
parse(selector: string): Array<selector.IToken[]>;
stringify(selector: Array<selector.IToken[]>): string;
};
将 CSS 选择器转换为 js 对象。
参数名 | 说明 |
---|---|
selector | CSS 选择器 |
返回值 | js 对象 |
将 js 对象序列化成 CSS 选择器。
参数名 | 说明 |
---|---|
groups | 要序列化的对象 |
返回值 | CSS 选择器 |
const groups = selector.parse('#test, input.user[name="licia"]');
// -> [[{type: 'id', value: 'test'}],[{type: 'tag', value: 'input'}...]]
selector.stringify(groups);
获取 shebang 命令。
function shebang(str: string): string | void;
参数名 | 说明 |
---|---|
str | 要获取命令的文本 |
返回值 | Shebang 命令 |
shebang('#!/usr/bin/env node'); // -> '/usr/bin/env node'
shebang('#!/bin/bash'); // -> '/bin/bash'
shebang('node'); // -> undefined
希尔排序实现。
function shellSort(arr: any[], cmp?: types.AnyFn): any[];
参数名 | 说明 |
---|---|
arr | 要排序的数组 |
cmp | 比较器 |
返回值 | 有序数组 |
shellSort([2, 1]); // -> [1, 2]
将数组中元素的顺序打乱。
function shuffle(arr: any[]): any[];
参数名 | 说明 |
---|---|
arr | 源数组 |
返回值 | 目标数组 |
shuffle([1, 2, 3]); // -> [3, 1, 2]
确保一个异步函数返回前只运行一个实例。
function singleton<F extends types.Fn<Promise<any>>>(
fn: F,
hashFn?: types.AnyFn
): F;
参数名 | 说明 |
---|---|
fn | 要限制的函数 |
hashFn | 计算缓存键名函数 |
返回值 | 单例运行函数 |
const fetch = singleton(async function fetch(id) {});
const f1 = fetch(1);
const f2 = fetch(1);
const f3 = fetch(2);
console.log(f1 === f2); // -> true
console.log(f1 === f3); // -> false
f1.then(() => {
const f4 = fetch(1);
console.log(f1 === f4); // -> false
});
获取对象的大小或类数组元素的长度。
function size(obj: any): number;
参数名 | 说明 |
---|---|
obj | 目标集合 |
返回值 | 集合大小 |
size({ a: 1, b: 2 }); // -> 2
size([1, 2, 3]); // -> 3
计算 js 对象大概的内存占用。
function sizeof(obj: any): number;
参数名 | 说明 |
---|---|
obj | 要计算的对象 |
返回值 | 对象大小,单位是字节 |
一个字符占用 2 字节,布尔值 4 字节,数字 8 字节。
对象键名当成字符串来计算。
sizeof('a'); // -> 2
sizeof(8); // -> 8
sizeof(false); // -> 4
sizeof(function() {}); // -> 0
sizeof({ a: 'b' }); // -> 4
使用 Promise 模拟暂停方法。
function sleep(timeout: number): Promise<void>;
参数名 | 说明 |
---|---|
timeout | 暂停时长 |
(async function() {
await sleep(2000);
})();
截取数组的一部分生成新数组。
function slice(
array: any[],
start?: number,
end?: number
): any[];
参数名 | 说明 |
---|---|
array | 目标数组 |
start=0 | 起始位置 |
end=array.length | 结束位置,不包含 |
slice([1, 2, 3, 4], 1, 2); // -> [2]
Slug 化字符串。
function slugify(
str: string,
replacement?: { [index: string]: string }
): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
replacement | 自定义替换 |
返回值 | 目标字符串 |
slugify('I ♥ pony'); // -> 'I-love-pony'
slugify('I ♥ pony', { ' ': '_' }); // -> 'I_love_pony'
转换字符串为下划线式。
function snakeCase(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 下划线式字符串 |
snakeCase('fooBar'); // -> foo_bar
snakeCase('foo bar'); // -> foo_bar
snakeCase('foo.bar'); // -> foo_bar
检查集合中是否有元素通过真值检测。
function some<T>(
list: types.List<T>,
iterator?: types.ListIterator<T, boolean>,
context?: any
): boolean;
function some<T>(
object: types.Dictionary<T>,
iterator?: types.ObjectIterator<T, boolean>,
context?: any
): boolean;
参数名 | 说明 |
---|---|
obj | 目标集合 |
predicate | 真值检测函数 |
ctx | 函数上下文 |
返回值 | 如果有元素通过真值检测,返回真 |
some([2, 5], function(val) {
return val % 2 === 0;
}); // -> true
遍历集合中的元素,将其作为参数调用函数,并以得到的结果为依据对数组进行排序。
function sortBy(
arr: any,
iterator?: types.AnyFn,
ctx?: any
): any[];
参数名 | 说明 |
---|---|
arr | 源集合 |
iteratee=identity | 排序依据生成函数 |
ctx | 函数上下文 |
返回值 | 排序后的数组 |
sortBy([1, 2, 3, 4, 5, 6], function(num) {
return Math.sin(num);
}); // -> [5, 4, 6, 3, 1, 2]
排序对象的键名。
function sortKeys(
obj: object,
options?: {
deep?: boolean;
comparator?: types.AnyFn;
}
): object;
参数名 | 说明 |
---|---|
obj | 要排序的对象 |
options | 排序选项 |
返回值 | 排序后的对象 |
可用选项:
参数名 | 说明 |
---|---|
deep=false | 是否递归 |
comparator | 比较器 |
sortKeys(
{ b: { d: 2, c: 1 }, a: 0 },
{
deep: true
}
); // -> {a: 0, b: {c: 1, d: 2}}
将字符串转换为空格式。
function spaceCase(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 空格式字符串 |
spaceCase('fooBar'); // -> foo bar
spaceCase('foo.bar'); // -> foo bar
spaceCase('foo.bar'); // -> foo bar
将不同命名式的字符串拆分成数组。
function splitCase(str: string): string[];
参数名 | 说明 |
---|---|
str | 目标字符串 |
返回值 | 拆分成的数组 |
splitCase('foo-bar'); // -> ['foo', 'bar']
splitCase('foo bar'); // -> ['foo', 'bar']
splitCase('foo_bar'); // -> ['foo', 'bar']
splitCase('foo.bar'); // -> ['foo', 'bar']
splitCase('fooBar'); // -> ['foo', 'bar']
splitCase('foo-Bar'); // -> ['foo', 'bar']
将路径拆分为文件夹路径,文件名和扩展名。
function splitPath(
path: string
): {
dir: string;
name: string;
ext: string;
};
参数名 | 说明 |
---|---|
path | 目标路径 |
返回值 | 包含文件夹路径,文件名和扩展名的对象 |
splitPath('f:/foo/bar.txt'); // -> {dir: 'f:/foo/', name: 'bar.txt', ext: '.txt'}
splitPath('/home/foo/bar.txt'); // -> {dir: '/home/foo/', name: 'bar.txt', ext: '.txt'}
获取 v8 的 CallSite 对象。
function stackTrace(): any[];
stackTrace(); // -> List of CallSite objects
检查字符串是否以指定字符串开头。
function startWith(str: string, prefix: string): boolean;
参数名 | 说明 |
---|---|
str | 目标字符串 |
prefix | 字符串前缀 |
返回值 | 如果是前缀,返回真 |
startWith('ab', 'a'); // -> true
使用 djb2 算法进行字符串哈希。
function strHash(str: string): number;
参数名 | 说明 |
---|---|
str | 目标字符串 |
返回值 | 哈希结果 |
strHash('test'); // -> 2090770981
将字符串转换为字节数组。
function strToBytes(str: string, encoding?: string): number[];
参数名 | 说明 |
---|---|
str | 目标字符串 |
encoding=utf8 | 字符串编码 |
返回值 | 字节数组 |
支持编码:utf8,hex,base64
strToBytes('licia'); // -> [108, 105, 99, 105, 97]
strToBytes('qK6b/w==', 'base64'); // -> [168, 174, 155, 255]
简单的字符串模板。
function strTpl(str: string, data: types.PlainObj<any>): string;
参数名 | 说明 |
---|---|
str | 模板字符串 |
data | 渲染数据 |
返回值 | 目标字符串 |
strTpl('Hello, {{name.first}}!', { name: { first: 'licia' } }); // -> 'Hello, licia!'
获取字符串的可见宽度。
function strWidth(str: string): number;
参数名 | 说明 |
---|---|
str | 要获取宽度的字符串 |
返回值 | 可见宽度 |
strWidth('Hello \nworld!'); // -> 12
strWidth('\u001b[4m你好,世界!\u001b[0m'); // -> 12
JSON 序列化,支持循环引用和函数。
function stringify(obj: any, spaces?: number): string;
undefined 被当作 null 处理。
参数名 | 说明 |
---|---|
obj | 目标对象 |
spaces | 缩进 |
返回值 | 序列化后的字符串 |
stringify({ a: function() {} }); // -> '{"a":"[Function function () {}]"}'
const obj = { a: 1, b: {} };
obj.b = obj;
stringify(obj); // -> '{"a":1,"b":"[Circular ~]"}'
序列化对象,保留类型信息。
namespace stringifyAll {
function parse(str: string): any;
}
function stringifyAll(
obj: any,
options?: {
unenumerable?: boolean;
symbol?: boolean;
accessGetter?: boolean;
timeout?: number;
depth?: number;
ignore?: any[];
}
): string;
参数名 | 说明 |
---|---|
obj | 源对象 |
options | 序列化选项 |
返回值 | 序列化后的字符串 |
可用选项:
参数名 | 说明 |
---|---|
unenumerable=false | 包含不可枚举值 |
symbol=false | 包含 Symbol 键名 |
accessGetter=false | 获取 getter 值 |
timeout=0 | 序列化超时时间 |
depth=0 | 遍历对象的最大深度 |
ignore | 忽略的对象 |
超时后,所有未序列化的值都会变成 “Timeout”。
将字符串反序列化回对象。
参数名 | 说明 |
---|---|
obj | 序列化后的字符串 |
返回值 | 目标对象 |
stringifyAll(function test() {}); // -> '{"value":"function test() {}","type":"Function",...}'
清除字符串中的 ansi 控制码。
function stripAnsi(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
stripAnsi('\u001b[4mcake\u001b[0m'); // -> 'cake'
清除 UTF-8 BOM。
function stripBom(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
stripBom('\uFEFFlicia'); // -> 'licia'
清除源码中的注释。
function stripCmt(str: string): string;
参数名 | 说明 |
---|---|
str | 源码 |
返回值 | 无注释代码 |
stripCmt('// comment \n var a = 5; \/* comment2\n * comment3\n *\/'); // -> ' var a = 5; '
清除字符串中的 ansi 颜色控制码。
function stripColor(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
stripColor('\u001b[31mred\u001b[39m'); // -> 'red'
清除字符串中的 html 标签。
function stripHtmlTag(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
stripHtmlTag('<p>Hello</p>'); // -> 'Hello'
清除多行文本的缩进。
function stripIndent(str: string): string;
function stripIndent(
literals: TemplateStringsArray,
...placeholders: any[]
): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
它可以像函数一样调用,也可以当成标签模板使用。
stripIndent`
Test string
* item one
* item two
`; // -> 'Test string\n * item one\n * item two'
将数字转换为指定的精度。
function stripNum(num: number, precision?: number): number;
参数名 | 说明 |
---|---|
num | 源数字 |
precision=12 | 精度 |
返回值 | 目标数字 |
stripNum(0.1 + 0.2); // -> 0.3
计算数字和。
function sum(...num: number[]): number;
参数名 | 说明 |
---|---|
...num | 要计算的数字 |
返回值 | 数字和 |
sum(1, 2, 5); // -> 8
交换数组中的两项。
function swap(arr: any[], a: number, b: number): any[];
参数名 | 说明 |
---|---|
arr | 目标数组 |
a | 序号一 |
b | 序号二 |
返回值 | 数组本身 |
const arr = [1, 2];
swap(arr, 0, 1); // -> [2, 1]
输出表格字符串。
namespace table {
interface IOptions {
border?: {
topBody?: string;
topJoin?: string;
topLeft?: string;
topRight?: string;
bottomBody?: string;
bottomJoin?: string;
bottomLeft?: string;
bottomRight?: string;
bodyLeft?: string;
bodyRight?: string;
bodyJoin?: string;
joinBody?: string;
joinLeft?: string;
joinRight?: string;
joinJoin?: string;
};
}
function parse(table: string, options?: IOptions): Array<string[]>;
}
function table(
rows: Array<string[]>,
options?: table.IOptions
): string;
参数名 | 说明 |
---|---|
rows | 表格数据 |
options | 表格选项 |
返回值 | 表格字符串 |
参数名 | 说明 |
---|---|
table | 表格字符串 |
options | 表格选项 |
返回值 | 表格数据 |
table([
['', 'firstName', 'lastName'],
['daughter', 'Emily', 'Smith'],
['father', 'John', 'Smith'],
['mother', 'Jane', 'Smith']
]);
将模板字符串编译成函数用于渲染。
function template(str: string, util?: any): types.AnyFn;
参数名 | 说明 |
---|---|
str | 模板字符串 |
util | 模板函数 |
返回值 | 编译后的模板函数 |
template('Hello <%= name %>!')({ name: 'licia' }); // -> 'Hello licia!'
template('<p><%- name %></p>')({ name: '<licia>' }); // -> '<p><licia></p>'
template('<%if (echo) {%>Hello licia!<%}%>')({ echo: true }); // -> 'Hello licia!'
template('<p><%= util["upperCase"](name) %></p>', {
upperCase: function(str) {
return str.toLocaleUpperCase();
}
})({ name: 'licia' }); // -> '<p>LICIA</p>'
主题工具库。
namespace theme {
interface ITheme extends Emitter {
get(): string;
}
}
const theme: theme.ITheme;
绑定 change 事件。
解绑 change 事件。
获取当前主题(light 或 dark)。
theme.on('change', function(theme) {
console.log(theme); // -> 'dark'
});
theme.get(); // -> 'light'
返回函数的节流阀版本。
function throttle<T extends types.AnyFn>(fn: T, wait: number): T;
参数名 | 说明 |
---|---|
fn | 源函数 |
wait | 延迟毫秒数 |
返回值 | 目标函数 |
const updatePos = throttle(function() {}, 100);
// $(window).scroll(updatePos);
stream Transform 类的简单包装。
import stream = require('stream');
namespace through {
interface ThroughConstructor extends stream.Transform {
new (opts?: stream.DuplexOptions): stream.Transform;
(opts?: stream.DuplexOptions): stream.Transform;
}
type TransformCallback = (err?: any, data?: any) => void;
type TransformFunction = (
this: stream.Transform,
chunk: any,
enc: string,
callback: TransformCallback
) => void;
type FlushCallback = (
this: stream.Transform,
flushCallback: () => void
) => void;
function obj(
transform?: TransformFunction,
flush?: FlushCallback
): stream.Transform;
function ctor(
transform?: TransformFunction,
flush?: FlushCallback
): ThroughConstructor;
function ctor(
opts?: stream.DuplexOptions,
transform?: TransformFunction,
flush?: FlushCallback
): ThroughConstructor;
}
function through(
transform?: through.TransformFunction,
flush?: through.FlushCallback
): stream.Transform;
function through(
opts?: stream.DuplexOptions,
transform?: through.TransformFunction,
flush?: through.FlushCallback
): stream.Transform;
参数名 | 说明 |
---|---|
opts={} | 初始化流选项 |
transform | Transform 实现 |
flush | Flush 实现 |
设置 objectMode 为真的快捷方式。
返回继承 Transform 的类。
const fs = require('fs');
fs.createReadStream('in.txt')
.pipe(
through(function(chunk, enc, cb) {
// Do something to chunk
this.push(chunk);
cb();
})
)
.pipe(fs.createWriteStream('out.txt'));
将绝对路径转换为波浪线路径。
function tildify(path: string): string;
参数名 | 说明 |
---|---|
path | 要转换的路径 |
返回值 | 波浪线路径 |
tildify('/home/surunzi/dev'); // -> '~/dev'
将时间格式化成多久之前的形式。
function timeAgo(
date: Date | number,
now?: Date | number
): string;
参数名 | 说明 |
---|---|
date | 目标日期 |
now=new Date | 当时日期 |
返回值 | 格式化时间表示 |
const now = new Date().getTime();
timeAgo(now - 1000 * 6); // -> just now
timeAgo(now - 1000 * 15); // -> 15 seconds ago
timeAgo(now + 1000 * 60 * 15); // -> in 15 minutes
timeAgo(now - 1000 * 60 * 60 * 5, now); // -> 5 hours ago
获取函数的执行时间。
function timeTaken(fn: types.AnyFn): number;
参数名 | 说明 |
---|---|
fn | 要计算执行时间的函数 |
返回值 | 执行时间,单位毫秒 |
timeTaken(function() {
// Do something.
}); // -> Time taken to execute given function.
调用目标函数 n 次。
function times<T>(
n: number,
fn: (n: number) => T,
ctx?: any
): T[];
参数名 | 说明 |
---|---|
n | 调用次数 |
fn | 目标函数 |
ctx | 函数上下文 |
返回值 | 结果数组 |
times(3, String); // -> ['0', '1', '2']
将任意值转换为数组。
function toArr(val: any): any[];
参数名 | 说明 |
---|---|
val | 要转换的值 |
返回值 | 转换后的数组 |
toArr({ a: 1, b: 2 }); // -> [{a: 1, b: 2}]
toArr('abc'); // -> ['abc']
toArr(1); // -> [1]
toArr(null); // -> []
让 generator 可以像 async/await 一样使用。
function toAsync(fn: types.AnyFn): types.AnyFn;
参数名 | 说明 |
---|---|
fn | Generator 函数 |
返回值 | 目标函数 |
const sleep = require('licia/sleep');
const fn = toAsync(function*() {
yield sleep(200);
return 'licia';
});
fn().then(str => {});
将任意值转换为布尔值。
function toBool(val: any): boolean;
参数名 | 说明 |
---|---|
val | 要转换的值 |
返回值 | 转换后的布尔值 |
toBool(true); // -> true
toBool(null); // -> false
toBool(1); // -> true
toBool(0); // -> false
toBool('0'); // -> false
toBool('1'); // -> true
toBool('false'); // -> false
将任意值转换为日期类型。
function toDate(val: any): Date;
参数名 | 说明 |
---|---|
val | 要转换的值 |
返回值 | 转换后的日期值 |
toDate('20180501');
toDate('2018-05-01');
toDate(1525107450849);
将 html 字符串转换为 dom 元素。
function toEl(str: string): Element;
必须只有一个根元素。
参数名 | 说明 |
---|---|
str | html 字符串 |
返回值 | html 元素 |
toEl('<div>test</div>');
将任意值转换为整数。
function toInt(val: any): number;
参数名 | 说明 |
---|---|
val | 要转换的值 |
返回值 | 转换后的整数 |
toInt(1.1); // -> 1
toInt(undefined); // -> 0
将任意值转换为数字。
function toNum(val: any): number;
参数名 | 说明 |
---|---|
val | 要转换的值 |
返回值 | 转换后的数字 |
toNum('5'); // -> 5
将函数转换为源码。
function toSrc(fn: types.AnyFn): string;
参数名 | 说明 |
---|---|
fn | 目标函数 |
返回值 | 源码 |
toSrc(Math.min); // -> 'function min() { [native code] }'
toSrc(function() {}); // -> 'function () { }'
将任意值转换为字符串。
function toStr(val: any): string;
参数名 | 说明 |
---|---|
val | 要转换的值 |
返回值 | 转换后的字符串 |
toStr(null); // -> ''
toStr(1); // -> '1'
toStr(false); // -> 'false'
toStr([1, 2, 3]); // -> '1,2,3'
拓扑排序实现。
function topoSort(edges: any[]): any[];
参数名 | 说明 |
---|---|
edges | 依赖关系 |
返回值 | 排序后的数组 |
topoSort([
[1, 2],
[1, 3],
[3, 2]
]); // -> [1, 3, 2]
触发浏览器事件。
function trigger(
el: Element | Document,
type: string,
options?: any
): void;
function trigger(type: string, options?: any): void;
参数名 | 说明 |
---|---|
el=document | 目标元素 |
type | 事件类型 |
options | 选项 |
trigger(document.getElementById('test'), 'mouseup');
trigger('keydown', { keyCode: 65 });
删除字符串两边指定字符或空格。
function trim(str: string, chars?: string | string[]): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
chars | 删除字符 |
返回值 | 目标字符串 |
trim(' abc '); // -> 'abc'
trim('_abc_', '_'); // -> 'abc'
trim('_abc_', ['a', 'c', '_']); // -> 'b'
截取字符串,使其长度为指定值。
function truncate(
txt: string,
width: number,
options?: {
ellipsis?: string;
separator: string;
}
): string;
参数名 | 说明 |
---|---|
txt | 要截取的字符串 |
width | 最大字符串长度 |
options | 选项 |
返回值 | 截取后的字符串 |
选项:
参数名 | 说明 |
---|---|
ellipsis='...' | 表示截取掉部分的符号 |
separator | 分隔符,尽可能使截取位置在该处 |
truncate('ORA ORA ORA ORA ORA ORA', 12); // -> 'ORA ORA O...'
truncate('ORA ORA ORA ORA ORA ORA', 10, {
separator: ' ',
ellipsis: '……'
}); // -> 'ORA ORA……'
在 try catch 块中运行函数。
function tryIt(fn: types.AnyFn, cb?: types.AnyFn): void;
参数名 | 说明 |
---|---|
fn | 目标函数 |
cb | 回调 |
tryIt(
function() {
// Do something that might cause an error.
},
function(err, result) {
if (err) console.log(err);
}
);
获取 JavaScript 对象的内部类型。
function type(val: any, lowerCase?: boolean): string;
参数名 | 说明 |
---|---|
val | 目标对象 |
lowerCase=true | 是否小写 |
返回值 | 对象类型 |
type(5); // -> 'number'
type({}); // -> 'object'
type(function() {}); // -> 'function'
type([]); // -> 'array'
type([], false); // -> 'Array'
type(async function() {}, false); // -> 'AsyncFunction'
仅用于生成 ts 定义文件。
namespace types {
interface Collection<T> {}
interface List<T> extends Collection<T> {
[index: number]: T;
length: number;
}
interface ListIterator<T, TResult> {
(value: T, index: number, list: List<T>): TResult;
}
interface Dictionary<T> extends Collection<T> {
[index: string]: T;
}
interface ObjectIterator<T, TResult> {
(element: T, key: string, list: Dictionary<T>): TResult;
}
interface MemoIterator<T, TResult> {
(prev: TResult, curr: T, index: number, list: List<T>): TResult;
}
interface MemoObjectIterator<T, TResult> {
(prev: TResult, curr: T, key: string, list: Dictionary<T>): TResult;
}
type Fn<T> = (...args: any[]) => T;
type AnyFn = Fn<any>;
type PlainObj<T> = { [name: string]: T };
}
const types: {};
UCS-2 编解码。
const ucs2: {
encode(arr: number[]): string;
decode(str: string): number[];
};
通过码点序列创建字符串。
参数名 | 说明 |
---|---|
arr | 码点序列 |
返回值 | 编码后的字符串 |
通过字符串创建码点序列。
参数名 | 说明 |
---|---|
str | 字符串 |
返回值 | 码点序列 |
ucs2.encode([0x61, 0x62, 0x63]); // -> 'abc'
ucs2.decode('abc'); // -> [0x61, 0x62, 0x63]
'𝌆'.length; // -> 2
ucs2.decode('𝌆').length; // -> 1
全局错误监听。
const uncaught: {
start(): void;
stop(): void;
addListener(fn: (err: Error) => void): void;
rmListener(fn: (err: Error) => void): void;
rmAllListeners(): void;
};
开始监听错误。
停止监听错误。
添加监听器。
参数名 | 说明 |
---|---|
fn | 错误监听器 |
移除监听器。
移除所有监听器。
uncaught.start();
uncaught.addListener(err => {
// Do something.
});
和 escape 相反,转义 HTML 实体回去。
function unescape(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
unescape('You & Me'); // -> 'You & Me'
返回传入所有数组的并集。
function union(...arr: Array<any[]>): any[];
参数名 | 说明 |
---|---|
...arr | 要合并的数组 |
返回值 | 数组并集 |
union([2, 1], [4, 2], [1, 2]); // -> [2, 1, 4]
生成全局唯一 id。
function uniqId(prefix?: string): string;
参数名 | 说明 |
---|---|
prefix | id 前缀 |
返回值 | 全局唯一 id |
uniqId('eustia_'); // -> 'eustia_xxx'
返回数组去重后的副本。
function unique(
arr: any[],
cmp?: (a: any, b: any) => boolean | number
): any[];
参数名 | 说明 |
---|---|
arr | 源数组 |
cmp | 比较器 |
返回值 | 目标数组 |
unique([1, 2, 3, 1]); // -> [1, 2, 3]
使用异步函数同时支持 promise 及回调模式。
function universalify(
fn: types.AnyFn,
type: string
): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 异步函数 |
type | 源类型,promise 或 callback |
返回值 | 目标函数 |
function callbackFn(str, cb) {
setTimeout(() => {
cb(null, str);
}, 10);
}
const fn = universalify(callbackFn, 'callback');
fn('licia', (err, result) => {
console.log(result); // -> 'licia'
});
fn('licia').then(result => {
console.log(result); // -> 'licia'
});
与 zip 相反。
declare function unzip(arr: Array<any[]>): Array<any[]>;
参数名 | 说明 |
---|---|
arr | 源数组 |
返回值 | 目标数组 |
unzip([
['a', 1, true],
['b', 2, false]
]); // -> [['a', 'b'], [1, 2], [true, false]]
转换字符串为大写。
function upperCase(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
upperCase('test'); // -> 'TEST'
将字符串的第一个字符转换为大写。
function upperFirst(str: string): string;
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
upperFirst('red'); // -> Red
使用 define 创建的模块。
function use(requires: string[], method: types.AnyFn): void;
function use(method: types.AnyFn): void;
参数名 | 说明 |
---|---|
requires | 依赖 |
method | 要执行的代码 |
// define('A', () => 'A');
use(['A'], function(A) {
console.log(A + 'B'); // -> 'AB'
});
UTF-8 编解码。
const utf8: {
encode(str: string): string;
decode(str: string, safe?: boolean): string;
};
UTF-8 编码。
参数名 | 说明 |
---|---|
str | 源字符串 |
返回值 | 目标字符串 |
UTF-8 解码。
参数名 | 说明 |
---|---|
str | 源字符串 |
safe=false | 如果设为真,不抛错误 |
返回值 | 目标字符串 |
utf8.encode('\uD800\uDC00'); // -> '\xF0\x90\x80\x80'
utf8.decode('\xF0\x90\x80\x80'); // -> '\uD800\uDC00'
生成符合 RFC4112 版本 4 协议的 uuid。
function uuid(): string;
相关标准 RFC4122 4.4。
uuid(); // -> '53ce0497-6554-49e9-8d79-347406d2a88b'
返回对象所有的属性值。
function values(obj: any): any[];
参数名 | 说明 |
---|---|
obj | 目标对象 |
返回值 | 所有属性值 |
values({ one: 1, two: 2 }); // -> [1, 2]
获取窗口缩放比。
function viewportScale(): number;
viewportScale(); // -> 3
vlq 编解码。
const vlq: {
encode(number: number | number[]): string;
decode(string: string): number[];
};
将数字编码为 vlq 字符串。
参数名 | 说明 |
---|---|
number | 源数字 |
返回值 | 目标字符串 |
将 vlq 字符串解码为数字。
参数名 | 说明 |
---|---|
string | 源字符串 |
返回值 | 目标数字 |
vlq.encode(123); // -> '2H'
vlq.encode([123, 456, 789]); // -> '2HwcqxB'
vlq.decode('2H'); // -> [123]
vlq.decode('2HwcqxB'); // -> [123, 456, 789]
等待直到条件函数返回真值。
function waitUntil(
condition: types.AnyFn,
timeout?: number,
interval?: number
): Promise<any>;
参数名 | 说明 |
---|---|
condition | 条件函数 |
timeout=0 | 超时 |
interval=250 | 等待间隔 |
let a = 5;
setTimeout(() => (a = 10), 500);
waitUntil(() => a === 10).then(() => {
console.log(a); // -> 10
});
按顺序执行函数序列。
function waterfall(tasks: types.AnyFn[], cb?: types.AnyFn): void;
参数名 | 说明 |
---|---|
tasks | 函数序列 |
cb | 结束回调 |
waterfall(
[
function(cb) {
cb(null, 'one');
},
function(arg1, cb) {
// arg1 -> 'one'
cb(null, 'done');
}
],
function(err, result) {
// result -> 'done'
}
);
按照指定长度对字符串进行折行处理。
function wordWrap(txt: string, width: number): string;
参数名 | 说明 |
---|---|
txt | 要折行的字符串 |
width | 最大行宽度 |
返回值 | 折行后的字符串 |
wordWrap('Licia is a utility library.', 10);
// -> 'Licia is \na utility \nlibrary.'
将 32 位字长数组转换为字节数组。
function wordsToBytes(words: number[]): number[];
参数名 | 说明 |
---|---|
words | 字长数组 |
返回值 | 字节数组 |
wordsToBytes([0x12345678]); // -> [0x12, 0x34, 0x56, 0x78]
将函数运行在 worker 线程中。
function workerize(fn: types.AnyFn): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 源函数 |
返回值 | 目标函数 |
const worker = workerize(function(a, b) {
return a + b;
});
worker(1, 2).then(function(value) {
console.log(value); // -> 3
});
将函数封装到包裹函数里面, 并把它作为第一个参数传给包裹函数。
function wrap(
fn: types.AnyFn,
wrapper: types.AnyFn
): types.AnyFn;
参数名 | 说明 |
---|---|
fn | 要包裹的函数 |
wrapper | 包裹函数 |
返回值 | 目标函数 |
const p = wrap(escape, function(fn, text) {
return '<p>' + fn(text) + '</p>';
});
p('You & Me'); // -> '<p>You & Me</p>'
小程序 wx 对象的 promise 版本。
const wx: any;
wx.getStorage('test').then(res => {
console.log(res.data);
});
使用 xpath 选择元素,不支持 IE。
function xpath(xpath: string): HTMLElement[];
参数名 | 说明 |
---|---|
xpath | Xpath |
返回值 | 目标元素集 |
xpath('//html/body'); // -> [body]
将每个数组中相应位置的值合并在一起。
function zip(...arr: Array<any[]>): Array<any[]>;
参数名 | 说明 |
---|---|
arr | 源数组 |
返回值 | 目标数组 |
zip(['a', 'b'], [1, 2], [true, false]); // -> [['a', 1, true], ['b', 2, false]]