Node.js v10.14.2 文档


目录

util(实用工具)#

中英对照

稳定性: 2 - 稳定的

util 模块主要用于支持 Node.js 内部 API 的需求。 大部分实用工具也可用于应用程序与模块开发者。 使用方法如下:

const util = require('util');

util.callbackify(original)#

中英对照

async 异步函数(或者一个返回值为 Promise 的函数)转换成遵循异常优先的回调风格的函数,例如将 (err, value) => ... 回调作为最后一个参数。在回调函数中, 第一个参数 err 为 Promise rejected 的原因 (如果 Promise 状态为 resolved , err为 null ),第二个参数则是 Promise 状态为 resolved 时的返回值.

例如 :

const util = require('util');

async function fn() {
  return 'hello world';
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  if (err) throw err;
  console.log(ret);
});

将会打印出:

hello world

注意:

  • 回调函数是异步执行的, 并且有异常堆栈错误追踪. 如果回调函数抛出一个异常, 进程会触发一个 'uncaughtException' 异常, 如果没有被捕获, 进程将会退出.

  • null 在回调函数中作为一个参数有其特殊的意义, 如果回调函数的首个参数为 Promise rejected 的原因且带有返回值, 且值可以转换成布尔值 false, 这个值会被封装在 Error 对象里, 可以通过属性 reason 获取.

    function fn() {
      return Promise.reject(null);
    }
    const callbackFunction = util.callbackify(fn);
    
    callbackFunction((err, ret) => {
      // When the Promise was rejected with `null` it is wrapped with an Error and
      // the original value is stored in `reason`.
      err && err.hasOwnProperty('reason') && err.reason === null;  // true
    });
    

util.debuglog(section)#

中英对照

  • section <string> 一个字符串,指定要为应用的哪些部分创建 debuglog 函数。 debuglog 函数要为哪些应用创建。
  • 返回: <Function> 日志函数

util.debuglog() 方法用于创建一个函数,基于 NODE_DEBUG 环境变量的存在与否有条件地写入调试信息到 stderr。 如果 section 名称在环境变量的值中,则返回的函数类似于 console.error()。 否则,返回的函数是一个空操作。

例子:

const util = require('util');
const debuglog = util.debuglog('foo');

debuglog('hello from foo [%d]', 123);

如果程序在环境中运行时带上 NODE_DEBUG=foo,则输出类似如下:

FOO 3245: hello from foo [123]

其中 3245 是进程 id。 如果运行时没带上环境变量集合,则不会打印任何东西。

NODE_DEBUG 环境变量中可指定多个由逗号分隔的 section 名称。 例如:NODE_DEBUG=fs,net,tls

util.deprecate(fn, msg[, code])#

中英对照

  • fn <Function> The function that is being deprecated.
  • msg <string> A warning message to display when the deprecated function is invoked.
  • code <string> A deprecation code. See the list of deprecated APIs for a list of codes.
  • Returns: <Function> The deprecated function wrapped to emit a warning.

util.deprecate() 方法会包装给定的 function 或类,并标记为废弃的。

const util = require('util');

exports.obsoleteFunction = util.deprecate(() => {
  // Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');

当被调用时,util.deprecate() 会返回一个函数,这个函数会使用 process.on('warning') 事件触发一个 DeprecationWarning。 默认情况下,警告只在首次被调用时才会被触发并打印到 stderr。 警告被触发之后,被包装的 function 会被调用。

const util = require('util');

const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');
const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');
fn1(); // emits a deprecation warning with code DEP0001
fn2(); // does not emit a deprecation warning because it has the same code

如果使用了 --no-deprecation--no-warnings 命令行标记,或 process.noDeprecation 属性在首次废弃警告之前被设为 true,则 util.deprecate() 方法什么也不做。

如果设置了 --trace-deprecation--trace-warnings 命令行标记,或 process.traceDeprecation 属性被设为 true,则废弃的函数首次被调用时会把警告与堆栈追踪打印到 stderr

如果设置了 --throw-deprecation 命令行标记,或 process.throwDeprecation 属性被设为 true,则当废弃的函数被调用时会抛出一个异常。

--throw-deprecation 命令行标记和 process.throwDeprecation 属性优先于 --trace-deprecationprocess.traceDeprecation

util.format(format[, ...args])#

中英对照

  • format <string> 一个类似 printf 的格式字符串。

util.format() 方法返回一个格式化后的字符串,使用第一个参数作为一个类似 printf 的格式。

第一个参数是一个字符串,包含零个或多个占位符。 每个占位符会被对应参数转换后的值所替换。 支持的占位符有:

  • %s - 字符串。
  • %d - 数值(整数或浮点数)。
  • %i - Integer.
  • %f - Floating point value.
  • %j - JSON。如果参数包含循环引用,则用字符串 '[Circular]' 替换。
  • %o - Object. A string representation of an object with generic JavaScript object formatting. Similar to util.inspect() with options { showHidden: true, depth: 4, showProxy: true }. This will show the full object including non-enumerable symbols and properties.
  • %O - Object. A string representation of an object with generic JavaScript object formatting. Similar to util.inspect() without options. This will show the full object not including non-enumerable symbols and properties.
  • %% - 单个百分号('%')。不消耗参数。

如果占位符没有对应的参数,则占位符不被替换。

util.format('%s:%s', 'foo');
// 返回: 'foo:%s'

如果传入 util.format() 方法的参数比占位符的数量多,则多出的参数会被强制转换为字符串,然后拼接到返回的字符串,参数之间用一个空格分隔。 Excessive arguments whose typeof is 'object' or 'symbol' (except null) will be transformed by util.inspect().

util.format('%s:%s', 'foo', 'bar', 'baz'); // 'foo:bar baz'

如果第一个参数不是一个字符串,则 util.format() 返回一个所有参数用空格分隔并连在一起的字符串。 每个参数都使用 util.inspect() 转换为一个字符串。

util.format(1, 2, 3); // '1 2 3'

If only one argument is passed to util.format(), it is returned as it is without any formatting.

util.format('%% %s'); // '%% %s'

util.formatWithOptions(inspectOptions, format[, ...args])#

暂无中英对照

This function is identical to util.format(), except in that it takes an inspectOptions argument which specifies options that are passed along to util.inspect().

util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });
// Returns 'See object { foo: 42 }', where `42` is colored as a number
// when printed to a terminal.

