util（实用工具）#

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

const util = require('util');

`util.callbackify(original)`#

新增于: v8.2.0

original <Function> async 异步函数。
返回: <Function> 传统回调函数。

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

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 拒绝的原因且带有返回值，且值可以转换成布尔值 false，这个值会被封装在 Error 对象里，可以通过属性 reason 获取。

function fn() {
  return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  // 当 Promise 被以 `null` 拒绝时，它被包装为 Error 并且原始值存储在 `reason` 中。
  err && err.hasOwnProperty('reason') && err.reason === null;  // true
});

`util.debuglog(section[, callback])`#

新增于: v0.11.3

section <string> 一个字符串，指定要为应用的哪些部分创建 debuglog 函数。
callback <Function> A callback invoked the first time the logging function is called with a function argument that is a more optimized logging function.
返回: <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。如果运行时没带上环境变量集合，则不会打印任何东西。

section 还支持通配符：

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

debuglog('hi there, it\'s foo-bar [%d]', 2333);

如果在环境中使用 NODE_DEBUG=foo* 运行，那么它将输出如下内容：

FOO-BAR 3257: hi there, it's foo-bar [2333]

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

The optional callback argument can be used to replace the logging function with a different function that doesn't have any initialization or unnecessary wrapping.

const util = require('util');
let debuglog = util.debuglog('internals', (debug) => {
  // Replace with a logging function that optimizes out
  // testing if the section is enabled
  debuglog = debug;
});

`debuglog().enabled`#

新增于: v14.9.0

<boolean>

The util.debuglog().enabled getter is used to create a test that can be used in conditionals based on the existence of the NODE_DEBUG environment variable. If the section name appears within the value of that environment variable, then the returned value will be true. If not, then the returned value will be false.

const util = require('util');
const enabled = util.debuglog('foo').enabled;
if (enabled) {
  console.log('hello from foo [%d]', 123);
}

If this program is run with NODE_DEBUG=foo in the environment, then it will output something like:

hello from foo [123]

`util.debug(section)`#

新增于: v14.9.0

Alias for util.debuglog. Usage allows for readability of that doesn't imply logging when only using util.debuglog().enabled.

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

版本历史

版本	变更
v10.0.0	Deprecation warnings are only emitted once for each code.
v0.8.0	新增于: v0.8.0

fn <Function> 要被弃用的函数。
msg <string> 当调用弃用的函数时显示的警告消息。
code <string> 弃用码。有关代码列表，请参见弃用的 API 列。
返回: <Function> 弃用的函数被包装以发出警告。

util.deprecate() 方法以一种标记为已弃用的方式包装 fn（可以是函数或类）。

const util = require('util');

exports.obsoleteFunction = util.deprecate(() => {
  // 一些操作。
}, 'obsoleteFunction() 已弃用，使用 newShinyFunction() 代替');

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

如果在对 util.deprecate() 的多次调用中提供了相同的可选 code，则该 code 仅触发一次警告。

const util = require('util');

const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');
const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');
fn1(); // 使用代码 DEP0001 触发弃用警告。
fn2(); // 不会触发弃用警告，因为它具有相同的代码。

如果使用了 --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-deprecation 和 process.traceDeprecation。

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

版本历史

版本	变更
v12.11.0	The `%c` specifier is ignored now.
v12.0.0	The `format` argument is now only taken as such if it actually contains format specifiers.
v12.0.0	If the `format` argument is not a format string, the output string's formatting is no longer dependent on the type of the first argument. This change removes previously present quotes from strings that were being output when the first argument was not a string.
v11.4.0	The `%d`, `%f` and `%i` specifiers now support Symbols properly.
v11.4.0	The `%o` specifier's `depth` has default depth of 4 again.
v11.0.0	The `%o` specifier's `depth` option will now fall back to the default depth.
v10.12.0	The `%d` and `%i` specifiers now support BigInt.
v8.4.0	The `%o` and `%O` specifiers are supported now.
v0.5.3	新增于: v0.5.3

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

util.format() 方法返回一个格式化后的字符串，使用第一个参数作为一个类似 printf 的格式的字符串，该字符串可以包含零个或多个格式占位符。每个占位符会被对应参数转换后的值所替换。支持的占位符有：

