Node.js v24.0.0 文档
- Node.js v24.0.0
-
目录
- Util
util.callbackify(original)
util.debuglog(section[, callback])
util.debug(section)
util.deprecate(fn, msg[, code])
util.diff(actual, expected)
util.format(format[, ...args])
util.formatWithOptions(inspectOptions, format[, ...args])
util.getCallSites([frameCount][, options])
util.getSystemErrorName(err)
util.getSystemErrorMap()
util.getSystemErrorMessage(err)
util.inherits(constructor, superConstructor)
util.inspect(object[, options])
util.inspect(object[, showHidden[, depth[, colors]]])
util.isDeepStrictEqual(val1, val2)
- 类:
util.MIMEType
- 类:
util.MIMEParams
util.parseArgs([config])
util.parseEnv(content)
util.promisify(original)
util.stripVTControlCharacters(str)
util.styleText(format, text[, options])
- 类:
util.TextDecoder
- 类:
util.TextEncoder
util.toUSVString(string)
util.transferableAbortController()
util.transferableAbortSignal(signal)
util.aborted(signal, resource)
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.isBigIntObject(value)
util.types.isBigUint64Array(value)
util.types.isBooleanObject(value)
util.types.isBoxedPrimitive(value)
util.types.isCryptoKey(value)
util.types.isDataView(value)
util.types.isDate(value)
util.types.isExternal(value)
util.types.isFloat16Array(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.isKeyObject(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)
- 已弃用的 API
- Util
-
索引
- 断言测试
- 异步上下文跟踪
- 异步钩子
- Buffer
- C++ 插件
- 使用 Node-API 的 C/C++ 插件
- C++ 嵌入器 API
- 子进程
- Cluster
- 命令行选项
- Console
- Crypto
- Debugger
- 已弃用的 API
- 诊断通道
- DNS
- Domain
- Errors
- Events
- 文件系统
- 全局变量
- HTTP
- HTTP/2
- HTTPS
- Inspector
- 国际化
- 模块:CommonJS 模块
- 模块:ECMAScript 模块
- 模块:
node:module
API - 模块:包
- 模块:TypeScript
- Net
- OS
- Path
- 性能钩子
- 权限
- Process
- Punycode
- 查询字符串
- Readline
- REPL
- Report
- 单可执行文件应用程序
- SQLite
- Stream
- 字符串解码器
- 测试运行器
- Timers
- TLS/SSL
- 跟踪事件
- TTY
- UDP/数据报
- URL
- Utilities
- V8
- VM
- WASI
- Web Crypto API
- Web Streams API
- Worker threads
- Zlib
- 其他版本
- 选项
Util#
源码: lib/util.js
node:util
模块支持 Node.js 内部 API 的需求。许多实用程序对应用程序和模块开发人员也很有用。要访问它:
import util from 'node:util';
const util = require('node:util');
util.callbackify(original)
#
original
<Function> 一个async
函数- 返回:<Function> 一个回调风格的函数
接受一个 async
函数(或返回 Promise
的函数),并返回一个遵循 error-first 回调风格的函数,即接受一个 (err, value) => ...
回调作为最后一个参数。 在回调中,第一个参数将是拒绝原因(如果 Promise
已解决,则为 null
),第二个参数将是已解决的值。
import { callbackify } from 'node:util';
async function fn() {
return 'hello world';
}
const callbackFunction = callbackify(fn);
callbackFunction((err, ret) => {
if (err) throw err;
console.log(ret);
});
const { callbackify } = require('node:util');
async function fn() {
return 'hello world';
}
const callbackFunction = callbackify(fn);
callbackFunction((err, ret) => {
if (err) throw err;
console.log(ret);
});
将打印
hello world
该回调以异步方式执行,并将具有有限的堆栈跟踪。 如果回调抛出,则该进程将发出一个 'uncaughtException'
事件,如果未处理,则将退出。
由于 null
作为回调的第一个参数具有特殊含义,如果包装的函数以一个虚值作为原因拒绝 Promise
,则该值将被包装在 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 && Object.hasOwn(err, 'reason') && err.reason === null; // true
});
util.debuglog(section[, callback])
#
section
<string> 一个字符串,用于标识应用程序中创建debuglog
函数的部分。callback
<Function> 首次使用函数参数调用日志记录函数时调用的回调,该函数参数是更优化的日志记录函数。- 返回:<Function> 日志记录函数
util.debuglog()
方法用于创建一个函数,该函数根据 NODE_DEBUG
环境变量的存在有条件地将调试消息写入 stderr
。 如果 section
名称出现在该环境变量的值中,则返回的函数的操作类似于 console.error()
。 否则,返回的函数是一个空操作。
import { debuglog } from 'node:util';
const log = debuglog('foo');
log('hello from foo [%d]', 123);
const { debuglog } = require('node:util');
const log = debuglog('foo');
log('hello from foo [%d]', 123);
如果使用环境变量 NODE_DEBUG=foo
运行此程序,则它将输出类似以下内容:
FOO 3245: hello from foo [123]
其中 3245
是进程 ID。 如果在没有设置该环境变量的情况下运行它,则它不会打印任何内容。
section
也支持通配符
import { debuglog } from 'node:util';
const log = debuglog('foo');
log('hi there, it\'s foo-bar [%d]', 2333);
const { debuglog } = require('node:util');
const log = debuglog('foo');
log('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
。
可选的 callback
参数可用于将日志记录函数替换为没有初始化或不必要的包装的不同函数。
import { debuglog } from 'node:util';
let log = debuglog('internals', (debug) => {
// Replace with a logging function that optimizes out
// testing if the section is enabled
log = debug;
});
const { debuglog } = require('node:util');
let log = debuglog('internals', (debug) => {
// Replace with a logging function that optimizes out
// testing if the section is enabled
log = debug;
});
debuglog().enabled
#
util.debuglog().enabled
getter 用于创建一个测试,该测试可用于基于 NODE_DEBUG
环境变量的存在的条件语句中。 如果 section
名称出现在该环境变量的值中,则返回的值将为 true
。 否则,返回的值将为 false
。
import { debuglog } from 'node:util';
const enabled = debuglog('foo').enabled;
if (enabled) {
console.log('hello from foo [%d]', 123);
}
const { debuglog } = require('node:util');
const enabled = debuglog('foo').enabled;
if (enabled) {
console.log('hello from foo [%d]', 123);
}
如果使用环境变量 NODE_DEBUG=foo
运行此程序,则它将输出类似以下内容:
hello from foo [123]
util.debug(section)
#
util.debuglog
的别名。 使用允许读取,这并不意味着在使用 util.debuglog().enabled
时仅进行日志记录。
util.deprecate(fn, msg[, code])
#
fn
<Function> 正在弃用的函数。msg
<string> 调用已弃用的函数时显示的警告消息。code
<string> 一个弃用代码。请参阅已弃用 API 列表以获取代码列表。- 返回: <Function> 包装好的已弃用函数,用于发出警告。
util.deprecate()
方法包装 fn
(可以是函数或类),使其标记为已弃用。
import { deprecate } from 'node:util';
export const obsoleteFunction = deprecate(() => {
// Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');
const { deprecate } = require('node:util');
exports.obsoleteFunction = deprecate(() => {
// Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');
调用时,util.deprecate()
将返回一个函数,该函数将使用 'warning'
事件发出 DeprecationWarning
。 警告将被发出并打印到 stderr
,这是第一次调用返回的函数时。 发出警告后,将在不发出警告的情况下调用包装的函数。
如果在多次调用 util.deprecate()
中提供相同的可选 code
,则仅针对该 code
发出一次警告。
import { deprecate } from 'node:util';
const fn1 = deprecate(
() => 'a value',
'deprecation message',
'DEP0001',
);
const fn2 = deprecate(
() => 'a different value',
'other dep message',
'DEP0001',
);
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code
const { deprecate } = require('node:util');
const fn1 = deprecate(
function() {
return 'a value';
},
'deprecation message',
'DEP0001',
);
const fn2 = deprecate(
function() {
return 'a different value';
},
'other dep message',
'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-deprecation
和 process.traceDeprecation
。
util.diff(actual, expected)
#
-
返回: <Array> 差异条目的数组。 每个条目都是一个包含两个元素的数组
-
算法复杂度:O(N*D),其中
-
N 是两个序列组合的总长度(N = actual.length + expected.length)
-
D 是编辑距离(将一个序列转换为另一个序列所需的最少操作数)。
util.diff()
比较两个字符串或数组值,并返回一个差异条目的数组。 它使用 Myers diff 算法来计算最小差异,该算法与断言错误消息内部使用的算法相同。
如果值相等,则返回一个空数组。
const { diff } = require('node:util');
// Comparing strings
const actualString = '12345678';
const expectedString = '12!!5!7!';
console.log(diff(actualString, expectedString));
// [
// [0, '1'],
// [0, '2'],
// [1, '3'],
// [1, '4'],
// [-1, '!'],
// [-1, '!'],
// [0, '5'],
// [1, '6'],
// [-1, '!'],
// [0, '7'],
// [1, '8'],
// [-1, '!'],
// ]
// Comparing arrays
const actualArray = ['1', '2', '3'];
const expectedArray = ['1', '3', '4'];
console.log(diff(actualArray, expectedArray));
// [
// [0, '1'],
// [1, '2'],
// [0, '3'],
// [-1, '4'],
// ]
// Equal values return empty array
console.log(diff('same', 'same'));
// []
util.format(format[, ...args])
#
format
<string> 一个类似printf
的格式字符串。
util.format()
方法返回一个格式化的字符串,该字符串使用第一个参数作为类似 printf
的格式字符串,该字符串可以包含零个或多个格式说明符。 每个说明符都将替换为来自相应参数的转换值。 支持的说明符是
%s
:String
将用于转换除BigInt
、Object
和-0
之外的所有值。BigInt
值将用n
表示,并且既没有用户定义的toString
函数也没有Symbol.toPrimitive
函数的对象将使用util.inspect()
进行检查,选项为{ depth: 0, colors: false, compact: 3 }
。%d
:Number
将用于转换除BigInt
和Symbol
之外的所有值。%i
:parseInt(value, 10)
用于转换除BigInt
和Symbol
之外的所有值。%f
:parseFloat(value)
用于转换除Symbol
之外的所有值。%j
: JSON。 如果参数包含循环引用,则替换为字符串'[Circular]'
。%o
:Object
。 具有通用 JavaScript 对象格式的对象字符串表示形式。 类似于util.inspect()
,选项为{ showHidden: true, showProxy: true }
。 这将显示完整对象,包括不可枚举的属性和代理。%O
:Object
。 具有通用 JavaScript 对象格式的对象字符串表示形式。 类似于没有选项的util.inspect()
。 这将显示完整对象,不包括不可枚举的属性和代理。%c
:CSS
。 此说明符将被忽略,并将跳过传入的任何 CSS。%%
: 单个百分号 ('%'
)。 这不占用参数。- 返回: <string> 格式化的字符串
如果说明符没有相应的参数,则不会替换它
util.format('%s:%s', 'foo');
// Returns: 'foo:%s'
如果类型不是 string
,则不属于格式字符串一部分的值将使用 util.inspect()
格式化。
如果传递给 util.format()
方法的参数多于说明符的数量,则额外的参数将连接到返回的字符串,用空格分隔
util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'
如果第一个参数不包含有效的格式说明符,则 util.format()
返回一个字符串,该字符串是由所有参数连接而成,用空格分隔
util.format(1, 2, 3);
// Returns: '1 2 3'
如果仅将一个参数传递给 util.format()
,则会按原样返回,无需任何格式化
util.format('%% %s');
// Returns: '%% %s'
util.format()
是一种同步方法,旨在用作调试工具。 某些输入值可能会产生显着的性能开销,从而可能阻止事件循环。 请谨慎使用此函数,切勿在热代码路径中使用。
util.formatWithOptions(inspectOptions, format[, ...args])
#
此函数与 util.format()
相同,不同之处在于它采用一个 inspectOptions
参数,该参数指定传递给 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.getCallSites([frameCount][, options])
#
frameCount
<number> 要捕获为调用站点对象的帧的可选数量。 默认:10
。 允许的范围是 1 到 200 之间。options
<Object> 可选sourceMap
<boolean> 从 source-map 重构堆栈跟踪中的原始位置。 默认情况下,使用标志--enable-source-maps
启用。
- 返回: <Object[]> 调用站点对象的数组
返回一个调用站点对象数组,其中包含调用函数的堆栈。
import { getCallSites } from 'node:util';
function exampleFunction() {
const callSites = getCallSites();
console.log('Call Sites:');
callSites.forEach((callSite, index) => {
console.log(`CallSite ${index + 1}:`);
console.log(`Function Name: ${callSite.functionName}`);
console.log(`Script Name: ${callSite.scriptName}`);
console.log(`Line Number: ${callSite.lineNumber}`);
console.log(`Column Number: ${callSite.column}`);
});
// CallSite 1:
// Function Name: exampleFunction
// Script Name: /home/example.js
// Line Number: 5
// Column Number: 26
// CallSite 2:
// Function Name: anotherFunction
// Script Name: /home/example.js
// Line Number: 22
// Column Number: 3
// ...
}
// A function to simulate another stack layer
function anotherFunction() {
exampleFunction();
}
anotherFunction();
const { getCallSites } = require('node:util');
function exampleFunction() {
const callSites = getCallSites();
console.log('Call Sites:');
callSites.forEach((callSite, index) => {
console.log(`CallSite ${index + 1}:`);
console.log(`Function Name: ${callSite.functionName}`);
console.log(`Script Name: ${callSite.scriptName}`);
console.log(`Line Number: ${callSite.lineNumber}`);
console.log(`Column Number: ${callSite.column}`);
});
// CallSite 1:
// Function Name: exampleFunction
// Script Name: /home/example.js
// Line Number: 5
// Column Number: 26
// CallSite 2:
// Function Name: anotherFunction
// Script Name: /home/example.js
// Line Number: 22
// Column Number: 3
// ...
}
// A function to simulate another stack layer
function anotherFunction() {
exampleFunction();
}
anotherFunction();
可以通过将选项 sourceMap
设置为 true
来重构原始位置。 如果 source map 不可用,则原始位置将与当前位置相同。 启用 --enable-source-maps
标志后,例如在使用 --experimental-transform-types
时,sourceMap
默认情况下将为 true。
import { getCallSites } from 'node:util';
interface Foo {
foo: string;
}
const callSites = getCallSites({ sourceMap: true });
// With sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 7
// Column Number: 26
// Without sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 2
// Column Number: 26
const { getCallSites } = require('node:util');
const callSites = getCallSites({ sourceMap: true });
// With sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 7
// Column Number: 26
// Without sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 2
// Column Number: 26
util.getSystemErrorName(err)
#
返回来自 Node.js API 的数字错误代码的字符串名称。 错误代码和错误名称之间的映射取决于平台。 有关常见错误的名称,请参见常见系统错误。
fs.access('file/that/does/not/exist', (err) => {
const name = util.getSystemErrorName(err.errno);
console.error(name); // ENOENT
});
util.getSystemErrorMap()
#
- 返回: <Map>
返回一个 Map,其中包含 Node.js API 提供的所有系统错误代码。错误代码和错误名称之间的映射取决于平台。有关常见错误的名称,请参阅常见系统错误。
fs.access('file/that/does/not/exist', (err) => {
const errorMap = util.getSystemErrorMap();
const name = errorMap.get(err.errno);
console.error(name); // ENOENT
});
util.getSystemErrorMessage(err)
#
返回来自 Node.js API 的数字错误代码的字符串消息。错误代码和字符串消息之间的映射取决于平台。
fs.access('file/that/does/not/exist', (err) => {
const message = util.getSystemErrorMessage(err.errno);
console.error(message); // No such file or directory
});
util.inherits(constructor, superConstructor)
#
extends
关键字。constructor
<Function>superConstructor
<Function>
不鼓励使用 util.inherits()
。请使用 ES6 class
和 extends
关键字来获得语言级别的继承支持。另请注意,这两种风格在语义上不兼容。
将一个构造函数的原型方法继承到另一个构造函数中。constructor
的原型将被设置为从 superConstructor
创建的新对象。
这主要是在 Object.setPrototypeOf(constructor.prototype, superConstructor.prototype)
的基础上添加一些输入验证。作为额外的便利,可以通过 constructor.super_
属性访问 superConstructor
。
const util = require('node:util');
const EventEmitter = require('node: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(`Received data: "${data}"`);
});
stream.write('It works!'); // Received data: "It works!"
使用 class
和 extends
的 ES6 示例
import EventEmitter from 'node:events';
class MyStream extends EventEmitter {
write(data) {
this.emit('data', data);
}
}
const stream = new MyStream();
stream.on('data', (data) => {
console.log(`Received data: "${data}"`);
});
stream.write('With ES6');
const EventEmitter = require('node:events');
class MyStream extends EventEmitter {
write(data) {
this.emit('data', data);
}
}
const stream = new MyStream();
stream.on('data', (data) => {
console.log(`Received data: "${data}"`);
});
stream.write('With ES6');
util.inspect(object[, options])
#
util.inspect(object[, showHidden[, depth[, colors]]])
object
<any> 任何 JavaScript 原始类型或Object
。options
<Object>showHidden
<boolean> 如果为true
,则格式化结果中包含object
的不可枚举符号和属性。<WeakMap> 和 <WeakSet> 条目以及用户定义的原型属性(不包括方法属性)也包含在内。默认:false
。depth
<number> 指定格式化object
时要递归的次数。这对于检查大型对象很有用。要递归到最大调用堆栈大小,请传递Infinity
或null
。默认:2
。colors
<boolean> 如果为true
,则输出将使用 ANSI 颜色代码进行样式化。颜色是可自定义的。请参阅自定义util.inspect
颜色。默认:false
。customInspect
<boolean> 如果为false
,则不会调用[util.inspect.custom](depth, opts, inspect)
函数。默认:true
。showProxy
<boolean> 如果为true
,则Proxy
检查包括target
和handler
对象。默认:false
。maxArrayLength
<integer> 指定格式化时要包含的Array
、<TypedArray>、<Map>、<WeakMap> 和 <WeakSet> 元素的最大数量。设置为null
或Infinity
可显示所有元素。设置为0
或负数可不显示任何元素。默认:100
。maxStringLength
<integer> 指定格式化时要包含的最大字符数。设置为null
或Infinity
可显示所有元素。设置为0
或负数可不显示任何字符。默认:10000
。breakLength
<integer> 输入值跨多行拆分的长度。设置为Infinity
可以将输入格式化为单行(与设置为true
或任何数字 >=1
的compact
结合使用)。默认:80
。compact
<boolean> | <integer> 将此设置为false
会导致每个对象键显示在新行上。它会在长于breakLength
的文本中换行。如果设置为数字,则只要所有属性都适合breakLength
,最内部的n
个元素就会在单行上合并。短数组元素也会分组在一起。有关更多信息,请参见下面的示例。默认:3
。sorted
<boolean> | <Function> 如果设置为true
或函数,则对象的所有属性以及Set
和Map
条目都会在结果字符串中排序。如果设置为true
,则使用默认排序。如果设置为函数,则将其用作比较函数。getters
<boolean> | <string> 如果设置为true
,则检查 getter。如果设置为'get'
,则仅检查没有相应 setter 的 getter。如果设置为'set'
,则仅检查具有相应 setter 的 getter。这可能会导致副作用,具体取决于 getter 函数。默认:false
。numericSeparator
<boolean> 如果设置为true
,则使用下划线分隔所有 bigint 和数字中每三位数字。默认:false
。
- 返回: <string>
object
的表示形式。
util.inspect()
方法返回 object
的字符串表示形式,用于调试。 util.inspect
的输出可能随时更改,不应以编程方式依赖它。可以传递其他 options
来更改结果。 util.inspect()
将使用构造函数的名称和/或 @@toStringTag
为检查的值创建一个可识别的标签。
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] {}'
循环引用使用引用索引指向其锚点
import { inspect } from 'node: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] }
// }
const { inspect } = require('node: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] }
// }
以下示例检查 util
对象的所有属性
import util from 'node:util';
console.log(util.inspect(util, { showHidden: true, depth: null }));
const util = require('node:util');
console.log(util.inspect(util, { showHidden: true, depth: null }));
以下示例重点介绍了 compact
选项的效果
import { inspect } from 'node:util';
const o = {
a: [1, 2, [[
'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
'test',
'foo']], 4],
b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));
// { a:
// [ 1,
// 2,
// [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line
// 'test',
// 'foo' ] ],
// 4 ],
// b: Map(2) { 'za' => 1, 'zb' => 'test' } }
// Setting `compact` to false or an integer creates more reader friendly output.
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));
// {
// a: [
// 1,
// 2,
// [
// [
// 'Lorem ipsum dolor sit amet,\n' +
// 'consectetur adipiscing elit, sed do eiusmod \n' +
// '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.
const { inspect } = require('node:util');
const o = {
a: [1, 2, [[
'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
'test',
'foo']], 4],
b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));
// { a:
// [ 1,
// 2,
// [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line
// 'test',
// 'foo' ] ],
// 4 ],
// b: Map(2) { 'za' => 1, 'zb' => 'test' } }
// Setting `compact` to false or an integer creates more reader friendly output.
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));
// {
// a: [
// 1,
// 2,
// [
// [
// 'Lorem ipsum dolor sit amet,\n' +
// 'consectetur adipiscing elit, sed do eiusmod \n' +
// '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.
showHidden
选项允许检查<WeakMap> 和 <WeakSet> 条目。如果条目多于 maxArrayLength
,则不能保证显示哪些条目。这意味着两次检索相同的 <WeakSet> 条目可能会导致不同的输出。此外,任何时候都可能对没有剩余强引用的条目进行垃圾回收。
import { inspect } from 'node: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 } }
const { inspect } = require('node: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 } }
sorted
选项确保对象的属性插入顺序不会影响 util.inspect()
的结果。
import { inspect } from 'node:util';
import assert from 'node: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 }),
);
const { inspect } = require('node:util');
const assert = require('node: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 }),
);
numericSeparator
选项在所有数字中每三位数字添加一个下划线。
import { inspect } from 'node:util';
const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;
console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45
const { inspect } = require('node:util');
const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;
console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45
util.inspect()
是一种用于调试的同步方法。其最大输出长度约为 128 MiB。导致输出更长的输入将被截断。
自定义 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
: (无样式)null
:bold
number
:yellow
regexp
:red
special
:cyan
(例如,Proxies
)string
:green
symbol
:green
undefined
:grey
颜色样式使用 ANSI 控制代码,这些代码可能并非在所有终端上都受支持。要验证颜色支持,请使用tty.hasColors()
。
预定义的控制代码列在下面(分组为“修饰符”、“前景色”和“背景色”)。
修饰符#
不同终端对修饰符的支持程度各不相同。如果不支持,它们通常会被忽略。
reset
- 将所有(颜色)修饰符重置为其默认值- bold - 将文本设置为粗体
- italic - 将文本设置为斜体
- underline - 为文本添加下划线
strikethrough- 在文本中心绘制一条水平线(别名:strikeThrough
,crossedout
,crossedOut
)hidden
- 打印文本,但使其不可见(别名:conceal)- dim - 降低颜色强度(别名:
faint
) - overlined - 为文本添加上划线
- blink - 以一定的时间间隔隐藏和显示文本
- inverse - 交换前景色和背景色(别名:
swapcolors
,swapColors
) - doubleunderline - 为文本添加双下划线(别名:
doubleUnderline
) - framed - 在文本周围绘制一个框架
前景色#
black
red
green
yellow
blue
magenta
cyan
white
gray
(别名:grey
,blackBright
)redBright
greenBright
yellowBright
blueBright
magentaBright
cyanBright
whiteBright
背景色#
bgBlack
bgRed
bgGreen
bgYellow
bgBlue
bgMagenta
bgCyan
bgWhite
bgGray
(别名:bgGrey
,bgBlackBright
)bgRedBright
bgGreenBright
bgYellowBright
bgBlueBright
bgMagentaBright
bgCyanBright
bgWhiteBright
对象上的自定义检查函数#
对象也可以定义自己的 [util.inspect.custom](depth, opts, inspect)
函数,util.inspect()
在检查对象时会调用该函数并使用其结果。
import { inspect } from 'node:util';
class Box {
constructor(value) {
this.value = value;
}
[inspect.custom](depth, options, inspect) {
if (depth < 0) {
return options.stylize('[Box]', 'special');
}
const newOptions = Object.assign({}, options, {
depth: options.depth === null ? null : options.depth - 1,
});
// Five space padding because that's the size of "Box< ".
const padding = ' '.repeat(5);
const inner = inspect(this.value, newOptions)
.replace(/\n/g, `\n${padding}`);
return `${options.stylize('Box', 'special')}< ${inner} >`;
}
}
const box = new Box(true);
console.log(inspect(box));
// "Box< true >"
const { inspect } = require('node:util');
class Box {
constructor(value) {
this.value = value;
}
[inspect.custom](depth, options, inspect) {
if (depth < 0) {
return options.stylize('[Box]', 'special');
}
const newOptions = Object.assign({}, options, {
depth: options.depth === null ? null : options.depth - 1,
});
// Five space padding because that's the size of "Box< ".
const padding = ' '.repeat(5);
const inner = inspect(this.value, newOptions)
.replace(/\n/g, `\n${padding}`);
return `${options.stylize('Box', 'special')}< ${inner} >`;
}
}
const box = new Box(true);
console.log(inspect(box));
// "Box< true >"
自定义 [util.inspect.custom](depth, opts, inspect)
函数通常返回一个字符串,但可以返回任何类型的值,这些值将由 util.inspect()
相应地格式化。
import { inspect } from 'node:util';
const obj = { foo: 'this will not show up in the inspect() output' };
obj[inspect.custom] = (depth) => {
return { bar: 'baz' };
};
console.log(inspect(obj));
// "{ bar: 'baz' }"
const { inspect } = require('node:util');
const obj = { foo: 'this will not show up in the inspect() output' };
obj[inspect.custom] = (depth) => {
return { bar: 'baz' };
};
console.log(inspect(obj));
// "{ bar: 'baz' }"
util.inspect.custom
#
- <symbol>,可用于声明自定义检查函数。
除了可以通过 util.inspect.custom
访问之外,此符号还被全局注册,并且可以在任何环境中作为 Symbol.for('nodejs.util.inspect.custom')
访问。
使用此方法允许以可移植的方式编写代码,以便在 Node.js 环境中使用自定义检查函数,而在浏览器中忽略它。 util.inspect()
函数本身作为第三个参数传递给自定义检查函数,以实现进一步的可移植性。
const customInspectSymbol = Symbol.for('nodejs.util.inspect.custom');
class Password {
constructor(value) {
this.value = value;
}
toString() {
return 'xxxxxxxx';
}
[customInspectSymbol](depth, inspectOptions, inspect) {
return `Password <${this.toString()}>`;
}
}
const password = new Password('r0sebud');
console.log(password);
// Prints Password <xxxxxxxx>
有关更多详细信息,请参阅对象上的自定义检查函数。
util.inspect.defaultOptions
#
defaultOptions
值允许自定义 util.inspect
使用的默认选项。 这对于像 console.log
或 util.format
这样隐式调用 util.inspect
的函数非常有用。 它应设置为包含一个或多个有效util.inspect()
选项的对象。 也支持直接设置选项属性。
import { inspect } from 'node:util';
const arr = Array(156).fill(0);
console.log(arr); // Logs the truncated array
inspect.defaultOptions.maxArrayLength = null;
console.log(arr); // logs the full array
const { inspect } = require('node:util');
const arr = Array(156).fill(0);
console.log(arr); // Logs the truncated array
inspect.defaultOptions.maxArrayLength = null;
console.log(arr); // logs the full array
util.isDeepStrictEqual(val1, val2)
#
如果 val1
和 val2
之间存在深度严格相等,则返回 true
。 否则,返回 false
。
有关深度严格相等的更多信息,请参阅assert.deepStrictEqual()
。
类: util.MIMEType
#
MIMEType 类的一个实现。
按照浏览器约定,MIMEType
对象的所有属性都作为类原型上的 getter 和 setter 实现,而不是作为对象本身上的数据属性。
MIME 字符串是一个结构化字符串,包含多个有意义的组成部分。 解析后,将返回一个 MIMEType
对象,其中包含每个这些组成部分的属性。
构造函数: new MIMEType(input)
#
input
<string> 要解析的输入 MIME
通过解析 input
创建一个新的 MIMEType
对象。
import { MIMEType } from 'node:util';
const myMIME = new MIMEType('text/plain');
const { MIMEType } = require('node:util');
const myMIME = new MIMEType('text/plain');
如果 input
不是有效的 MIME,将抛出一个 TypeError
。 请注意,将努力强制将给定的值转换为字符串。 例如
import { MIMEType } from 'node:util';
const myMIME = new MIMEType({ toString: () => 'text/plain' });
console.log(String(myMIME));
// Prints: text/plain
const { MIMEType } = require('node:util');
const myMIME = new MIMEType({ toString: () => 'text/plain' });
console.log(String(myMIME));
// Prints: text/plain
mime.type
#
获取和设置 MIME 的类型部分。
import { MIMEType } from 'node:util';
const myMIME = new MIMEType('text/javascript');
console.log(myMIME.type);
// Prints: text
myMIME.type = 'application';
console.log(myMIME.type);
// Prints: application
console.log(String(myMIME));
// Prints: application/javascript
const { MIMEType } = require('node:util');
const myMIME = new MIMEType('text/javascript');
console.log(myMIME.type);
// Prints: text
myMIME.type = 'application';
console.log(myMIME.type);
// Prints: application
console.log(String(myMIME));
// Prints: application/javascript
mime.subtype
#
获取和设置 MIME 的子类型部分。
import { MIMEType } from 'node:util';
const myMIME = new MIMEType('text/ecmascript');
console.log(myMIME.subtype);
// Prints: ecmascript
myMIME.subtype = 'javascript';
console.log(myMIME.subtype);
// Prints: javascript
console.log(String(myMIME));
// Prints: text/javascript
const { MIMEType } = require('node:util');
const myMIME = new MIMEType('text/ecmascript');
console.log(myMIME.subtype);
// Prints: ecmascript
myMIME.subtype = 'javascript';
console.log(myMIME.subtype);
// Prints: javascript
console.log(String(myMIME));
// Prints: text/javascript
mime.essence
#
获取 MIME 的 essence。 此属性为只读。 使用 mime.type
或 mime.subtype
来更改 MIME。
import { MIMEType } from 'node:util';
const myMIME = new MIMEType('text/javascript;key=value');
console.log(myMIME.essence);
// Prints: text/javascript
myMIME.type = 'application';
console.log(myMIME.essence);
// Prints: application/javascript
console.log(String(myMIME));
// Prints: application/javascript;key=value
const { MIMEType } = require('node:util');
const myMIME = new MIMEType('text/javascript;key=value');
console.log(myMIME.essence);
// Prints: text/javascript
myMIME.type = 'application';
console.log(myMIME.essence);
// Prints: application/javascript
console.log(String(myMIME));
// Prints: application/javascript;key=value
mime.toString()
#
- 返回: <string>
MIMEType
对象上的 toString()
方法返回序列化的 MIME。
由于需要符合标准,因此此方法不允许用户自定义 MIME 的序列化过程。
mime.toJSON()
#
- 返回: <string>
mime.toString()
的别名。
当使用JSON.stringify()
序列化 MIMEType
对象时,会自动调用此方法。
import { MIMEType } from 'node:util';
const myMIMES = [
new MIMEType('image/png'),
new MIMEType('image/gif'),
];
console.log(JSON.stringify(myMIMES));
// Prints: ["image/png", "image/gif"]
const { MIMEType } = require('node:util');
const myMIMES = [
new MIMEType('image/png'),
new MIMEType('image/gif'),
];
console.log(JSON.stringify(myMIMES));
// Prints: ["image/png", "image/gif"]
类: util.MIMEParams
#
MIMEParams
API 提供对 MIMEType
参数的读写访问。
构造函数: new MIMEParams()
#
使用空参数创建一个新的 MIMEParams
对象
import { MIMEParams } from 'node:util';
const myParams = new MIMEParams();
const { MIMEParams } = require('node:util');
const myParams = new MIMEParams();
mimeParams.entries()
#
- 返回: <Iterator>
返回参数中每个名称-值对的迭代器。 迭代器的每个项目都是一个 JavaScript Array
。 数组的第一个项目是 name
,数组的第二个项目是 value
。
mimeParams.get(name)
#
返回第一个名称为 name
的名称-值对的值。 如果没有此类对,则返回 null
。
mimeParams.keys()
#
- 返回: <Iterator>
返回每个名称-值对的名称的迭代器。
import { MIMEType } from 'node:util';
const { params } = new MIMEType('text/plain;foo=0;bar=1');
for (const name of params.keys()) {
console.log(name);
}
// Prints:
// foo
// bar
const { MIMEType } = require('node:util');
const { params } = new MIMEType('text/plain;foo=0;bar=1');
for (const name of params.keys()) {
console.log(name);
}
// Prints:
// foo
// bar
mimeParams.set(name, value)
#
将与 name
关联的 MIMEParams
对象中的值设置为 value
。 如果存在任何名称为 name
的预先存在的名称-值对,则将第一个此类对的值设置为 value
。
import { MIMEType } from 'node:util';
const { params } = new MIMEType('text/plain;foo=0;bar=1');
params.set('foo', 'def');
params.set('baz', 'xyz');
console.log(params.toString());
// Prints: foo=def;bar=1;baz=xyz
const { MIMEType } = require('node:util');
const { params } = new MIMEType('text/plain;foo=0;bar=1');
params.set('foo', 'def');
params.set('baz', 'xyz');
console.log(params.toString());
// Prints: foo=def;bar=1;baz=xyz
mimeParams[@@iterator]()
#
- 返回: <Iterator>
import { MIMEType } from 'node:util';
const { params } = new MIMEType('text/plain;foo=bar;xyz=baz');
for (const [name, value] of params) {
console.log(name, value);
}
// Prints:
// foo bar
// xyz baz
const { MIMEType } = require('node:util');
const { params } = new MIMEType('text/plain;foo=bar;xyz=baz');
for (const [name, value] of params) {
console.log(name, value);
}
// Prints:
// foo bar
// xyz baz
util.parseArgs([config])
#
-
config
<Object> 用于提供解析的参数并配置解析器。config
支持以下属性args
<string[]> 参数字符串数组。 默认: 删除execPath
和filename
的process.argv
。options
<Object> 用于描述解析器已知的参数。options
的键是选项的长名称,值是<Object>,接受以下属性type
<string> 参数的类型,必须是boolean
或string
。multiple
<boolean> 是否允许多次提供此选项。如果为true
,所有值将被收集到一个数组中。如果为false
,则选项的值以最后一次为准。默认值:false
。short
<string> 选项的单字符别名。default
<string> | <boolean> | <string[]> | <boolean[]> 如果(且仅当)要解析的参数中没有出现该选项时,使用的默认值。 它必须与type
属性的类型相同。 当multiple
为true
时,它必须是一个数组。
strict
<boolean> 当遇到未知参数,或者传递的参数与options
中配置的type
不匹配时,是否应该抛出错误。默认值:true
。allowPositionals
<boolean> 此命令是否接受位置参数。 默认值: 如果strict
为true
,则为false
,否则为true
。allowNegative
<boolean> 如果为true
,则允许通过在选项名称前加上--no-
来显式地将布尔选项设置为false
。默认值:false
。tokens
<boolean> 返回解析后的 tokens。 这对于扩展内置行为非常有用,从添加额外的检查到以不同的方式重新处理 tokens。默认值:false
。
-
返回值: <Object> 解析后的命令行参数
values
<Object> 已解析的选项名称与其 <string> 或 <boolean> 值的映射。positionals
<string[]> 位置参数。tokens
<Object[]> | <undefined> 参见 parseArgs tokens 部分。 仅当config
包含tokens: true
时才返回。
提供比直接与 process.argv
交互更高层次的命令行参数解析 API。 接受预期参数的规范,并返回一个包含解析后的选项和位置参数的结构化对象。
import { parseArgs } from 'node:util';
const args = ['-f', '--bar', 'b'];
const options = {
foo: {
type: 'boolean',
short: 'f',
},
bar: {
type: 'string',
},
};
const {
values,
positionals,
} = parseArgs({ args, options });
console.log(values, positionals);
// Prints: [Object: null prototype] { foo: true, bar: 'b' } []
const { parseArgs } = require('node:util');
const args = ['-f', '--bar', 'b'];
const options = {
foo: {
type: 'boolean',
short: 'f',
},
bar: {
type: 'string',
},
};
const {
values,
positionals,
} = parseArgs({ args, options });
console.log(values, positionals);
// Prints: [Object: null prototype] { foo: true, bar: 'b' } []
parseArgs
tokens
#
通过在配置中指定 tokens: true
,可以使用详细的解析信息来添加自定义行为。 返回的 tokens 具有描述以下内容属性
- 所有 tokens
- 选项 tokens
name
<string> 选项的长名称。rawName
<string> 选项在 args 中的使用方式,如-f
或--foo
。value
<string> | <undefined> 在 args 中指定的选项值。 对于布尔选项,未定义。inlineValue
<boolean> | <undefined> 选项值是否以内联方式指定,如--foo=bar
。
- 位置 tokens
value
<string> args 中位置参数的值(即args[index]
)。
- option-terminator token
返回的 tokens 按照在输入 args 中遇到的顺序排列。 在 args 中出现多次的选项会为每次使用生成一个 token。 像 -xy
这样的短选项组会展开为每个选项的 token。 因此 -xxx
生成三个 tokens。
例如,要添加对否定选项(如 --no-color
)的支持(当选项的类型为 boolean
时,allowNegative
支持该选项),可以重新处理返回的 tokens 以更改为否定选项存储的值。
import { parseArgs } from 'node:util';
const options = {
'color': { type: 'boolean' },
'no-color': { type: 'boolean' },
'logfile': { type: 'string' },
'no-logfile': { type: 'boolean' },
};
const { values, tokens } = parseArgs({ options, tokens: true });
// Reprocess the option tokens and overwrite the returned values.
tokens
.filter((token) => token.kind === 'option')
.forEach((token) => {
if (token.name.startsWith('no-')) {
// Store foo:false for --no-foo
const positiveName = token.name.slice(3);
values[positiveName] = false;
delete values[token.name];
} else {
// Resave value so last one wins if both --foo and --no-foo.
values[token.name] = token.value ?? true;
}
});
const color = values.color;
const logfile = values.logfile ?? 'default.log';
console.log({ logfile, color });
const { parseArgs } = require('node:util');
const options = {
'color': { type: 'boolean' },
'no-color': { type: 'boolean' },
'logfile': { type: 'string' },
'no-logfile': { type: 'boolean' },
};
const { values, tokens } = parseArgs({ options, tokens: true });
// Reprocess the option tokens and overwrite the returned values.
tokens
.filter((token) => token.kind === 'option')
.forEach((token) => {
if (token.name.startsWith('no-')) {
// Store foo:false for --no-foo
const positiveName = token.name.slice(3);
values[positiveName] = false;
delete values[token.name];
} else {
// Resave value so last one wins if both --foo and --no-foo.
values[token.name] = token.value ?? true;
}
});
const color = values.color;
const logfile = values.logfile ?? 'default.log';
console.log({ logfile, color });
使用示例,展示了否定选项,以及当一个选项以多种方式使用时,最后一次获胜。
$ node negate.js
{ logfile: 'default.log', color: undefined }
$ node negate.js --no-logfile --no-color
{ logfile: false, color: false }
$ node negate.js --logfile=test.log --color
{ logfile: 'test.log', color: true }
$ node negate.js --no-logfile --logfile=test.log --color --no-color
{ logfile: 'test.log', color: false }
util.parseEnv(content)
#
content
<string>
.env
文件的原始内容。
- 返回值: <Object>
给定一个示例 .env
文件
const { parseEnv } = require('node:util');
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
import { parseEnv } from 'node:util';
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
util.promisify(original)
#
original
<Function>- 返回值: <Function>
接受一个遵循常见错误优先回调风格的函数,即,以一个 (err, value) => ...
回调作为最后一个参数,并返回一个返回 Promise 的版本。
import { promisify } from 'node:util';
import { stat } from 'node:fs';
const promisifiedStat = promisify(stat);
promisifiedStat('.').then((stats) => {
// Do something with `stats`
}).catch((error) => {
// Handle the error.
});
const { promisify } = require('node:util');
const { stat } = require('node:fs');
const promisifiedStat = promisify(stat);
promisifiedStat('.').then((stats) => {
// Do something with `stats`
}).catch((error) => {
// Handle the error.
});
或者,等效地使用 async function
s
import { promisify } from 'node:util';
import { stat } from 'node:fs';
const promisifiedStat = promisify(stat);
async function callStat() {
const stats = await promisifiedStat('.');
console.log(`This directory is owned by ${stats.uid}`);
}
callStat();
const { promisify } = require('node:util');
const { stat } = require('node:fs');
const promisifiedStat = promisify(stat);
async function callStat() {
const stats = await promisifiedStat('.');
console.log(`This directory is owned by ${stats.uid}`);
}
callStat();
如果存在 original[util.promisify.custom]
属性,则 promisify
将返回其值,请参阅 自定义 Promise 化函数。
promisify()
假定 original
是一个函数,在所有情况下都将回调作为其最后一个参数。 如果 original
不是函数,promisify()
将抛出错误。 如果 original
是函数,但其最后一个参数不是错误优先回调,它仍然会被传递一个错误优先回调作为其最后一个参数。
除非经过特殊处理,否则在类方法或其他使用 this
的方法上使用 promisify()
可能无法按预期工作
import { promisify } from 'node:util';
class Foo {
constructor() {
this.a = 42;
}
bar(callback) {
callback(null, this.a);
}
}
const foo = new Foo();
const naiveBar = promisify(foo.bar);
// TypeError: Cannot read properties of undefined (reading 'a')
// 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'
const { promisify } = require('node:util');
class Foo {
constructor() {
this.a = 42;
}
bar(callback) {
callback(null, this.a);
}
}
const foo = new Foo();
const naiveBar = promisify(foo.bar);
// TypeError: Cannot read properties of undefined (reading 'a')
// 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()
的返回值
import { promisify } from 'node:util';
function doSomething(foo, callback) {
// ...
}
doSomething[promisify.custom] = (foo) => {
return getPromiseSomehow();
};
const promisified = promisify(doSomething);
console.log(promisified === doSomething[promisify.custom]);
// prints 'true'
const { promisify } = require('node:util');
function doSomething(foo, callback) {
// ...
}
doSomething[promisify.custom] = (foo) => {
return getPromiseSomehow();
};
const promisified = promisify(doSomething);
console.log(promisified === doSomething[promisify.custom]);
// prints 'true'
对于原始函数不遵循以错误优先回调作为最后一个参数的标准格式的情况,这可能很有用。
例如,对于一个接受 (foo, onSuccessCallback, onErrorCallback)
的函数
doSomething[util.promisify.custom] = (foo) => {
return new Promise((resolve, reject) => {
doSomething(foo, resolve, reject);
});
};
如果定义了 promisify.custom
但不是函数,则 promisify()
将抛出错误。
util.promisify.custom
#
- <symbol> 可用于声明函数的自定义 Promise 化变体,请参阅 自定义 Promise 化函数。
除了可以通过 util.promisify.custom
访问之外,此符号还被 全局注册,并且可以在任何环境中作为 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.stripVTControlCharacters(str)
#
返回删除了任何 ANSI 转义码的 str
。
console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"
util.styleText(format, text[, options])
#
format
<string> | <Array> 在util.inspect.colors
中定义的文本格式或文本格式数组。text
<string> 要格式化的文本。options
<Object>
此函数返回一个格式化的文本,考虑了传递的 format
以在终端中打印。 它知道终端的功能,并根据通过 NO_COLOR
、NODE_DISABLE_COLORS
和 FORCE_COLOR
环境变量设置的配置进行操作。
import { styleText } from 'node:util';
import { stderr } from 'node:process';
const successMessage = styleText('green', 'Success!');
console.log(successMessage);
const errorMessage = styleText(
'red',
'Error! Error!',
// Validate if process.stderr has TTY
{ stream: stderr },
);
console.error(errorMessage);
const { styleText } = require('node:util');
const { stderr } = require('node:process');
const successMessage = styleText('green', 'Success!');
console.log(successMessage);
const errorMessage = styleText(
'red',
'Error! Error!',
// Validate if process.stderr has TTY
{ stream: stderr },
);
console.error(errorMessage);
util.inspect.colors
还提供了文本格式,例如 italic
和 underline
,您可以将两者结合起来
console.log(
util.styleText(['underline', 'italic'], 'My italic underlined message'),
);
当传递格式数组时,应用的格式的顺序是从左到右,因此以下样式可能会覆盖前一个样式。
console.log(
util.styleText(['red', 'green'], 'text'), // green
);
完整的格式列表可以在 修饰符 中找到。
类: util.TextDecoder
#
WHATWG 编码标准 TextDecoder
API 的实现。
const decoder = new TextDecoder();
const u8arr = new Uint8Array([72, 101, 108, 108, 111]);
console.log(decoder.decode(u8arr)); // Hello
WHATWG 支持的编码#
根据 WHATWG 编码标准,TextDecoder
API 支持的编码在下表中列出。 对于每种编码,可以使用一个或多个别名。
不同的 Node.js 构建配置支持不同的编码集。(参见 国际化)
默认情况下支持的编码(具有完整的 ICU 数据)#
编码 | 别名 |
---|---|
'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' |
当 Node.js 使用 small-icu
选项构建时支持的编码#
编码 | 别名 |
---|---|
'utf-8' | 'unicode-1-1-utf-8' , 'utf8' |
'utf-16le' | 'utf-16' |
'utf-16be' |
当禁用 ICU 时支持的编码#
编码 | 别名 |
---|---|
'utf-8' | 'unicode-1-1-utf-8' , 'utf8' |
'utf-16le' | 'utf-16' |
WHATWG 编码标准中列出的 'iso-8859-16'
编码不受支持。
new TextDecoder([encoding[, options]])
#
创建新的 TextDecoder
实例。 encoding
可以指定支持的编码或别名之一。
TextDecoder
类也可在全局对象上使用。
textDecoder.decode([input[, options]])
#
input
<ArrayBuffer> | <DataView> | <TypedArray> 包含编码数据的ArrayBuffer
、DataView
或TypedArray
实例。options
<Object>stream
<boolean> 如果需要额外的数据块,则为true
。 默认值:false
。
- 返回: <string>
解码 input
并返回一个字符串。 如果 options.stream
为 true
,则发生在 input
末尾的任何不完整的字节序列都会在内部缓冲,并在下次调用 textDecoder.decode()
后发出。
如果 textDecoder.fatal
为 true
,则发生的解码错误将导致抛出 TypeError
。
类: util.TextEncoder
#
WHATWG 编码标准 TextEncoder
API 的实现。 TextEncoder
的所有实例仅支持 UTF-8 编码。
const encoder = new TextEncoder();
const uint8array = encoder.encode('this is some data');
TextEncoder
类也可在全局对象上使用。
textEncoder.encode([input])
#
input
<string> 要编码的文本。 默认值: 空字符串。- 返回: <Uint8Array>
UTF-8 编码 input
字符串,并返回包含编码字节的 Uint8Array
。
textEncoder.encodeInto(src, dest)
#
src
<string> 要编码的文本。dest
<Uint8Array> 用于保存编码结果的数组。- 返回值: <Object>
UTF-8 编码 src
字符串到 dest
Uint8Array,并返回一个包含读取的 Unicode 代码单元和写入的 UTF-8 字节的对象。
const encoder = new TextEncoder();
const src = 'this is some data';
const dest = new Uint8Array(10);
const { read, written } = encoder.encodeInto(src, dest);
util.toUSVString(string)
#
string
<string>
返回 string
,在将任何代理代码点(或等效地,任何未配对的代理代码单元)替换为 Unicode“替换字符”U+FFFD 之后。
util.transferableAbortController()
#
创建并返回一个 <AbortController> 实例,该实例的 <AbortSignal> 被标记为可传递,并且可以与 structuredClone()
或 postMessage()
一起使用。
util.transferableAbortSignal(signal)
#
signal
<AbortSignal>- 返回: <AbortSignal>
将给定的 <AbortSignal> 标记为可传递,以便它可以与 structuredClone()
和 postMessage()
一起使用。
const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);
util.aborted(signal, resource)
#
signal
<AbortSignal>resource
<Object> 任何与可中止操作相关联并被弱引用的非空对象。 如果在signal
中止之前垃圾回收了resource
,则 promise 将保持挂起状态,从而允许 Node.js 停止跟踪它。 这有助于防止长时间运行或不可取消操作中的内存泄漏。- 返回: <Promise>
侦听提供的 signal
上的 abort 事件,并返回一个 promise,该 promise 在 signal
中止时解析。 如果提供了 resource
,它会弱引用操作的关联对象,因此如果在 signal
中止之前垃圾回收了 resource
,则返回的 promise 应保持挂起状态。 这可以防止长时间运行或不可取消操作中的内存泄漏。
const { aborted } = require('node:util');
// Obtain an object with an abortable signal, like a custom resource or operation.
const dependent = obtainSomethingAbortable();
// Pass `dependent` as the resource, indicating the promise should only resolve
// if `dependent` is still in memory when the signal is aborted.
aborted(dependent.signal, dependent).then(() => {
// This code runs when `dependent` is aborted.
console.log('Dependent resource was aborted.');
});
// Simulate an event that triggers the abort.
dependent.on('event', () => {
dependent.abort(); // This will cause the `aborted` promise to resolve.
});
import { aborted } from 'node:util';
// Obtain an object with an abortable signal, like a custom resource or operation.
const dependent = obtainSomethingAbortable();
// Pass `dependent` as the resource, indicating the promise should only resolve
// if `dependent` is still in memory when the signal is aborted.
aborted(dependent.signal, dependent).then(() => {
// This code runs when `dependent` is aborted.
console.log('Dependent resource was aborted.');
});
// Simulate an event that triggers the abort.
dependent.on('event', () => {
dependent.abort(); // This will cause the `aborted` promise to resolve.
});
util.types
#
util.types
为不同种类的内置对象提供类型检查。 与 instanceof
或 Object.prototype.toString.call(value)
不同,这些检查不会检查可以从 JavaScript 访问的对象的属性(例如它们的 prototype),并且通常具有调用 C++ 的开销。
通常,结果不会对值在 JavaScript 中公开的属性或行为类型做出任何保证。 它们主要供希望在 JavaScript 中进行类型检查的插件开发者使用。
该 API 可通过 require('node:util').types
或 require('node:util/types')
访问。
util.types.isAnyArrayBuffer(value)
#
如果该值是内置的 <ArrayBuffer> 或 <SharedArrayBuffer> 实例,则返回 true
。
另请参阅 util.types.isArrayBuffer()
和 util.types.isSharedArrayBuffer()
。
util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
util.types.isArrayBufferView(value)
#
如果该值是 <ArrayBuffer> 视图之一的实例,例如类型化数组对象或 <DataView>,则返回 true
。 相当于 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)
#
如果该值是 arguments
对象,则返回 true
。
function foo() {
util.types.isArgumentsObject(arguments); // Returns true
}
util.types.isArrayBuffer(value)
#
如果该值是内置的 <ArrayBuffer> 实例,则返回 true
。 这不包括 <SharedArrayBuffer> 实例。 通常,最好同时测试两者; 有关更多信息,请参见 util.types.isAnyArrayBuffer()
。
util.types.isArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer()); // Returns false
util.types.isAsyncFunction(value)
#
如果该值是 async function,则返回 true
。 这只会报告 JavaScript 引擎所看到的内容; 特别是,如果使用了转译工具,则返回值可能与原始源代码不匹配。
util.types.isAsyncFunction(function foo() {}); // Returns false
util.types.isAsyncFunction(async function foo() {}); // Returns true
util.types.isBigInt64Array(value)
#
如果该值是 BigInt64Array
实例,则返回 true
。
util.types.isBigInt64Array(new BigInt64Array()); // Returns true
util.types.isBigInt64Array(new BigUint64Array()); // Returns false
util.types.isBigIntObject(value)
#
如果该值是 BigInt 对象,例如由 Object(BigInt(123))
创建,则返回 true
。
util.types.isBigIntObject(Object(BigInt(123))); // Returns true
util.types.isBigIntObject(BigInt(123)); // Returns false
util.types.isBigIntObject(123); // Returns false
util.types.isBigUint64Array(value)
#
如果该值是 BigUint64Array
实例,则返回 true
。
util.types.isBigUint64Array(new BigInt64Array()); // Returns false
util.types.isBigUint64Array(new BigUint64Array()); // Returns true
util.types.isBooleanObject(value)
#
如果该值是布尔对象,例如由 new Boolean()
创建,则返回 true
。
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)
#
如果该值是任何 boxed primitive 对象,例如由 new Boolean()
、new String()
或 Object(Symbol())
创建,则返回 true
。
例如
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.isCryptoKey(value)
#
如果 value
是 <CryptoKey>,则返回 true
,否则返回 false
。
util.types.isDataView(value)
#
如果该值是内置的 <DataView> 实例,则返回 true
。
const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab)); // Returns true
util.types.isDataView(new Float64Array()); // Returns false
另请参阅 ArrayBuffer.isView()
。
util.types.isDate(value)
#
如果该值是内置的 <Date> 实例,则返回 true
。
util.types.isDate(new Date()); // Returns true
util.types.isExternal(value)
#
如果该值是原生 External
值,则返回 true
。
原生 External
值是一种特殊类型的对象,其中包含一个原始 C++ 指针 (void*
),用于从原生代码访问,并且没有其他属性。 这样的对象由 Node.js 内部或原生插件创建。 在 JavaScript 中,它们是具有 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)
...
import native from 'napi_addon.node';
import { types } from 'node:util';
const data = native.myNapi();
types.isExternal(data); // returns true
types.isExternal(0); // returns false
types.isExternal(new String('foo')); // returns false
const native = require('napi_addon.node');
const { types } = require('node:util');
const data = native.myNapi();
types.isExternal(data); // returns true
types.isExternal(0); // returns false
types.isExternal(new String('foo')); // returns false
有关 napi_create_external
的更多信息,请参阅napi_create_external()
。
util.types.isFloat16Array(value)
#
如果该值是内置的 <Float16Array> 实例,则返回 true
。
util.types.isFloat16Array(new ArrayBuffer()); // Returns false
util.types.isFloat16Array(new Float16Array()); // Returns true
util.types.isFloat16Array(new Float32Array()); // Returns false
util.types.isFloat32Array(value)
#
如果该值是内置的 <Float32Array> 实例,则返回 true
。
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)
#
如果该值是内置的 <Float64Array> 实例,则返回 true
。
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)
#
如果该值是 generator function,则返回 true
。 这只会报告 JavaScript 引擎所看到的内容; 特别是,如果使用了转译工具,则返回值可能与原始源代码不匹配。
util.types.isGeneratorFunction(function foo() {}); // Returns false
util.types.isGeneratorFunction(function* foo() {}); // Returns true
util.types.isGeneratorObject(value)
#
如果该值是从内置的 generator function 返回的 generator object,则返回 true
。 这只会报告 JavaScript 引擎所看到的内容; 特别是,如果使用了转译工具,则返回值可能与原始源代码不匹配。
function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator); // Returns true
util.types.isInt8Array(value)
#
如果该值是内置的 <Int8Array> 实例,则返回 true
。
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)
#
如果该值是内置的 <Int16Array> 实例,则返回 true
。
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)
#
如果该值是内置的 <Int32Array> 实例,则返回 true
。
util.types.isInt32Array(new ArrayBuffer()); // Returns false
util.types.isInt32Array(new Int32Array()); // Returns true
util.types.isInt32Array(new Float64Array()); // Returns false
util.types.isKeyObject(value)
#
如果 value
是 <KeyObject>,则返回 true
,否则返回 false
。
util.types.isMapIterator(value)
#
如果该值是为内置的 <Map> 实例返回的迭代器,则返回 true
。
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)
#
如果该值是 Module Namespace Object 的实例,则返回 true
。
import * as ns from './a.js';
util.types.isModuleNamespaceObject(ns); // Returns true
util.types.isNativeError(value)
#
如果该值是由内置的 Error
类型的构造函数返回的,则返回 true
。
console.log(util.types.isNativeError(new Error())); // true
console.log(util.types.isNativeError(new TypeError())); // true
console.log(util.types.isNativeError(new RangeError())); // true
原生错误类型的子类也是原生错误
class MyError extends Error {}
console.log(util.types.isNativeError(new MyError())); // true
一个值是原生错误类的 instanceof
并不等同于 isNativeError()
为该值返回 true
。 isNativeError()
为来自不同领域的错误返回 true
,而 instanceof Error
为这些错误返回 false
import { createContext, runInContext } from 'node:vm';
import { types } from 'node:util';
const context = createContext({});
const myError = runInContext('new Error()', context);
console.log(types.isNativeError(myError)); // true
console.log(myError instanceof Error); // false
const { createContext, runInContext } = require('node:vm');
const { types } = require('node:util');
const context = createContext({});
const myError = runInContext('new Error()', context);
console.log(types.isNativeError(myError)); // true
console.log(myError instanceof Error); // false
相反,isNativeError()
为所有不是由原生错误的构造函数返回的对象返回 false
。 这包括 instanceof
原生错误的值
const myError = { __proto__: Error.prototype };
console.log(util.types.isNativeError(myError)); // false
console.log(myError instanceof Error); // true
util.types.isNumberObject(value)
#
如果该值是数字对象,例如由 new Number()
创建,则返回 true
。
util.types.isNumberObject(0); // Returns false
util.types.isNumberObject(new Number(0)); // Returns true
util.types.isPromise(value)
#
如果该值是内置的 <Promise>,则返回 true
。
util.types.isPromise(Promise.resolve(42)); // Returns true
util.types.isProxy(value)
#
如果该值是 <Proxy> 实例,则返回 true
。
const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target); // Returns false
util.types.isProxy(proxy); // Returns true
util.types.isRegExp(value)
#
如果该值是正则表达式对象,则返回 true
。
util.types.isRegExp(/abc/); // Returns true
util.types.isRegExp(new RegExp('abc')); // Returns true
util.types.isSetIterator(value)
#
如果该值是为内置的 <Set> 实例返回的迭代器,则返回 true
。
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)
#
如果该值是内置的 <SharedArrayBuffer> 实例,则返回 true
。 这不包括 <ArrayBuffer> 实例。 通常,希望同时测试两者; 请参阅 util.types.isAnyArrayBuffer()
。
util.types.isSharedArrayBuffer(new ArrayBuffer()); // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer()); // Returns true
util.types.isStringObject(value)
#
如果该值是字符串对象,例如由 new String()
创建,则返回 true
。
util.types.isStringObject('foo'); // Returns false
util.types.isStringObject(new String('foo')); // Returns true
util.types.isSymbolObject(value)
#
如果该值是符号对象,是通过在 Symbol
原始值上调用 Object()
创建的,则返回 true
。
const symbol = Symbol('foo');
util.types.isSymbolObject(symbol); // Returns false
util.types.isSymbolObject(Object(symbol)); // Returns true
util.types.isTypedArray(value)
#
如果该值是内置的 <TypedArray> 实例,则返回 true
。
util.types.isTypedArray(new ArrayBuffer()); // Returns false
util.types.isTypedArray(new Uint8Array()); // Returns true
util.types.isTypedArray(new Float64Array()); // Returns true
另请参阅 ArrayBuffer.isView()
。
util.types.isUint8Array(value)
#
如果该值是内置的 <Uint8Array> 实例,则返回 true
。
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)
#
如果该值是内置的 <Uint8ClampedArray> 实例,则返回 true
。
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)
#
如果该值是内置的 <Uint16Array> 实例,则返回 true
。
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)
#
如果该值是内置的 <Uint32Array> 实例,则返回 true
。
util.types.isUint32Array(new ArrayBuffer()); // Returns false
util.types.isUint32Array(new Uint32Array()); // Returns true
util.types.isUint32Array(new Float64Array()); // Returns false
已弃用的 API#
以下 API 已弃用,不应再使用。 应更新现有的应用程序和模块以找到替代方法。
util._extend(target, source)
#
Object.assign()
。util._extend()
方法从未打算在 Node.js 内部模块之外使用。 社区找到了并使用了它。
它已被弃用,不应在新代码中使用。 JavaScript 通过 Object.assign()
提供了非常相似的内置功能。
util.isArray(object)
#
Array.isArray()
。Array.isArray()
的别名。
如果给定的 object
是一个 Array
,则返回 true
。 否则,返回 false
。
const util = require('node:util');
util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false