util.getSystemErrorName(err)#

暂无中英对照

Returns the string name for a numeric error code that comes from a Node.js API. The mapping between error codes and error names is platform-dependent. See Common System Errors for the names of common errors.

fs.access('file/that/does/not/exist', (err) => {
  const name = util.getSystemErrorName(err.errno);
  console.error(name);  // ENOENT
});

util.inherits(constructor, superConstructor)#

中英对照

注意,不建议使用 util.inherits()。 请使用 ES6 的 classextends 关键词获得语言层面的继承支持。 注意,这两种方式是语义上不兼容的

从一个构造函数中继承原型方法到另一个。 constructor 的原型会被设置到一个从 superConstructor 创建的新对象上。

superConstructor 可通过 constructor.super_ 属性访问。

const util = require('util');
const EventEmitter = require('events');

function MyStream() {
  EventEmitter.call(this);
}

util.inherits(MyStream, EventEmitter);

MyStream.prototype.write = function(data) {
  this.emit('data', data);
};

const stream = new MyStream();

console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true

stream.on('data', (data) => {
  console.log(`接收的数据:"${data}"`);
});
stream.write('运作良好!'); // 接收的数据:"运作良好!"

例子:使用 ES6 的 classextends

const EventEmitter = require('events');

class MyStream extends EventEmitter {
  write(data) {
    this.emit('data', data);
  }
}

const stream = new MyStream();

stream.on('data', (data) => {
  console.log(`接收的数据:"${data}"`);
});
stream.write('使用 ES6');

util.inspect(object[, options])#

util.inspect(object[, showHidden[, depth[, colors]]])#

暂无中英对照

  • object <any> Any JavaScript primitive or Object.
  • options <Object>

    • showHidden <boolean> If true, the object's non-enumerable symbols and properties will be included in the formatted result as well as WeakMap and WeakSet entries. Default: false.
    • depth <number> Specifies the number of times to recurse while formatting the object. This is useful for inspecting large complicated objects. To make it recurse up to the maximum call stack size pass Infinity or null. Default: 2.
    • colors <boolean> If true, the output will be styled with ANSI color codes. Colors are customizable, see Customizing util.inspect colors. Default: false.
    • customInspect <boolean> If false, then custom inspect(depth, opts) functions will not be called. Default: true.
    • showProxy <boolean> If true, then objects and functions that are Proxy objects will be introspected to show their target and handler objects. Default: false.

    • maxArrayLength <number> Specifies the maximum number of Array, TypedArray, WeakMap and WeakSet elements to include when formatting. Set to null or Infinity to show all elements. Set to 0 or negative to show no elements. Default: 100.
    • breakLength <number> The length at which an object's keys are split across multiple lines. Set to Infinity to format an object as a single line. Default: 60 for legacy compatibility.
    • compact <boolean> Setting this to false changes the default indentation to use a line break for each object key instead of lining up multiple properties in one line. It will also break text that is above the breakLength size into smaller and better readable chunks and indents objects the same as arrays. Note that no text will be reduced below 16 characters, no matter the breakLength size. For more information, see the example below. Default: true.
    • sorted <boolean> | <Function> If set to true or a function, all properties of an object and Set and Map entries will be sorted in the returned string. If set to true the default sort is going to be used. If set to a function, it is used as a compare function.
  • Returns: <string> The representation of passed object

The util.inspect() method returns a string representation of object that is intended for debugging. The output of util.inspect may change at any time and should not be depended upon programmatically. Additional options may be passed that alter certain aspects of the formatted string. util.inspect() will use the constructor's name and/or @@toStringTag to make an identifiable tag for an inspected value.

class Foo {
  get [Symbol.toStringTag]() {
    return 'bar';
  }
}

class Bar {}

const baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });

util.inspect(new Foo()); // 'Foo [bar] {}'
util.inspect(new Bar()); // 'Bar {}'
util.inspect(baz);       // '[foo] {}'

The following example inspects all properties of the util object:

const util = require('util');

console.log(util.inspect(util, { showHidden: true, depth: null }));

Values may supply their own custom inspect(depth, opts) functions, when called these receive the current depth in the recursive inspection, as well as the options object passed to util.inspect().

The following example highlights the difference with the compact option:

const util = require('util');

const o = {
  a: [1, 2, [[
    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +
      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',
    'test',
    'foo']], 4],
  b: new Map([['za', 1], ['zb', 'test']])
};
console.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));

// This will print