%s - String 将用于转换除 BigInt、 Object 和 -0 外的所有值。BigInt 值将用 n 表示，而没有用户定义 toString 函数的对象使用带有选项 { depth: 0, colors: false, compact: 3 } 的 util.inspect() 进行检查。
%d - Number 将用于转换除 BigInt 和 Symbol 之外的所有值。
%i - parseInt(value, 10) 用于除 BigInt 和 Symbol 之外的所有值。
%f - parseFloat(value) 用于除 BigInt 和 Symbol 之外的所有值。
%j - JSON。如果参数包含循环引用，则替换为字符串 '[Circular]'。
%o - Object。具有通用 JavaScript 对象格式的对象的字符串表示形式。类似于带有选项 { showHidden: true, showProxy: true } 的 util.inspect()。这将显示完整对象，包括非可枚举属性和代理。
%O - Object。具有通用 JavaScript 对象格式的对象的字符串表示形式。类似于 util.inspect() 但没有选项。这将显示完整对象，不包括非可枚举属性和代理。
%c - CSS。该说明符会被忽略，将会跳过任何传入的 CSS。
%% - 单个百分号（'%'）。这不会消耗参数。
返回: <string> 格式化的字符串。

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

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

如果类型不是 string，则使用 util.inspect() 格式化不属于格式字符串的值。

如果传入 util.format() 方法的参数比占位符的数量多，则多出的参数会被强制转换为字符串，然后拼接到返回的字符串，参数之间用一个空格分隔。

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

如果第一个参数不是一个字符串，则 util.format() 返回一个所有参数用空格分隔并连在一起的字符串。

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

如果只有一个参数传给 util.format()，它将按原样返回，不带任何格式：

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

util.format() 是一种用作调试工具的同步方法。某些输入值可能会产生严重的性能开销，从而阻止事件循环。请谨慎使用此功能，切勿在热代码路径中使用。

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

新增于: v10.0.0

inspectOptions <Object>
format <string>

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

新增于: v9.7.0

err <number>
Returns: <string>

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

版本历史

版本	变更
v5.0.0	The `constructor` parameter can refer to an ES6 class now.
v0.3.0	新增于: v0.3.0

constructor <Function>
superConstructor <Function>

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

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