// { a:
//   [ 1,
//     2,
//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line
//           'test',
//           'foo' ] ],
//     4 ],
//   b: Map { 'za' => 1, 'zb' => 'test' } }

// Setting `compact` to false changes the output to be more reader friendly.
console.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));

// {
//   a: [
//     1,
//     2,
//     [
//       [
//         'Lorem ipsum dolor sit amet, consectetur ' +
//           'adipiscing elit, sed do eiusmod tempor ' +
//           'incididunt ut labore et dolore magna ' +
//           'aliqua.,
//         'test',
//         'foo'
//       ]
//     ],
//     4
//   ],
//   b: Map {
//     'za' => 1,
//     'zb' => 'test'
//   }
// }

// Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
// single line.
// Reducing the `breakLength` will split the "Lorem ipsum" text in smaller
// chunks.

Using the showHidden option allows to inspect WeakMap and WeakSet entries. If there are more entries than maxArrayLength, there is no guarantee which entries are displayed. That means retrieving the same WeakSet entries twice might actually result in a different output. Besides this any item might be collected at any point of time by the garbage collector if there is no strong reference left to that object. Therefore there is no guarantee to get a reliable output.

const { inspect } = require('util');

const obj = { a: 1 };
const obj2 = { b: 2 };
const weakSet = new WeakSet([obj, obj2]);

console.log(inspect(weakSet, { showHidden: true }));
// WeakSet { { a: 1 }, { b: 2 } }

The sorted option makes sure the output is identical, no matter of the properties insertion order:

const { inspect } = require('util');
const assert = require('assert');

const o1 = {
  b: [2, 3, 1],
  a: '`a` comes before `b`',
  c: new Set([2, 3, 1])
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }

const o2 = {
  c: new Set([2, 1, 3]),
  a: '`a` comes before `b`',
  b: [2, 3, 1]
};
assert.strict.equal(
  inspect(o1, { sorted: true }),
  inspect(o2, { sorted: true })
);

Please note that util.inspect() is a synchronous method that is mainly intended as a debugging tool. Some input values can have a significant performance overhead that can block the event loop. Use this function with care and never in a hot code path.

自定义 util.inspect 的颜色#

中英对照

可以通过 util.inspect.stylesutil.inspect.colors 属性全局地自定义 util.inspect 的颜色输出(如果已启用)。

util.inspect.styles 是一个映射,关联一个样式名到一个 util.inspect.colors 颜色。

默认的样式与关联的颜色有:

  • number - yellow
  • boolean - yellow
  • string - green
  • date - magenta
  • regexp - red
  • null - bold
  • undefined - grey
  • special - cyan (暂时只用于函数)
  • name - (无样式)

预定义的颜色代码有:whitegreyblackbluecyangreenmagentaredyellow。 还有 bolditalicunderlineinverse 代码。

颜色样式使用 ANSI 控制码,可能不是所有终端都支持。

自定义对象的查看函数#

中英对照

对象可以定义自己的 [util.inspect.custom](depth, opts)(或已废弃的 inspect(depth, opts)) 函数,util.inspect() 会调用并使用查看对象时的结果:

const util = require('util');

class Box {
  constructor(value) {
    this.value = value;
  }

  [util.inspect.custom](depth, options) {
    if (depth < 0) {
      return options.stylize('[Box]', 'special');
    }

    const newOptions = Object.assign({}, options, {
      depth: options.depth === null ? null : options.depth - 1
    });

    // 五个空格的填充,因为那是 "Box< " 的大小。
    const padding = ' '.repeat(5);
    const inner = util.inspect(this.value, newOptions)
                      .replace(/\n/g, `\n${padding}`);
    return `${options.stylize('Box', 'special')}< ${inner} >`;
  }
}

const box = new Box(true);

util.inspect(box);
// 返回: "Box< true >"

自定义的 [util.inspect.custom](depth, opts) 函数通常返回一个字符串,但也可以返回一个任何类型的值,它会相应地被 util.inspect() 格式化。

const util = require('util');

const obj = { foo: '这个不会出现在 inspect() 的输出中' };
obj[util.inspect.custom] = (depth) => {
  return { bar: 'baz' };
};

util.inspect(obj);
// 返回: "{ bar: 'baz' }"

util.inspect.custom#

中英对照

  • <symbol> that can be used to declare custom inspect functions.

In addition to being accessible through util.inspect.custom, this symbol is registered globally and can be accessed in any environment as Symbol.for('nodejs.util.inspect.custom').

const inspect = Symbol.for('nodejs.util.inspect.custom');

class Password {
  constructor(value) {
    this.value = value;
  }

  toString() {
    return 'xxxxxxxx';
  }

  [inspect]() {
    return `Password <${this.toString()}>`;
  }
}

const password = new Password('r0sebud');
console.log(password);
// Prints Password <xxxxxxxx>

详见自定义对象的查看函数

util.inspect.defaultOptions#

中英对照

defaultOptions 值允许对被 util.inspect 使用的默认选项进行自定义。 这对 console.logutil.format 等显式调用 util.inspect 的函数很有用。 它需被设为一个对象,包含一个或多个有效的 util.inspect() 选项。 也支持直接设置选项的属性。

const util = require('util');
const arr = Array(101).fill(0);

console.log(arr); // 打印截断的数组
util.inspect.defaultOptions.maxArrayLength = null;
console.log(arr); // 打印完整的数组

util.isDeepStrictEqual(val1, val2)#

暂无中英对照

Returns true if there is deep strict equality between val1 and val2. Otherwise, returns false.

See assert.deepStrictEqual() for more information about deep strict equality.

util.promisify(original)#

中英对照

让一个遵循异常优先的回调风格的函数, 即 (err, value) => ... 回调函数是最后一个参数, 返回一个返回值是一个 promise 版本的函数。

例如:

const util = require('util');
const fs = require('fs');

const stat = util.promisify(fs.stat);
stat('.').then((stats) => {
  // Do something with `stats`
}).catch((error) => {
  // Handle the error.
});

或者,使用async function获得等效的效果:

const util = require('util');
const fs = require('fs');

const stat = util.promisify(fs.stat);

async function callStat() {
  const stats = await stat('.');
  console.log(`This directory is owned by ${stats.uid}`);
}

如果原本就有 original[util.promisify.custom] 属性, promisify 会返回它的值, 查阅 Custom promisified functions.

promisify() 会在所有情况下假定 original 是一个最后的参数是回调函数的函数,如果它不是,那么返回的函数的返回值为 undefined。

自定义 promisify 函数#

暂无中英对照

Using the util.promisify.custom symbol one can override the return value of

const util = require('util');

function doSomething(foo, callback) {
  // ...
}

doSomething[util.promisify.custom] = (foo) => {
  return getPromiseSomehow();
};

const promisified = util.promisify(doSomething);
console.log(promisified === doSomething[util.promisify.custom]);
// prints 'true'

This can be useful for cases where the original function does not follow the standard format of taking an error-first callback as the last argument.

For example, with a function that takes in (foo, onSuccessCallback, onErrorCallback):

doSomething[util.promisify.custom] = (foo) => {
  return new Promise((resolve, reject) => {
    doSomething(foo, resolve, reject);
  });
};

If promisify.custom is defined but is not a function, promisify() will throw an error.

util.promisify.custom#

暂无中英对照

A <symbol> that can be used to declare custom promisified variants of functions, see Custom promisified functions.

util.TextDecoder 类#

暂无中英对照

An implementation of the WHATWG Encoding Standard TextDecoder API.

const decoder = new TextDecoder('shift_jis');
let string = '';
let buffer;
while (buffer = getNextChunkSomehow()) {
  string += decoder.decode(buffer, { stream: true });
}
string += decoder.decode(); // end-of-stream

WHATWG 支持的字符编码#

暂无中英对照

Per the WHATWG Encoding Standard, the encodings supported by the TextDecoder API are outlined in the tables below. For each encoding, one or more aliases may be used.

Different Node.js build configurations support different sets of encodings. While a very basic set of encodings is supported even on Node.js builds without ICU enabled, support for some encodings is provided only when Node.js is built with ICU and using the full ICU data (see Internationalization).

无 ICU 的字符编码#

暂无中英对照

EncodingAliases
'utf-8''unicode-1-1-utf-8', 'utf8'
'utf-16le''utf-16'

有 ICU 的字符编码#

暂无中英对照

EncodingAliases
'utf-8''unicode-1-1-utf-8', 'utf8'
'utf-16le''utf-16'
'utf-16be'

需要完整 ICU 数据的字符编码#

暂无中英对照

EncodingAliases
'ibm866''866', 'cp866', 'csibm866'
'iso-8859-2''csisolatin2', 'iso-ir-101', 'iso8859-2', 'iso88592', 'iso_8859-2', 'iso_8859-2:1987', 'l2', 'latin2'
'iso-8859-3''csisolatin3', 'iso-ir-109', 'iso8859-3', 'iso88593', 'iso_8859-3', 'iso_8859-3:1988', 'l3', 'latin3'
'iso-8859-4''csisolatin4', 'iso-ir-110', 'iso8859-4', 'iso88594', 'iso_8859-4', 'iso_8859-4:1988', 'l4', 'latin4'
'iso-8859-5''csisolatincyrillic', 'cyrillic', 'iso-ir-144', 'iso8859-5', 'iso88595', 'iso_8859-5', 'iso_8859-5:1988'
'iso-8859-6''arabic', 'asmo-708', 'csiso88596e', 'csiso88596i', 'csisolatinarabic', 'ecma-114', 'iso-8859-6-e', 'iso-8859-6-i', 'iso-ir-127', 'iso8859-6', 'iso88596', 'iso_8859-6', 'iso_8859-6:1987'
'iso-8859-7''csisolatingreek', 'ecma-118', 'elot_928', 'greek', 'greek8', 'iso-ir-126', 'iso8859-7', 'iso88597', 'iso_8859-7', 'iso_8859-7:1987', 'sun_eu_greek'
'iso-8859-8''csiso88598e', 'csisolatinhebrew', 'hebrew', 'iso-8859-8-e', 'iso-ir-138', 'iso8859-8', 'iso88598', 'iso_8859-8', 'iso_8859-8:1988', 'visual'
'iso-8859-8-i''csiso88598i', 'logical'
'iso-8859-10''csisolatin6', 'iso-ir-157', 'iso8859-10', 'iso885910', 'l6', 'latin6'
'iso-8859-13''iso8859-13', 'iso885913'
'iso-8859-14''iso8859-14', 'iso885914'
'iso-8859-15''csisolatin9', 'iso8859-15', 'iso885915', 'iso_8859-15', 'l9'
'koi8-r''cskoi8r', 'koi', 'koi8', 'koi8_r'
'koi8-u''koi8-ru'
'macintosh''csmacintosh', 'mac', 'x-mac-roman'
'windows-874''dos-874', 'iso-8859-11', 'iso8859-11', 'iso885911', 'tis-620'
'windows-1250''cp1250', 'x-cp1250'
'windows-1251''cp1251', 'x-cp1251'
'windows-1252''ansi_x3.4-1968', 'ascii', 'cp1252', 'cp819', 'csisolatin1', 'ibm819', 'iso-8859-1', 'iso-ir-100', 'iso8859-1', 'iso88591', 'iso_8859-1', 'iso_8859-1:1987', 'l1', 'latin1', 'us-ascii', 'x-cp1252'
'windows-1253''cp1253', 'x-cp1253'
'windows-1254''cp1254', 'csisolatin5', 'iso-8859-9', 'iso-ir-148', 'iso8859-9', 'iso88599', 'iso_8859-9', 'iso_8859-9:1989', 'l5', 'latin5', 'x-cp1254'
'windows-1255''cp1255', 'x-cp1255'
'windows-1256''cp1256', 'x-cp1256'
'windows-1257''cp1257', 'x-cp1257'
'windows-1258''cp1258', 'x-cp1258'
'x-mac-cyrillic''x-mac-ukrainian'
'gbk''chinese', 'csgb2312', 'csiso58gb231280', 'gb2312', 'gb_2312', 'gb_2312-80', 'iso-ir-58', 'x-gbk'
'gb18030'
'big5''big5-hkscs', 'cn-big5', 'csbig5', 'x-x-big5'
'euc-jp''cseucpkdfmtjapanese', 'x-euc-jp'
'iso-2022-jp''csiso2022jp'
'shift_jis''csshiftjis', 'ms932', 'ms_kanji', 'shift-jis', 'sjis', 'windows-31j', 'x-sjis'
'euc-kr''cseuckr', 'csksc56011987', 'iso-ir-149', 'korean', 'ks_c_5601-1987', 'ks_c_5601-1989', 'ksc5601', 'ksc_5601', 'windows-949'