这主要在 Object.setPrototypeOf(constructor.prototype, superConstructor.prototype) 之上添加了一些输入验证。作为额外的便利，可以通过 constructor.super_属性访问 superConstructor。

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 的 class 和 extends 的示例：

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]]])`#

版本历史

版本	变更
v13.0.0	Circular references now include a marker to the reference.
v14.6.0, v12.19.0	If `object` is from a different `vm.Context` now, a custom inspection function on it will not receive context-specific arguments anymore.
v13.13.0, v12.17.0	The `maxStringLength` option is supported now.
v13.5.0, v12.16.0	User defined prototype properties are inspected in case `showHidden` is `true`.
v12.0.0	The `compact` options default is changed to `3` and the `breakLength` options default is changed to `80`.
v12.0.0	Internal properties no longer appear in the context argument of a custom inspection function.
v11.11.0	The `compact` option accepts numbers for a new output mode.
v11.7.0	ArrayBuffers now also show their binary contents.
v11.5.0	The `getters` option is supported now.
v11.4.0	The `depth` default changed back to `2`.
v11.0.0	The `depth` default changed to `20`.
v11.0.0	The inspection output is now limited to about 128 MB. Data above that size will not be fully inspected.
v10.12.0	The `sorted` option is supported now.
v10.6.0	Inspecting linked lists and similar objects is now possible up to the maximum call stack size.
v10.0.0	The `WeakMap` and `WeakSet` entries can now be inspected as well.
v9.9.0	The `compact` option is supported now.
v6.6.0	Custom inspection functions can now return `this`.
v6.3.0	The `breakLength` option is supported now.
v6.1.0	The `maxArrayLength` option is supported now; in particular, long arrays are truncated by default.
v6.1.0	The `showProxy` option is supported now.
v0.3.0	新增于: v0.3.0

object <any> Any JavaScript primitive or Object.
options <Object>
- showHidden <boolean> If true, object's non-enumerable symbols and properties are included in the formatted result. WeakMap and WeakSet entries are also included as well as user defined prototype properties (excluding method properties). Default: false.
- depth <number> Specifies the number of times to recurse while formatting object. This is useful for inspecting large objects. To recurse up to the maximum call stack size pass Infinity or null. Default: 2.
- colors <boolean> If true, the output is styled with ANSI color codes. Colors are customizable. See Customizing util.inspect colors. Default: false.
- customInspect <boolean> If false, [util.inspect.custom](depth, opts) functions are not invoked. Default: true.
- showProxy <boolean> If true, Proxy inspection includes the target and handler objects. Default: false.
- maxArrayLength <integer> 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.
- maxStringLength <integer> Specifies the maximum number of characters to include when formatting. Set to null or Infinity to show all elements. Set to 0 or negative to show no characters. Default: Infinity.
- breakLength <integer> The length at which input values are split across multiple lines. Set to Infinity to format the input as a single line (in combination with compact set to true or any number >= 1). Default: 80.
- compact <boolean> | <integer> Setting this to false causes each object key to be displayed on a new line. It will also add new lines to text that is longer than breakLength. If set to a number, the most n inner elements are united on a single line as long as all properties fit into breakLength. Short array elements are also grouped together. No text will be reduced below 16 characters, no matter the breakLength size. For more information, see the example below. Default: 3.
- sorted <boolean> | <Function> If set to true or a function, all properties of an object, and Set and Map entries are sorted in the resulting string. If set to true the default sort is used. If set to a function, it is used as a compare function.
- getters <boolean> | <string> If set to true, getters are inspected. If set to 'get', only getters without a corresponding setter are inspected. If set to 'set', only getters with a corresponding setter are inspected. This might cause side effects depending on the getter function. Default: false.
Returns: <string> The representation of 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 the result. 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] {}'

Circular references point to their anchor by using a reference index:

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

const obj = {};
obj.a = [obj];
obj.b = {};
obj.b.inner = obj.b;
obj.b.obj = obj;

console.log(inspect(obj));
// <ref *1> {
//   a: [ [Circular *1] ],
//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
// }

The following example inspects all properties of the util object:

const util = require('util');

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

The following example highlights the effect of 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 }));

// { a:
//   [ 1,
//     2,
//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line
//           'test',
//           'foo' ] ],
//     4 ],
//   b: Map(2) { '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(2) {
//     '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.

The showHidden option allows WeakMap and WeakSet entries to be inspected. If there are more entries than maxArrayLength, there is no guarantee which entries are displayed. That means retrieving the same WeakSet entries twice may result in different output. Furthermore, entries with no remaining strong references may be garbage collected at any time.

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 ensures that an object's property insertion order does not impact the result of util.inspect().

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(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 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 })
);

util.inspect() is a synchronous method intended for debugging. Its maximum output length is approximately 128 MB. Inputs that result in longer output will be truncated.

自定义 util.inspect 的颜色#

可以通过 util.inspect.styles 和 util.inspect.colors 属性全局地自定义 util.inspect 的颜色输出（如果已启用）。

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

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

bigint - yellow
boolean - yellow
date - magenta
module - underline
name - (no styling)
null - bold
number - yellow
regexp - red
special - cyan (例如 Proxies)
string - green
symbol - green
undefined - grey

颜色样式使用 ANSI 控制码，可能不是所有终端都支持。要验证颜色支持，请使用 tty.hasColors()。

下面列出了预定义的控制代码（分为“修饰符”、“前景颜色”和“背景颜色”）。

修饰符#

Modifier support varies throughout different terminals. They will mostly be ignored, if not supported.

reset - Resets all (color) modifiers to their defaults
bold - Make text bold
italic - Make text italic
underline - Make text underlined
~~strikethrough~~ - Puts a horizontal line through the center of the text (Alias: strikeThrough, crossedout, crossedOut)
hidden - Prints the text, but makes it invisible (Alias: conceal)
dim - Decreased color intensity (Alias: faint)
overlined - Make text overlined
blink - Hides and shows the text in an interval
inverse - Swap foreground and background colors (Alias: swapcolors, swapColors)
doubleunderline - Make text double underlined (Alias: doubleUnderline)
framed - Draw a frame around the text

前景颜色#

black
red
green
yellow
blue
magenta
cyan
white
gray (alias: grey, blackBright)
redBright
greenBright
yellowBright
blueBright
magentaBright
cyanBright
whiteBright

背景颜色#

bgBlack
bgRed
bgGreen
bgYellow
bgBlue
bgMagenta
bgCyan
bgWhite
bgGray (alias: bgGrey, bgBlackBright)
bgRedBright
bgGreenBright
bgYellowBright
bgBlueBright
bgMagentaBright
bgCyanBright
bgWhiteBright

自定义对象的查看函数#

对象可以定义自己的 [util.inspect.custom](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`#

版本历史

版本	变更
v10.12.0	This is now defined as a shared symbol.
v6.6.0	新增于: v6.6.0

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

See Custom inspection functions on Objects for more details.

`util.inspect.defaultOptions`#

新增于: v6.4.0

defaultOptions 值允许对被 util.inspect 使用的默认选项进行自定义。这对 console.log 或 util.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)`#

新增于: v9.0.0

val1 <any>
val2 <any>
Returns: <boolean>

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

新增于: v8.0.0

original <Function>
返回: <Function>

传入一个遵循常见的错误优先的回调风格的函数（即以 (err, value) => ... 回调作为最后一个参数），并返回一个返回 promise 的版本。

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

const stat = util.promisify(fs.stat);
stat('.').then((stats) => {
  // 使用 `stats`。
}).catch((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(`该目录归 ${stats.uid} 拥有`);
}

如果存在 original[util.promisify.custom] 属性，则 promisify 将会返回其值，参见自定义的 promise 化函数。

promisify() 在所有情况下都会假定 original 是一个以回调作为其最后参数的函数。如果 original 不是一个函数，则 promisify() 将会抛出错误。如果 original 是一个函数但其最后一个参数不是一个错误优先的回调，则它将仍会传入一个错误优先的回调作为其最后一个参数。

除非特殊处理，否则在类方法或使用 this 的其他方法上使用 promisify() 可能无法正常工作：

const util = require('util');

class Foo {
  constructor() {
    this.a = 42;
  }

  bar(callback) {
    callback(null, this.a);
  }
}

const foo = new Foo();

const naiveBar = util.promisify(foo.bar);
// TypeError: Cannot read property 'a' of undefined
// naiveBar().then(a => console.log(a));

naiveBar.call(foo).then((a) => console.log(a)); // '42'

const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'

自定义的 promise 化函数#

使用 util.promisify.custom 符号可以重写 util.promisify() 的返回值：

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]);
// 打印 'true'

对于原始函数不遵循将错误优先的回调作为最后一个参数的标准格式的情况，这很有用。

例如，使用一个接受 (foo, onSuccessCallback, onErrorCallback) 的函数:

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

如果定义了 promisify.custom 但不是一个函数，则 promisify() 将会抛出错误。

`util.promisify.custom`#

版本历史

版本	变更
v13.12.0, v12.16.2	This is now defined as a shared symbol.
v8.0.0	新增于: v8.0.0

<symbol> 可用于声明函数的自定义的 promise 化变量，参见自定义的 promise 化函数。

除了可以通过 util.promisify.custom 进行访问之外，该符号还被[注册为全局]的global symbol registry，并且可以在任何环境中作为 Symbol.for('nodejs.util.promisify.custom') 进行访问。

例如，使用一个接受 (foo, onSuccessCallback, onErrorCallback) 的函数：

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

doSomething[kCustomPromisifiedSymbol] = (foo) => {
  return new Promise((resolve, reject) => {
    doSomething(foo, resolve, reject);
  });
};

util.TextDecoder 类#

新增于: v8.3.0

WHATWG 编码标准的 TextDecoder API 的实现。

const decoder = new TextDecoder('shift_jis');
let string = '';
let buffer;
while (buffer = getNextChunkSomehow()) {
  string += decoder.decode(buffer, { stream: true });
}
string += decoder.decode(); // 流的末尾。

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. (see Internationalization)

默认支持的编码（带有完整的 ICU 数据）#

Encoding	Aliases
`'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'`

使用 small-icu 选项构建的 Node.js 支持的编码#

Encoding	Aliases
`'utf-8'`	`'unicode-1-1-utf-8'`, `'utf8'`
`'utf-16le'`	`'utf-16'`
`'utf-16be'`

当 ICU 被禁用时支持的编码#

Encoding	Aliases
`'utf-8'`	`'unicode-1-1-utf-8'`, `'utf8'`
`'utf-16le'`	`'utf-16'`

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

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

版本历史

版本	变更
v11.0.0	The class is now available on the global object.
v8.3.0	新增于: v8.3.0

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 not supported when ICU is disabled (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.

The TextDecoder class is also available on the global object.

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

input <ArrayBuffer> | <DataView> | <TypedArray> An ArrayBuffer, DataView or TypedArray instance containing the encoded data.
options <Object>
- stream <boolean> true if additional chunks of data are expected. Default: false.
Returns: <string>

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`#