The 'iso-8859-16' encoding listed in the WHATWG Encoding Standard is not supported.

new TextDecoder([encoding[, options]])#

暂无中英对照

  • encoding <string> Identifies the encoding that this TextDecoder instance supports. Default: 'utf-8'.
  • options <Object>

    • fatal <boolean> true if decoding failures are fatal. This option is only supported when ICU is enabled (see Internationalization). Default: false.
    • ignoreBOM <boolean> When true, the TextDecoder will include the byte order mark in the decoded result. When false, the byte order mark will be removed from the output. This option is only used when encoding is 'utf-8', 'utf-16be' or 'utf-16le'. Default: false.

Creates an new TextDecoder instance. The encoding may specify one of the supported encodings or an alias.

textDecoder.decode([input[, options]])#

暂无中英对照

Decodes the input and returns a string. If options.stream is true, any incomplete byte sequences occurring at the end of the input are buffered internally and emitted after the next call to textDecoder.decode().

If textDecoder.fatal is true, decoding errors that occur will result in a TypeError being thrown.

textDecoder.encoding#

暂无中英对照

The encoding supported by the TextDecoder instance.

textDecoder.fatal#

暂无中英对照

The value will be true if decoding errors result in a TypeError being thrown.

textDecoder.ignoreBOM#

暂无中英对照

The value will be true if the decoding result will include the byte order mark.

Class: util.TextEncoder#

暂无中英对照

An implementation of the WHATWG Encoding Standard TextEncoder API. All instances of TextEncoder only support UTF-8 encoding.

const encoder = new TextEncoder();
const uint8array = encoder.encode('this is some data');

textEncoder.encode([input])#

暂无中英对照

UTF-8 encodes the input string and returns a Uint8Array containing the encoded bytes.

textEncoder.encoding#

暂无中英对照

The encoding supported by the TextEncoder instance. Always set to 'utf-8'.

util.types#

暂无中英对照

util.types provides a number of type checks for different kinds of built-in objects. Unlike instanceof or Object.prototype.toString.call(value), these checks do not inspect properties of the object that are accessible from JavaScript (like their prototype), and usually have the overhead of calling into C++.

The result generally does not make any guarantees about what kinds of properties or behavior a value exposes in JavaScript. They are primarily useful for addon developers who prefer to do type checking in JavaScript.

util.types.isAnyArrayBuffer(value)#

暂无中英对照

Returns true if the value is a built-in ArrayBuffer or SharedArrayBuffer instance.

See also util.types.isArrayBuffer() and util.types.isSharedArrayBuffer().

util.types.isAnyArrayBuffer(new ArrayBuffer());  // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer());  // Returns true

util.types.isArgumentsObject(value)#

暂无中英对照

Returns true if the value is an arguments object.

function foo() {
  util.types.isArgumentsObject(arguments);  // Returns true
}

util.types.isArrayBuffer(value)#

暂无中英对照

Returns true if the value is a built-in ArrayBuffer instance. This does not include SharedArrayBuffer instances. Usually, it is desirable to test for both; See util.types.isAnyArrayBuffer() for that.

util.types.isArrayBuffer(new ArrayBuffer());  // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer());  // Returns false

util.types.isAsyncFunction(value)#

暂无中英对照

Returns true if the value is an async function. Note that this only reports back what the JavaScript engine is seeing; in particular, the return value may not match the original source code if a transpilation tool was used.