<string>

The encoding supported by the TextDecoder instance.

`textDecoder.fatal`#

<boolean>

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

`textDecoder.ignoreBOM`#

<boolean>

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

util.TextEncoder 类#

版本历史

版本	变更
v11.0.0	The class is now available on the global object.
v8.3.0	新增于: v8.3.0

WHATWG 编码标准的 TextEncoder API 的实现。 TextEncoder 的所有实例仅支持 UTF-8 编码。

const encoder = new TextEncoder();
const uint8array = encoder.encode('这是一些数据');

TextEncoder 类在全局对象上也可用。

`textEncoder.encode([input])`#

input <string> The text to encode. Default: an empty string.
Returns: <Uint8Array>

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

`textEncoder.encodeInto(src, dest)`#

src <string> The text to encode.
dest <Uint8Array> The array to hold the encode result.
Returns: <Object>
- read <number> The read Unicode code units of src.
- written <number> The written UTF-8 bytes of dest.

UTF-8 encodes the src string to the dest Uint8Array and returns an object containing the read Unicode code units and written UTF-8 bytes.

const encoder = new TextEncoder();
const src = 'this is some data';
const dest = new Uint8Array(10);
const { read, written } = encoder.encodeInto(src, dest);

`textEncoder.encoding`#

<string>

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

`util.types`#

新增于: v10.0.0

util.types provides 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)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

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