util.types.isAsyncFunction(function foo() {});  // Returns false
util.types.isAsyncFunction(async function foo() {});  // Returns true

util.types.isBigInt64Array(value)#

暂无中英对照

Returns true if the value is a BigInt64Array instance.

util.types.isBigInt64Array(new BigInt64Array());   // Returns true
util.types.isBigInt64Array(new BigUint64Array());  // Returns false

util.types.isBigUint64Array(value)#

暂无中英对照

Returns true if the value is a BigUint64Array instance.

util.types.isBigUint64Array(new BigInt64Array());   // Returns false
util.types.isBigUint64Array(new BigUint64Array());  // Returns true

util.types.isBooleanObject(value)#

暂无中英对照

Returns true if the value is a boolean object, e.g. created by new Boolean().

util.types.isBooleanObject(false);  // Returns false
util.types.isBooleanObject(true);   // Returns false
util.types.isBooleanObject(new Boolean(false)); // Returns true
util.types.isBooleanObject(new Boolean(true));  // Returns true
util.types.isBooleanObject(Boolean(false)); // Returns false
util.types.isBooleanObject(Boolean(true));  // Returns false

util.types.isBoxedPrimitive(value)#

暂无中英对照

Returns true if the value is any boxed primitive object, e.g. created by new Boolean(), new String() or Object(Symbol()).

For example:

util.types.isBoxedPrimitive(false); // Returns false
util.types.isBoxedPrimitive(new Boolean(false)); // Returns true
util.types.isBoxedPrimitive(Symbol('foo')); // Returns false
util.types.isBoxedPrimitive(Object(Symbol('foo'))); // Returns true
util.types.isBoxedPrimitive(Object(BigInt(5))); // Returns true

util.types.isDataView(value)#

暂无中英对照

Returns true if the value is a built-in DataView instance.

const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab));  // Returns true
util.types.isDataView(new Float64Array());  // Returns false

See also ArrayBuffer.isView().

util.types.isDate(value)#

暂无中英对照

Returns true if the value is a built-in Date instance.

util.types.isDate(new Date());  // Returns true

util.types.isExternal(value)#

暂无中英对照

Returns true if the value is a native External value.

util.types.isFloat32Array(value)#

暂无中英对照

Returns true if the value is a built-in Float32Array instance.

util.types.isFloat32Array(new ArrayBuffer());  // Returns false
util.types.isFloat32Array(new Float32Array());  // Returns true
util.types.isFloat32Array(new Float64Array());  // Returns false

util.types.isFloat64Array(value)#

暂无中英对照

Returns true if the value is a built-in Float64Array instance.

util.types.isFloat64Array(new ArrayBuffer());  // Returns false
util.types.isFloat64Array(new Uint8Array());  // Returns false
util.types.isFloat64Array(new Float64Array());  // Returns true

util.types.isGeneratorFunction(value)#

暂无中英对照

Returns true if the value is a generator function. Note that this only reports back what the JavaScript engine is seeing; in particular, the return value may not match the original source code if a transpilation tool was used.

util.types.isGeneratorFunction(function foo() {});  // Returns false
util.types.isGeneratorFunction(function* foo() {});  // Returns true

util.types.isGeneratorObject(value)#

暂无中英对照

Returns true if the value is a generator object as returned from a built-in generator function. Note that this only reports back what the JavaScript engine is seeing; in particular, the return value may not match the original source code if a transpilation tool was used.

function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator);  // Returns true

util.types.isInt8Array(value)#

暂无中英对照

Returns true if the value is a built-in Int8Array instance.

util.types.isInt8Array(new ArrayBuffer());  // Returns false
util.types.isInt8Array(new Int8Array());  // Returns true
util.types.isInt8Array(new Float64Array());  // Returns false

util.types.isInt16Array(value)#

暂无中英对照

Returns true if the value is a built-in Int16Array instance.

util.types.isInt16Array(new ArrayBuffer());  // Returns false
util.types.isInt16Array(new Int16Array());  // Returns true
util.types.isInt16Array(new Float64Array());  // Returns false

util.types.isInt32Array(value)#

暂无中英对照

Returns true if the value is a built-in Int32Array instance.

util.types.isInt32Array(new ArrayBuffer());  // Returns false
util.types.isInt32Array(new Int32Array());  // Returns true
util.types.isInt32Array(new Float64Array());  // Returns false

util.types.isMap(value)#

暂无中英对照

Returns true if the value is a built-in Map instance.

util.types.isMap(new Map());  // Returns true

util.types.isMapIterator(value)#

暂无中英对照

Returns true if the value is an iterator returned for a built-in Map instance.

const map = new Map();
util.types.isMapIterator(map.keys());  // Returns true
util.types.isMapIterator(map.values());  // Returns true
util.types.isMapIterator(map.entries());  // Returns true
util.types.isMapIterator(map[Symbol.iterator]());  // Returns true

util.types.isModuleNamespaceObject(value)#

暂无中英对照

Returns true if the value is an instance of a Module Namespace Object.

import * as ns from './a.js';

util.types.isModuleNamespaceObject(ns);  // Returns true

util.types.isNativeError(value)#

暂无中英对照

Returns true if the value is an instance of a built-in Error type.

util.types.isNativeError(new Error());  // Returns true
util.types.isNativeError(new TypeError());  // Returns true
util.types.isNativeError(new RangeError());  // Returns true