`util.types.isArrayBufferView(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

Returns true if the value is an instance of one of the ArrayBuffer views, such as typed array objects or DataView. Equivalent to ArrayBuffer.isView().

util.types.isArrayBufferView(new Int8Array());  // true
util.types.isArrayBufferView(Buffer.from('hello world')); // true
util.types.isArrayBufferView(new DataView(new ArrayBuffer(16)));  // true
util.types.isArrayBufferView(new ArrayBuffer());  // false

`util.types.isArgumentsObject(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

Returns true if the value is an arguments object.

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

`util.types.isArrayBuffer(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

Returns true if the value is an async function. 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)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.11.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

`util.types.isDate(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

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

`util.types.isExternal(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

Returns true if the value is a native External value.

A native External value is a special type of object that contains a raw C++ pointer (void*) for access from native code, and has no other properties. Such objects are created either by Node.js internals or native addons. In JavaScript, they are frozen objects with a null prototype.

#include <js_native_api.h>
#include <stdlib.h>
napi_value result;
static napi_value MyNapi(napi_env env, napi_callback_info info) {
  int* raw = (int*) malloc(1024);
  napi_status status = napi_create_external(env, (void*) raw, NULL, NULL, &result);
  if (status != napi_ok) {
    napi_throw_error(env, NULL, "napi_create_external failed");
    return NULL;
  }
  return result;
}
...
DECLARE_NAPI_PROPERTY("myNapi", MyNapi)
...

const native = require('napi_addon.node');
const data = native.myNapi();
util.types.isExternal(data); // returns true
util.types.isExternal(0); // returns false
util.types.isExternal(new String('foo')); // returns false

For further information on napi_create_external, refer to napi_create_external().

`util.types.isFloat32Array(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

Returns true if the value is a generator function. 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)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

Returns true if the value is a generator object as returned from a built-in generator function. 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)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

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

`util.types.isMapIterator(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

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

`util.types.isProxy(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

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

`util.types.isSetIterator(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

`util.types.isUint8Array(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

新增于: v10.0.0

value <any>
Returns: <boolean>

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

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

`util.types.isWeakSet(value)`#

新增于: v10.0.0

value <any>
Returns: <boolean>

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

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

`util.types.isWebAssemblyCompiledModule(value)`#

新增于: v10.0.0弃用于: v14.0.0

稳定性: 0 - 弃用: 改为使用 value instanceof WebAssembly.Module 。

value <any>
Returns: <boolean>

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

新增于: v0.7.5弃用于: v6.0.0

稳定性: 0 - 弃用: 改为使用 Object.assign() 。

target <Object>
source <Object>

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.isArray(object)`#

新增于: v0.6.0弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 Array.isArray() 。

object <any>
Returns: <boolean>

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 typeof value === 'boolean' 。

object <any>
Returns: <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)`#

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 Buffer.isBuffer() 。

object <any>
Returns: <boolean>

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

新增于: v0.6.0弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 util.types.isDate() 。

object <any>
Returns: <boolean>

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

新增于: v0.6.0弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 util.types.isNativeError() 。

object <any>
Returns: <boolean>

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

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 typeof value === 'function' 。

object <any>
Returns: <boolean>

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 value === null 。

object <any>
Returns: <boolean>

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 value === undefined || value === null 。

object <any>
Returns: <boolean>

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 typeof value === 'number' 。

object <any>
Returns: <boolean>

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 value !== null && typeof value === 'object' 。

object <any>
Returns: <boolean>

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 (typeof value !== 'object' && typeof value !== 'function') || value === null 。

object <any>
Returns: <boolean>

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

新增于: v0.6.0弃用于: v4.0.0

稳定性: 0 - 弃用

object <any>
Returns: <boolean>

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 typeof value === 'string' 。

object <any>
Returns: <boolean>

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 typeof value === 'symbol' 。

object <any>
Returns: <boolean>

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

新增于: v0.11.5弃用于: v4.0.0

稳定性: 0 - 弃用: 改为使用 value === undefined 。

object <any>
Returns: <boolean>

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

新增于: v0.3.0弃用于: v6.0.0

稳定性: 0 - 弃用: 改为使用 a third party module 。

string <string>

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

const util = require('util');

util.log('Timestamped message.');

目录

util（实用工具）#

util.callbackify(original)#

util.debuglog(section[, callback])#

debuglog().enabled#

util.debug(section)#

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

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

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

util.getSystemErrorName(err)#

util.inherits(constructor, superConstructor)#

util.inspect(object[, options])#

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

自定义 util.inspect 的颜色#

修饰符#

前景颜色#

背景颜色#

自定义对象的查看函数#

util.inspect.custom#

util.inspect.defaultOptions#

util.isDeepStrictEqual(val1, val2)#

util.promisify(original)#

自定义的 promise 化函数#

util.promisify.custom#

util.TextDecoder 类#

WHATWG 支持的字符编码#

默认支持的编码（带有完整的 ICU 数据）#

使用 small-icu 选项构建的 Node.js 支持的编码#

当 ICU 被禁用时支持的编码#

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

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

textDecoder.encoding#

textDecoder.fatal#

textDecoder.ignoreBOM#

util.TextEncoder 类#

textEncoder.encode([input])#

textEncoder.encodeInto(src, dest)#

textEncoder.encoding#

util.types#

util.types.isAnyArrayBuffer(value)#

util.types.isArrayBufferView(value)#

util.types.isArgumentsObject(value)#

util.types.isArrayBuffer(value)#

util.types.isAsyncFunction(value)#

util.types.isBigInt64Array(value)#

util.types.isBigUint64Array(value)#

util.types.isBooleanObject(value)#

util.types.isBoxedPrimitive(value)#

util.types.isDataView(value)#

util.types.isDate(value)#

util.types.isExternal(value)#

util.types.isFloat32Array(value)#

util.types.isFloat64Array(value)#

util.types.isGeneratorFunction(value)#

util.types.isGeneratorObject(value)#

util.types.isInt8Array(value)#

util.types.isInt16Array(value)#

util.types.isInt32Array(value)#

util.types.isMap(value)#

util.types.isMapIterator(value)#

util.types.isModuleNamespaceObject(value)#

util.types.isNativeError(value)#

util.types.isNumberObject(value)#

util.types.isPromise(value)#

util.types.isProxy(value)#

util.types.isRegExp(value)#

util.types.isSet(value)#

util.types.isSetIterator(value)#

util.types.isSharedArrayBuffer(value)#

util.types.isStringObject(value)#

util.types.isSymbolObject(value)#

util.types.isTypedArray(value)#

util.types.isUint8Array(value)#

util.types.isUint8ClampedArray(value)#

util.types.isUint16Array(value)#

util.types.isUint32Array(value)#

util.types.isWeakMap(value)#

util.types.isWeakSet(value)#

util.types.isWebAssemblyCompiledModule(value)#

弃用的 API#

`util.callbackify(original)`#

`util.debuglog(section[, callback])`#

`debuglog().enabled`#

`util.debug(section)`#

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

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

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

`util.getSystemErrorName(err)`#

`util.inherits(constructor, superConstructor)`#

`util.inspect(object[, options])`#

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

`util.inspect.custom`#

`util.inspect.defaultOptions`#

`util.isDeepStrictEqual(val1, val2)`#

`util.promisify(original)`#

`util.promisify.custom`#

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

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

`textDecoder.encoding`#

`textDecoder.fatal`#

`textDecoder.ignoreBOM`#

`textEncoder.encode([input])`#

`textEncoder.encodeInto(src, dest)`#

`textEncoder.encoding`#

`util.types`#

`util.types.isAnyArrayBuffer(value)`#

`util.types.isArrayBufferView(value)`#

`util.types.isArgumentsObject(value)`#

`util.types.isArrayBuffer(value)`#

`util.types.isAsyncFunction(value)`#

`util.types.isBigInt64Array(value)`#

`util.types.isBigUint64Array(value)`#

`util.types.isBooleanObject(value)`#

`util.types.isBoxedPrimitive(value)`#

`util.types.isDataView(value)`#

`util.types.isDate(value)`#

`util.types.isExternal(value)`#

`util.types.isFloat32Array(value)`#

`util.types.isFloat64Array(value)`#

`util.types.isGeneratorFunction(value)`#

`util.types.isGeneratorObject(value)`#

`util.types.isInt8Array(value)`#

`util.types.isInt16Array(value)`#

`util.types.isInt32Array(value)`#

`util.types.isMap(value)`#

`util.types.isMapIterator(value)`#

`util.types.isModuleNamespaceObject(value)`#

`util.types.isNativeError(value)`#

`util.types.isNumberObject(value)`#

`util.types.isPromise(value)`#

`util.types.isProxy(value)`#

`util.types.isRegExp(value)`#

`util.types.isSet(value)`#

`util.types.isSetIterator(value)`#

`util.types.isSharedArrayBuffer(value)`#

`util.types.isStringObject(value)`#

`util.types.isSymbolObject(value)`#

`util.types.isTypedArray(value)`#

`util.types.isUint8Array(value)`#

`util.types.isUint8ClampedArray(value)`#

`util.types.isUint16Array(value)`#

`util.types.isUint32Array(value)`#

`util.types.isWeakMap(value)`#

`util.types.isWeakSet(value)`#

`util.types.isWebAssemblyCompiledModule(value)`#

`util._extend(target, source)`#

`util.isArray(object)`#

`util.isBoolean(object)`#

`util.isBuffer(object)`#

`util.isDate(object)`#

`util.isError(object)`#

`util.isFunction(object)`#

`util.isNull(object)`#

`util.isNullOrUndefined(object)`#

`util.isNumber(object)`#

`util.isObject(object)`#

`util.isPrimitive(object)`#

`util.isRegExp(object)`#

`util.isString(object)`#

`util.isSymbol(object)`#