util.types.isNumberObject(value)#

暂无中英对照

Returns true if the value is a number object, e.g. created by new Number().

util.types.isNumberObject(0);  // Returns false
util.types.isNumberObject(new Number(0));   // Returns true

util.types.isPromise(value)#

暂无中英对照

Returns true if the value is a built-in Promise.

util.types.isPromise(Promise.resolve(42));  // Returns true

util.types.isProxy(value)#

暂无中英对照

Returns true if the value is a Proxy instance.

const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target);  // Returns false
util.types.isProxy(proxy);  // Returns true

util.types.isRegExp(value)#

暂无中英对照

Returns true if the value is a regular expression object.

util.types.isRegExp(/abc/);  // Returns true
util.types.isRegExp(new RegExp('abc'));  // Returns true

util.types.isSet(value)#

暂无中英对照

Returns true if the value is a built-in Set instance.

util.types.isSet(new Set());  // Returns true

util.types.isSetIterator(value)#

暂无中英对照

Returns true if the value is an iterator returned for a built-in Set instance.

const set = new Set();
util.types.isSetIterator(set.keys());  // Returns true
util.types.isSetIterator(set.values());  // Returns true
util.types.isSetIterator(set.entries());  // Returns true
util.types.isSetIterator(set[Symbol.iterator]());  // Returns true

util.types.isSharedArrayBuffer(value)#

暂无中英对照

Returns true if the value is a built-in SharedArrayBuffer instance. This does not include ArrayBuffer instances. Usually, it is desirable to test for both; See util.types.isAnyArrayBuffer() for that.

util.types.isSharedArrayBuffer(new ArrayBuffer());  // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer());  // Returns true

util.types.isStringObject(value)#

暂无中英对照

Returns true if the value is a string object, e.g. created by new String().

util.types.isStringObject('foo');  // Returns false
util.types.isStringObject(new String('foo'));   // Returns true

util.types.isSymbolObject(value)#

暂无中英对照

Returns true if the value is a symbol object, created by calling Object() on a Symbol primitive.

const symbol = Symbol('foo');
util.types.isSymbolObject(symbol);  // Returns false
util.types.isSymbolObject(Object(symbol));   // Returns true

util.types.isTypedArray(value)#

暂无中英对照

Returns true if the value is a built-in TypedArray instance.

util.types.isTypedArray(new ArrayBuffer());  // Returns false
util.types.isTypedArray(new Uint8Array());  // Returns true
util.types.isTypedArray(new Float64Array());  // Returns true

See also ArrayBuffer.isView().

util.types.isUint8Array(value)#

暂无中英对照

Returns true if the value is a built-in Uint8Array instance.

util.types.isUint8Array(new ArrayBuffer());  // Returns false
util.types.isUint8Array(new Uint8Array());  // Returns true
util.types.isUint8Array(new Float64Array());  // Returns false

util.types.isUint8ClampedArray(value)#

暂无中英对照

Returns true if the value is a built-in Uint8ClampedArray instance.

util.types.isUint8ClampedArray(new ArrayBuffer());  // Returns false
util.types.isUint8ClampedArray(new Uint8ClampedArray());  // Returns true
util.types.isUint8ClampedArray(new Float64Array());  // Returns false

util.types.isUint16Array(value)#

暂无中英对照

Returns true if the value is a built-in Uint16Array instance.

util.types.isUint16Array(new ArrayBuffer());  // Returns false
util.types.isUint16Array(new Uint16Array());  // Returns true
util.types.isUint16Array(new Float64Array());  // Returns false

util.types.isUint32Array(value)#

暂无中英对照

Returns true if the value is a built-in Uint32Array instance.

util.types.isUint32Array(new ArrayBuffer());  // Returns false
util.types.isUint32Array(new Uint32Array());  // Returns true
util.types.isUint32Array(new Float64Array());  // Returns false

util.types.isWeakMap(value)#

暂无中英对照

Returns true if the value is a built-in WeakMap instance.

util.types.isWeakMap(new WeakMap());  // Returns true

util.types.isWeakSet(value)#

暂无中英对照

Returns true if the value is a built-in WeakSet instance.

util.types.isWeakSet(new WeakSet());  // Returns true

util.types.isWebAssemblyCompiledModule(value)#

暂无中英对照

Returns true if the value is a built-in WebAssembly.Module instance.

const module = new WebAssembly.Module(wasmBuffer);
util.types.isWebAssemblyCompiledModule(module);  // Returns true

废弃的 API#

中英对照

以下 API 已被废弃,不应该再被使用。 现存的应用和模块应该使用替代方法更新。

util._extend(target, source)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 Object.assign() 代替。

The util._extend() method was never intended to be used outside of internal Node.js modules. The community found and used it anyway.

It is deprecated and should not be used in new code. JavaScript comes with very similar built-in functionality through Object.assign().

util.debug(string)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 console.error() 代替。

  • string <string> The message to print to stderr

Deprecated predecessor of console.error.

util.error([...strings])#

暂无中英对照

稳定性: 0 - 废弃的: 使用 console.error() 代替。

  • ...strings <string> The message to print to stderr

Deprecated predecessor of console.error.

util.isArray(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 Array.isArray() 代替。

Alias for Array.isArray().

Returns true if the given object is an Array. Otherwise, returns false.

const util = require('util');

util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false

util.isBoolean(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 typeof value === 'boolean' 代替。

Returns true if the given object is a Boolean. Otherwise, returns false.

const util = require('util');

util.isBoolean(1);
// Returns: false
util.isBoolean(0);
// Returns: false
util.isBoolean(false);
// Returns: true

util.isBuffer(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 Buffer.isBuffer() 代替。

Returns true if the given object is a Buffer. Otherwise, returns false.

const util = require('util');

util.isBuffer({ length: 0 });
// Returns: false
util.isBuffer([]);
// Returns: false
util.isBuffer(Buffer.from('hello world'));
// Returns: true

util.isDate(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 util.types.isDate() 代替。

Returns true if the given object is a Date. Otherwise, returns false.

const util = require('util');

util.isDate(new Date());
// Returns: true
util.isDate(Date());
// false (without 'new' returns a String)
util.isDate({});
// Returns: false

util.isError(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 util.types.isNativeError() 代替。

Returns true if the given object is an Error. Otherwise, returns false.

const util = require('util');

util.isError(new Error());
// Returns: true
util.isError(new TypeError());
// Returns: true
util.isError({ name: 'Error', message: 'an error occurred' });
// Returns: false

Note that this method relies on Object.prototype.toString() behavior. It is possible to obtain an incorrect result when the object argument manipulates @@toStringTag.

const util = require('util');
const obj = { name: 'Error', message: 'an error occurred' };

util.isError(obj);
// Returns: false
obj[Symbol.toStringTag] = 'Error';
util.isError(obj);
// Returns: true

util.isFunction(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 typeof value === 'function' 代替。

Returns true if the given object is a Function. Otherwise, returns false.

const util = require('util');

function Foo() {}
const Bar = () => {};

util.isFunction({});
// Returns: false
util.isFunction(Foo);
// Returns: true
util.isFunction(Bar);
// Returns: true

util.isNull(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 value === null 代替。

Returns true if the given object is strictly null. Otherwise, returns false.

const util = require('util');

util.isNull(0);
// Returns: false
util.isNull(undefined);
// Returns: false
util.isNull(null);
// Returns: true

util.isNullOrUndefined(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 value === undefined || value === null 代替。

Returns true if the given object is null or undefined. Otherwise, returns false.

const util = require('util');

util.isNullOrUndefined(0);
// Returns: false
util.isNullOrUndefined(undefined);
// Returns: true
util.isNullOrUndefined(null);
// Returns: true

util.isNumber(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 typeof value === 'number' 代替。

Returns true if the given object is a Number. Otherwise, returns false.

const util = require('util');

util.isNumber(false);
// Returns: false
util.isNumber(Infinity);
// Returns: true
util.isNumber(0);
// Returns: true
util.isNumber(NaN);
// Returns: true

util.isObject(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 value !== null && typeof value === 'object' 代替。

Returns true if the given object is strictly an Object and not a Function (even though functions are objects in JavaScript). Otherwise, returns false.

const util = require('util');

util.isObject(5);
// Returns: false
util.isObject(null);
// Returns: false
util.isObject({});
// Returns: true
util.isObject(() => {});
// Returns: false

util.isPrimitive(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 (typeof value !== 'object' && typeof value !== 'function') || value === null 代替。

Returns true if the given object is a primitive type. Otherwise, returns false.

const util = require('util');

util.isPrimitive(5);
// Returns: true
util.isPrimitive('foo');
// Returns: true
util.isPrimitive(false);
// Returns: true
util.isPrimitive(null);
// Returns: true
util.isPrimitive(undefined);
// Returns: true
util.isPrimitive({});
// Returns: false
util.isPrimitive(() => {});
// Returns: false
util.isPrimitive(/^$/);
// Returns: false
util.isPrimitive(new Date());
// Returns: false

util.isRegExp(object)#

暂无中英对照

稳定性: 0 - 废弃的

Returns true if the given object is a RegExp. Otherwise, returns false.

const util = require('util');

util.isRegExp(/some regexp/);
// Returns: true
util.isRegExp(new RegExp('another regexp'));
// Returns: true
util.isRegExp({});
// Returns: false

util.isString(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 typeof value === 'string' 代替。

Returns true if the given object is a string. Otherwise, returns false.

const util = require('util');

util.isString('');
// Returns: true
util.isString('foo');
// Returns: true
util.isString(String('foo'));
// Returns: true
util.isString(5);
// Returns: false

util.isSymbol(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 typeof value === 'symbol' 代替。

Returns true if the given object is a Symbol. Otherwise, returns false.

const util = require('util');

util.isSymbol(5);
// Returns: false
util.isSymbol('foo');
// Returns: false
util.isSymbol(Symbol('foo'));
// Returns: true

util.isUndefined(object)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 value === undefined 代替。

Returns true if the given object is undefined. Otherwise, returns false.

const util = require('util');

const foo = undefined;
util.isUndefined(5);
// Returns: false
util.isUndefined(foo);
// Returns: true
util.isUndefined(null);
// Returns: false

util.log(string)#

暂无中英对照

稳定性: 0 - 废弃的: 使用 a third party module 代替。

The util.log() method prints the given string to stdout with an included timestamp.

const util = require('util');

util.log('Timestamped message.');

util.print([...strings])#

暂无中英对照

稳定性: 0 - 废弃的: 使用 console.log() 代替。

Deprecated predecessor of console.log.

util.puts([...strings])#

暂无中英对照

稳定性: 0 - 废弃的: 使用 console.log() 代替。

Deprecated predecessor of console.log.