Util
Node.js Docs · نسخهٔ 221ffa5df301 · MIT و مجوزهای همراه مخزن
# Util
<!--introduced_in=v0.10.0-->
توجه: Stability: 2 - Stable
<!-- source_link=lib/util.js -->
The node:util module supports the needs of Node.js internal APIs. Many of the utilities are useful for application and module developers as well. To access it:
const util = require('node:util');util.callbackify(original)
<!-- YAML added: v8.2.0 -->
original{Function} Anasyncfunction- Returns: {Function} a callback style function
Takes an async function (or a function that returns a Promise) and returns a function following the error-first callback style, i.e. taking an (err, value) => ... callback as the last argument. In the callback, the first argument will be the rejection reason (or null if the Promise resolved), and the second argument will be the resolved value.
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);
});Will print:
hello worldThe callback is executed asynchronously, and will have a limited stack trace. If the callback throws, the process will emit an ['uncaughtException'][] event, and if not handled will exit.
Since null has a special meaning as the first argument to a callback, if a wrapped function rejects a Promise with a falsy value as a reason, the value is wrapped in an Error with the original value stored in a field named 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
});const util = require('node:util');
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.convertProcessSignalToExitCode(signal)
<!-- YAML added: v24.14.0 -->
signal{string} A signal name (e.g.'SIGTERM')- Returns: {number} The exit code corresponding to
signal
The util.convertProcessSignalToExitCode() method converts a signal name to its corresponding POSIX exit code. Following the POSIX standard, the exit code for a process terminated by a signal is calculated as 128 + signal number.
If signal is not a valid signal name, then an error will be thrown. See [signal(7)][] for a list of valid signals.
console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)const { convertProcessSignalToExitCode } = require('node:util');
console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)This is particularly useful when working with processes to determine the exit code based on the signal that terminated the process.
util.debuglog(section[, callback])
<!-- YAML added: v0.11.3 -->
section{string} A string identifying the portion of the application for
which the debuglog function is being created.
callback{Function} A callback invoked the first time the logging function
is called with a function argument that is a more optimized logging function.
- Returns: {Function} The logging function
The util.debuglog() method is used to create a function that conditionally writes debug messages to stderr 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 function operates similar to [console.error()][]. If not, then the returned function is a no-op.
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);If this program is run with NODE_DEBUG=foo in the environment, then it will output something like:
FOO 3245: hello from foo [123]where 3245 is the process id. If it is not run with that environment variable set, then it will not print anything.
The section supports wildcard also:
const log = debuglog('foo-bar');
log('hi there, it\'s foo-bar [%d]', 2333);const { debuglog } = require('node:util');
const log = debuglog('foo-bar');
log('hi there, it\'s foo-bar [%d]', 2333);if it is run with NODE_DEBUG=foo* in the environment, then it will output something like:
FOO-BAR 3257: hi there, it's foo-bar [2333]Multiple comma-separated section names may be specified in the NODE_DEBUG environment variable: 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.
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
<!-- YAML added: v14.9.0 -->
- Type: {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 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);
}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)
<!-- YAML added: 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[, options]])
<!-- YAML added: v0.8.0 changes:
- version: v24.12.0
pr-url: https://github.com/nodejs/node/pull/59982 description: Add options object with modifyPrototype to conditionally modify the prototype of the deprecated object.
- version: v10.0.0
pr-url: https://github.com/nodejs/node/pull/16393 description: Deprecation warnings are only emitted once for each code. -->
fn{Function} The function that is being deprecated.msg{string} A warning message to display when the deprecated function is
invoked.
code{string} A deprecation code. See the [list of deprecated APIs][] for a
list of codes.
options{Object}modifyPrototype{boolean} When false do not change the prototype of object
while emitting the deprecation warning. Default: true.
- Returns: {Function} The deprecated function wrapped to emit a warning.
The util.deprecate() method wraps fn (which may be a function or class) in such a way that it is marked as deprecated.
// 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.');When called, util.deprecate() will return a function that will emit a DeprecationWarning using the ['warning'][] event. The warning will be emitted and printed to stderr the first time the returned function is called. After the warning is emitted, the wrapped function is called without emitting a warning.
If the same optional code is supplied in multiple calls to util.deprecate(), the warning will be emitted only once for that code.
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 codeconst { 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 codeIf either the --no-deprecation or --no-warnings command-line flags are used, or if the process.noDeprecation property is set to true _prior_ to the first deprecation warning, the util.deprecate() method does nothing.
If the --trace-deprecation or --trace-warnings command-line flags are set, or the process.traceDeprecation property is set to true, a warning and a stack trace are printed to stderr the first time the deprecated function is called.
If the --throw-deprecation command-line flag is set, or the process.throwDeprecation property is set to true, then an exception will be thrown when the deprecated function is called.
The --throw-deprecation command-line flag and process.throwDeprecation property take precedence over --trace-deprecation and process.traceDeprecation.
util.debounce(fn, wait[, options])
<!-- YAML added: v24.22.0 -->
fn{Function} The function to debounce.wait{integer} The number of milliseconds to delayfn.options{Object}leading{boolean} Whentrue, invokesfnimmediately when a new
debounce window begins. Default: false.
rejectOnCancel{boolean} Whentrue, a call superseded by a later call
rejects with an AbortError. Default: false.
signal{AbortSignal} AnAbortSignalthat cancels pending calls and
prevents future calls when aborted.
- Returns: {Function} The debounced function.
Creates a function that delays calling fn until wait milliseconds have elapsed since the most recent invocation. The debounced function returns a {Promise} for the value returned by fn. If fn throws or returns a rejected promise, the returned promise is rejected with the same reason.
When the debounced function is called more than once before the delay expires, fn receives the arguments from the most recent call. By default, the promises from all calls resolve or reject with the result of that invocation. If options.rejectOnCancel is true, the promises from superseded calls reject with an AbortError instead.
When options.leading is true, the first call in a debounce window invokes fn immediately. Calls made during that window are delayed until wait milliseconds have elapsed since the most recent call. A trailing invocation only occurs if the debounced function was called again during the window. The window begins before fn is invoked, so recursive calls and calls made while an asynchronous fn is pending are part of the same window if they occur before the delay expires. This also applies to calls made after a synchronous fn returns but before the delay expires.
If options.signal is aborted, pending and future calls reject with an AbortError, with the signal's reason set as the error's cause, and fn is not invoked by those calls. If the signal is already aborted, debounce() throws an AbortError.
The returned function has the following properties:
cancel([reason])cancels the current debounce window. Its pending promises
reject with an AbortError. If provided, reason is set as the error's cause.
flush()cancels the delay and invokesfnimmediately. It has no effect if
no invocation is pending.
pending{Promise|null} is the promise returned by the most recent call in
the current debounce window, or null if no invocation is pending.
pendingCount{integer} is the number of calls awaiting the invocation in
the current debounce window.
ref()makes the pending and future timeout keep the Node.js event loop
active. Returns the debounced function.
unref()allows the event loop to exit while a timeout is pending. This also
applies to future timeouts. Returns the debounced function.
When invoked, fn has the debounced function as its this value. After a trailing invocation, a new debounce window can begin even if a promise returned by fn is still pending. The debounced function preserves the name and length of fn.
const fn = debounce(async (value) => {
await wait(100);
return value;
}, 50);
const first = fn(1);
const second = fn(2);
console.log(await first); // 2
console.log(await second); // 2A debounced function can be used to trigger an action after a period of inactivity. Each call resets the timeout:
const { debounce } = require('node:util');
const onInactivity = debounce(() => {
console.log('No activity for 5 seconds');
}, 5_000).unref();
process.stdin.on('data', (data) => {
console.log(`Received ${data.length} bytes`);
onInactivity();
});
// Start the initial inactivity timeout.
onInactivity();util.throttle(fn, limit, interval[, options])
<!-- YAML added: v24.22.0 -->
fn{Function} The function to throttle.limit{integer} The maximum number of times to invokefnduring an
interval. Must be greater than 0.
interval{integer} The length of each interval in milliseconds.options{Object}concurrency{number} The maximum number of invocations offnwhose
return values may be unsettled at once. Must be a positive integer or Infinity. Default: Infinity.
maxPending{number} The maximum number of calls that may be queued when
overflow is 'queue'. Must be a non-negative integer or Infinity. Default: Infinity.
overflow{string} Determines how calls exceeding the limit are handled.
Default: 'queue'.
'queue': Queue calls in the order received.'drop': Reject calls immediately without queueing them.signal{AbortSignal} AnAbortSignalthat cancels pending calls and
prevents future calls when aborted.
strict{boolean} Whentrue, ensures thatlimitis not exceeded during
any rolling interval. Default: false.
- Returns: {Function} The throttled function.
Creates a function that limits how often fn is invoked. By default, calls that exceed the limit are queued in the order received rather than discarded. The throttled function returns a {Promise} for the value returned by fn. If fn throws or returns a rejected promise, the returned promise is rejected with the same reason.
An invocation starts only when both rate and concurrency capacity are available. Rate capacity is consumed when fn starts, not when a call enters the queue. Concurrency capacity is released when the value returned by fn settles. Non-promise values settle during the next microtask.
When options.overflow is 'drop', calls made without available rate or concurrency capacity are rejected immediately. When options.overflow is 'queue' and options.maxPending calls are already queued, additional calls are also rejected immediately. maxPending has no effect when overflow is 'drop'.
In both cases, rejected calls return a promise rejected with an ERR_THROTTLED error. The rejected promise is marked as handled, so ignoring it does not emit an 'unhandledRejection' event. Awaiting or explicitly handling the promise still observes the rejection. Rejected calls do not consume rate or concurrency capacity, enter the queue, or schedule a timeout.
By default, the interval begins when the first call in a new window invokes fn. Up to limit calls can invoke fn during that window. Queued calls are processed in groups of up to limit as each subsequent window begins. This windowed behavior can result in calls occurring close together at a window boundary.
When options.strict is true, invocation times are tracked individually. This ensures that no more than limit calls begin during any rolling interval, at the cost of additional bookkeeping.
If options.signal is aborted, pending and future calls reject with an AbortError, with the signal's reason set as the error's cause, and fn is not invoked by those calls. If the signal is already aborted, throttle() throws an AbortError.
The returned function has the following properties:
cancel([reason])cancels all queued calls and resets the current throttle
window. The queued promises reject with an AbortError. If provided, reason is set as the error's cause. Does not cancel invocations that have already started.
hasImmediateCapacity()returnstrueif a call made at that moment could
invoke fn without being queued or rejected. The check does not reserve capacity, and the throttled function always checks again when called. It returns false while calls are queued to preserve their order. Callers can avoid creating a timeout by only calling the throttled function when this method returns true.
pending{Promise|null} is the promise returned by the most recently queued
call, or null if no invocation is queued.
pendingCount{integer} is the number of calls awaiting invocation.activeCount{integer} is the number of invocations whose return values have
not settled.
ref()makes the pending and future timeout keep the Node.js event loop
active. Returns the throttled function.
unref()allows the event loop to exit while a timeout is pending. This also
applies to future timeouts. Returns the throttled function.
Calls that have already invoked fn are not affected by cancel() or by an aborted signal. When invoked, fn has the throttled function as its this value. The throttled function preserves the name and length of fn.
const request = throttle(async (id) => {
const response = await fetch(`https://example.com/items/${id}`);
return response.json();
}, 2, 1_000);
// At most two requests begin during each one-second interval. All other calls
// remain queued and retain their original arguments.
const results = await Promise.all([
request(1),
request(2),
request(3),
request(4),
]);util.diff(actual, expected)
<!-- YAML added:
- v23.11.0
- v22.15.0
-->
توجه: Stability: 1 - Experimental
actual{Array|string} The first value to compare
expected{Array|string} The second value to compare
- Returns: {Array} An array of difference entries. Each entry is an array with two elements:
0{number} Operation code:-1for delete,0for no-op/unchanged,1for insert1{string} The value associated with the operation
- Algorithm complexity: O(N\*D), where:
- N is the total length of the two sequences combined (N = actual.length + expected.length)
- D is the edit distance (the minimum number of operations required to transform one sequence into the other).
[util.diff()][] compares two string or array values and returns an array of difference entries. It uses the Myers diff algorithm to compute minimal differences, which is the same algorithm used internally by assertion error messages.
If the values are equal, an empty array is returned.
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])
<!-- YAML added: v0.5.3 changes:
- version: v12.11.0
pr-url: https://github.com/nodejs/node/pull/29606 description: The %c specifier is ignored now.
- version: v12.0.0
pr-url: https://github.com/nodejs/node/pull/23162 description: The format argument is now only taken as such if it actually contains format specifiers.
- version: v12.0.0
pr-url: https://github.com/nodejs/node/pull/23162 description: 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.
- version: v11.4.0
pr-url: https://github.com/nodejs/node/pull/23708 description: The %d, %f, and %i specifiers now support Symbols properly.
- version: v11.4.0
pr-url: https://github.com/nodejs/node/pull/24806 description: The %o specifier's depth has default depth of 4 again.
- version: v11.0.0
pr-url: https://github.com/nodejs/node/pull/17907 description: The %o specifier's depth option will now fall back to the default depth.
- version: v10.12.0
pr-url: https://github.com/nodejs/node/pull/22097 description: The %d and %i specifiers now support BigInt.
- version: v8.4.0
pr-url: https://github.com/nodejs/node/pull/14558 description: The %o and %O specifiers are supported now. -->
format{string} Aprintf-like format string.
The util.format() method returns a formatted string using the first argument as a printf-like format string which can contain zero or more format specifiers. Each specifier is replaced with the converted value from the corresponding argument. Supported specifiers are:
%s:Stringwill be used to convert all values exceptBigInt,Object
and -0. BigInt values will be represented with an n and Objects that have neither a user defined toString function nor Symbol.toPrimitive function are inspected using util.inspect() with options { depth: 0, colors: false, compact: 3 }.
%d:Numberwill be used to convert all values exceptBigIntand
Symbol.
%i:parseInt(value, 10)is used for all values exceptBigIntand
Symbol.
%f:parseFloat(value)is used for all values exceptSymbol.%j: JSON. Replaced with the string'[Circular]'if the argument contains
circular references.
%o:Object. A string representation of an object with generic JavaScript
object formatting. Similar to util.inspect() with options { showHidden: true, showProxy: true }. This will show the full object including non-enumerable properties and proxies.
%O:Object. A string representation of an object with generic JavaScript
object formatting. Similar to util.inspect() without options. This will show the full object not including non-enumerable properties and proxies.
%c:CSS. This specifier is ignored and will skip any CSS passed in.%%: single percent sign ('%'). This does not consume an argument.- Returns: {string} The formatted string
If a specifier does not have a corresponding argument, it is not replaced:
util.format('%s:%s', 'foo');
// Returns: 'foo:%s'Values that are not part of the format string are formatted using util.inspect() if their type is not string.
If there are more arguments passed to the util.format() method than the number of specifiers, the extra arguments are concatenated to the returned string, separated by spaces:
util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'If the first argument does not contain a valid format specifier, util.format() returns a string that is the concatenation of all arguments separated by spaces:
util.format(1, 2, 3);
// Returns: '1 2 3'If only one argument is passed to util.format(), it is returned as it is without any formatting:
util.format('%% %s');
// Returns: '%% %s'util.format() is a synchronous method that is intended as a debugging tool. Some input values can have a significant performance overhead that can block the event loop. Use this function with care and never in a hot code path.
util.formatWithOptions(inspectOptions, format[, ...args])
<!-- YAML added: 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.getCallSites([frameCount][, options])
<!-- YAML added: v22.9.0 changes:
- version:
- v23.7.0
- v22.14.0
pr-url: https://github.com/nodejs/node/pull/56584 description: Property column is deprecated in favor of columnNumber.
- version:
- v23.7.0
- v22.14.0
pr-url: https://github.com/nodejs/node/pull/56551 description: Property CallSite.scriptId is exposed.
- version:
- v23.3.0
- v22.12.0
pr-url: https://github.com/nodejs/node/pull/55626 description: The API is renamed from util.getCallSite to util.getCallSites(). -->
توجه: Stability: 1.1 - Active development
frameCount{integer} Optional number of frames to capture as call site objects.
Default: 10. Allowable range is between 1 and 200.
options{Object} OptionalsourceMap{boolean} Reconstruct the original location in the stacktrace from the source-map.
Enabled by default with the flag --enable-source-maps.
- Returns: {Object\[]} An array of call site objects
functionName{string} Returns the name of the function associated with this call site.scriptName{string} Returns the name of the resource that contains the script for the
function for this call site.
scriptId{string} Returns the unique id of the script, as in Chrome DevTools protocol [Runtime.ScriptId][].lineNumber{number} Returns the JavaScript script line number (1-based).columnNumber{number} Returns the JavaScript script column number (1-based).
Returns an array of call site objects containing the stack of the caller function.
Unlike accessing an error.stack, the result returned from this API is not interfered with Error.prepareStackTrace.
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.columnNumber}`);
});
// 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.columnNumber}`);
});
// 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();It is possible to reconstruct the original locations by setting the option sourceMap to true. If the source map is not available, the original location will be the same as the current location. When the --enable-source-maps flag is enabled, for example when using --experimental-transform-types, sourceMap will be true by default.
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: 26const { 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: 26util.getSystemErrorName(err)
<!-- YAML added: 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.getSystemErrorMap()
<!-- YAML added:
- v16.0.0
- v14.17.0
-->
- Returns: {Map}
Returns a Map of all system error codes available from the 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 errorMap = util.getSystemErrorMap();
const name = errorMap.get(err.errno);
console.error(name); // ENOENT
});util.getSystemErrorMessage(err)
<!-- YAML added:
- v23.1.0
- v22.12.0
-->
err{number}- Returns: {string}
Returns the string message for a numeric error code that comes from a Node.js API. The mapping between error codes and string messages is platform-dependent.
fs.access('file/that/does/not/exist', (err) => {
const message = util.getSystemErrorMessage(err.errno);
console.error(message); // No such file or directory
});util.setTraceSigInt(enable)
<!-- YAML added: v24.6.0 -->
enable{boolean}
Enable or disable printing a stack trace on SIGINT. The API is only available on the main thread.
util.inherits(constructor, superConstructor)
<!-- YAML added: v0.3.0 changes:
- version: v5.0.0
pr-url: https://github.com/nodejs/node/pull/3455 description: The constructor parameter can refer to an ES6 class now. -->
توجه: Stability: 3 - Legacy: Use ES2015 class syntax and extends keyword instead.
constructor{Function}superConstructor{Function}
Usage of util.inherits() is discouraged. Please use the ES6 class and extends keywords to get language level inheritance support. Also note that the two styles are [semantically incompatible][].
Inherit the prototype methods from one [constructor][] into another. The prototype of constructor will be set to a new object created from superConstructor.
This mainly adds some input validation on top of Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). As an additional convenience, superConstructor will be accessible through the constructor.super_ property.
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!"ES6 example using class and extends:
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]]])
<!-- YAML added: v0.3.0 changes:
- version:
- v17.3.0
- v16.14.0
pr-url: https://github.com/nodejs/node/pull/41003 description: The numericSeparator option is supported now.
- version: v16.18.0
pr-url: https://github.com/nodejs/node/pull/43576 description: add support for maxArrayLength when inspecting Set and Map.
- version:
- v14.6.0
- v12.19.0
pr-url: https://github.com/nodejs/node/pull/33690 description: If object is from a different vm.Context now, a custom inspection function on it will not receive context-specific arguments anymore.
- version:
- v13.13.0
- v12.17.0
pr-url: https://github.com/nodejs/node/pull/32392 description: The maxStringLength option is supported now.
- version:
- v13.5.0
- v12.16.0
pr-url: https://github.com/nodejs/node/pull/30768 description: User defined prototype properties are inspected in case showHidden is true.
- version: v13.0.0
pr-url: https://github.com/nodejs/node/pull/27685 description: Circular references now include a marker to the reference.
- version: v12.0.0
pr-url: https://github.com/nodejs/node/pull/27109 description: The compact options default is changed to 3 and the breakLength options default is changed to 80.
- version: v12.0.0
pr-url: https://github.com/nodejs/node/pull/24971 description: Internal properties no longer appear in the context argument of a custom inspection function.
- version: v11.11.0
pr-url: https://github.com/nodejs/node/pull/26269 description: The compact option accepts numbers for a new output mode.
- version: v11.7.0
pr-url: https://github.com/nodejs/node/pull/25006 description: ArrayBuffers now also show their binary contents.
- version: v11.5.0
pr-url: https://github.com/nodejs/node/pull/24852 description: The getters option is supported now.
- version: v11.4.0
pr-url: https://github.com/nodejs/node/pull/24326 description: The depth default changed back to 2.
- version: v11.0.0
pr-url: https://github.com/nodejs/node/pull/22846 description: The depth default changed to 20.
- version: v11.0.0
pr-url: https://github.com/nodejs/node/pull/22756 description: The inspection output is now limited to about 128 MiB. Data above that size will not be fully inspected.
- version: v10.12.0
pr-url: https://github.com/nodejs/node/pull/22788 description: The sorted option is supported now.
- version: v10.6.0
pr-url: https://github.com/nodejs/node/pull/20725 description: Inspecting linked lists and similar objects is now possible up to the maximum call stack size.
- version: v10.0.0
pr-url: https://github.com/nodejs/node/pull/19259 description: The WeakMap and WeakSet entries can now be inspected as well.
- version: v9.9.0
pr-url: https://github.com/nodejs/node/pull/17576 description: The compact option is supported now.
- version: v6.6.0
pr-url: https://github.com/nodejs/node/pull/8174 description: Custom inspection functions can now return this.
- version: v6.3.0
pr-url: https://github.com/nodejs/node/pull/7499 description: The breakLength option is supported now.
- version: v6.1.0
pr-url: https://github.com/nodejs/node/pull/6334 description: The maxArrayLength option is supported now; in particular, long arrays are truncated by default.
- version: v6.1.0
pr-url: https://github.com/nodejs/node/pull/6465 description: The showProxy option is supported now. -->
object{any} Any JavaScript primitive orObject.options{Object}showHidden{boolean} Iftrue,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} Iftrue, the output is styled with ANSI color
codes. Colors are customizable. See [Customizing util.inspect colors][]. Default: false.
customInspect{boolean} Iffalse,
[util.inspect.custom](depth, opts, inspect) functions are not invoked. Default: true.
showProxy{boolean} Iftrue,Proxyinspection includes
the [target and handler][] objects. Default: false.
maxArrayLength{integer} Specifies the maximum number ofArray,
{TypedArray}, {Map}, {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: 10000.
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 tofalsecauses each object key
to be displayed on a new line. It will break on new lines in 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. For more information, see the example below. Default: 3.
sorted{boolean|Function} If set totrueor 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 totrue, 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.
numericSeparator{boolean} If set totrue, an underscore is used to
separate every three digits in all bigints and numbers. 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 Symbol.toStringTag property 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 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] }
// }The following example inspects all properties of the util object:
console.log(util.inspect(util, { showHidden: true, depth: null }));const util = require('node:util');
console.log(util.inspect(util, { showHidden: true, depth: null }));The following example highlights the effect of the compact option:
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.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 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 } }The sorted option ensures that an object's property insertion order does not impact the result of util.inspect().
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 }),
);The numericSeparator option adds an underscore every three digits to all numbers.
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_45const { 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_45util.inspect() is a synchronous method intended for debugging. Its maximum output length is approximately 128 MiB. Inputs that result in longer output will be truncated.
Customizing util.inspect colors
<!-- type=misc -->
Color output (if enabled) of util.inspect is customizable globally via the util.inspect.styles and util.inspect.colors properties.
util.inspect.styles is a map associating a style name to a color from util.inspect.colors.
The default styles and associated colors are:
bigint:yellowboolean:yellowdate:magentamodule:underlinename: (no styling)null:boldnumber:yellowregexp:redspecial:cyan(e.g.,Proxies)string:greensymbol:greenundefined:grey
Color styling uses ANSI control codes that may not be supported on all terminals. To verify color support use [tty.hasColors()][].
Predefined control codes are listed below (grouped as "Modifiers", "Foreground colors", and "Background colors").
Modifiers
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
- <span style="border-bottom: 1px solid;">underline</span> - 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)- <span style="opacity: 0.5;">dim</span> - Decreased color intensity (Alias:
faint)
- <span style="border-top: 1px solid;">overlined</span> - Make text overlined
- blink - Hides and shows the text in an interval
- <span style="filter: invert(100%);">inverse</span> - Swap foreground and
background colors (Alias: swapcolors, swapColors)
- <span style="border-bottom: 1px double;">doubleunderline</span> - Make text
double underlined (Alias: doubleUnderline)
- <span style="border: 1px solid;">framed</span> - Draw a frame around the text
Foreground colors
blackredgreenyellowbluemagentacyanwhitegray(alias:grey,blackBright)redBrightgreenBrightyellowBrightblueBrightmagentaBrightcyanBrightwhiteBright
Background colors
bgBlackbgRedbgGreenbgYellowbgBluebgMagentabgCyanbgWhitebgGray(alias:bgGrey,bgBlackBright)bgRedBrightbgGreenBrightbgYellowBrightbgBlueBrightbgMagentaBrightbgCyanBrightbgWhiteBright
Custom inspection functions on objects
<!-- type=misc -->
<!-- YAML added: v0.1.97 changes:
- version:
- v17.3.0
- v16.14.0
pr-url: https://github.com/nodejs/node/pull/41019 description: The inspect argument is added for more interoperability. -->
Objects may also define their own [[util.inspect.custom](depth, opts, inspect)][util.inspect.custom] function, which util.inspect() will invoke and use the result of when inspecting the object.
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 >"Custom [util.inspect.custom](depth, opts, inspect) functions typically return a string but may return a value of any type that will be formatted accordingly by util.inspect().
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
<!-- YAML added: v6.6.0 changes:
- version: v10.12.0
pr-url: https://github.com/nodejs/node/pull/20857 description: This is now defined as a shared symbol. -->
- Type: {symbol} that can be used to declare custom inspect functions.
In addition to being accessible through util.inspect.custom, this symbol is [registered globally][global symbol registry] and can be accessed in any environment as Symbol.for('nodejs.util.inspect.custom').
Using this allows code to be written in a portable fashion, so that the custom inspect function is used in a Node.js environment and ignored in the browser. The util.inspect() function itself is passed as third argument to the custom inspect function to allow further portability.
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>See [Custom inspection functions on Objects][] for more details.
util.inspect.defaultOptions
<!-- YAML added: v6.4.0 -->
The defaultOptions value allows customization of the default options used by util.inspect. This is useful for functions like console.log or util.format which implicitly call into util.inspect. It shall be set to an object containing one or more valid [util.inspect()][] options. Setting option properties directly is also supported.
const arr = Array(156).fill(0);
console.log(arr); // Logs the truncated array
inspect.defaultOptions.maxArrayLength = null;
console.log(arr); // logs the full arrayconst { 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 arrayutil.isDeepStrictEqual(val1, val2[, options])
<!-- YAML added: v9.0.0 changes:
- version: v24.9.0
pr-url: https://github.com/nodejs/node/pull/59762 description: Added options parameter to allow skipping prototype comparison. -->
val1{any}val2{any}skipPrototype{boolean} Iftrue, prototype and constructor
comparison is skipped during deep strict equality check. Default: false.
- Returns: {boolean}
Returns true if there is deep strict equality between val1 and val2. Otherwise, returns false.
By default, deep strict equality includes comparison of object prototypes and constructors. When skipPrototype is true, objects with different prototypes or constructors can still be considered equal if their enumerable properties are deeply strictly equal.
const util = require('node:util');
class Foo {
constructor(a) {
this.a = a;
}
}
class Bar {
constructor(a) {
this.a = a;
}
}
const foo = new Foo(1);
const bar = new Bar(1);
// Different constructors, same properties
console.log(util.isDeepStrictEqual(foo, bar));
// false
console.log(util.isDeepStrictEqual(foo, bar, true));
// trueSee [assert.deepStrictEqual()][] for more information about deep strict equality.
util.markPromiseAsHandled(promise)
<!-- YAML added: v24.22.0 -->
promise{Promise} The promise to mark as handled
Marks a promise as handled so that unhandled rejections are ignored and are not reported to the 'unhandledrejection' event.
Class: util.MIMEType
<!-- YAML added:
- v19.1.0
- v18.13.0
changes:
- version:
- v23.11.0
- v22.15.0
pr-url: https://github.com/nodejs/node/pull/57510 description: Marking the API stable. -->
An implementation of the MIMEType class.
In accordance with browser conventions, all properties of MIMEType objects are implemented as getters and setters on the class prototype, rather than as data properties on the object itself.
A MIME string is a structured string containing multiple meaningful components. When parsed, a MIMEType object is returned containing properties for each of these components.
new MIMEType(input)
input{string} The input MIME to parse
Creates a new MIMEType object by parsing the input.
const myMIME = new MIMEType('text/plain');const { MIMEType } = require('node:util');
const myMIME = new MIMEType('text/plain');A TypeError will be thrown if the input is not a valid MIME. Note that an effort will be made to coerce the given values into strings. For instance:
const myMIME = new MIMEType({ toString: () => 'text/plain' });
console.log(String(myMIME));
// Prints: text/plainconst { MIMEType } = require('node:util');
const myMIME = new MIMEType({ toString: () => 'text/plain' });
console.log(String(myMIME));
// Prints: text/plainmime.type
- Type: {string}
Gets and sets the type portion of the MIME.
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/javascriptconst { 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/javascriptmime.subtype
- Type: {string}
Gets and sets the subtype portion of the MIME.
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/javascriptconst { 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/javascriptmime.essence
- Type: {string}
Gets the essence of the MIME. This property is read only. Use mime.type or mime.subtype to alter the MIME.
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=valueconst { 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=valuemime.params
- Type: {MIMEParams}
Gets the [MIMEParams][] object representing the parameters of the MIME. This property is read-only. See [MIMEParams][] documentation for details.
mime.toString()
- Returns: {string}
The toString() method on the MIMEType object returns the serialized MIME.
Because of the need for standard compliance, this method does not allow users to customize the serialization process of the MIME.
mime.toJSON()
- Returns: {string}
Alias for [mime.toString()][].
This method is automatically called when an MIMEType object is serialized with [JSON.stringify()][].
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"]MIMEType.parse(string)
<!-- added: v24.21.0 -->
string{string} The input MIME to parse- Returns: {MIMEType|null}
Attempts to parse the given string as a MIMEType. If the string cannot be parsed, null is returned.
Class: util.MIMEParams
<!-- YAML added:
- v19.1.0
- v18.13.0
-->
The MIMEParams API provides read and write access to the parameters of a MIMEType.
new MIMEParams()
Creates a new MIMEParams object by with empty parameters
const myParams = new MIMEParams();const { MIMEParams } = require('node:util');
const myParams = new MIMEParams();mimeParams.delete(name)
name{string}
Remove all name-value pairs whose name is name.
mimeParams.entries()
- Returns: {Iterator}
Returns an iterator over each of the name-value pairs in the parameters. Each item of the iterator is a JavaScript Array. The first item of the array is the name, the second item of the array is the value.
mimeParams.get(name)
name{string}- Returns: {string | null} A string or
nullif there is no name-value pair
with the given name.
Returns the value of the first name-value pair whose name is name. If there are no such pairs, null is returned.
mimeParams.has(name)
name{string}- Returns: {boolean}
Returns true if there is at least one name-value pair whose name is name.
mimeParams.keys()
- Returns: {Iterator}
Returns an iterator over the names of each name-value pair.
const { params } = new MIMEType('text/plain;foo=0;bar=1');
for (const name of params.keys()) {
console.log(name);
}
// Prints:
// foo
// barconst { 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
// barmimeParams.set(name, value)
name{string}value{string}
Sets the value in the MIMEParams object associated with name to value. If there are any pre-existing name-value pairs whose names are name, set the first such pair's value to value.
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=xyzconst { 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=xyzmimeParams.values()
- Returns: {Iterator}
Returns an iterator over the values of each name-value pair.
mimeParams[Symbol.iterator]()
- Returns: {Iterator}
Alias for [mimeParams.entries()][].
const { params } = new MIMEType('text/plain;foo=bar;xyz=baz');
for (const [name, value] of params) {
console.log(name, value);
}
// Prints:
// foo bar
// xyz bazconst { 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 bazutil.parseArgs([config])
<!-- YAML added:
- v18.3.0
- v16.17.0
changes:
- version:
- v22.4.0
- v20.16.0
pr-url: https://github.com/nodejs/node/pull/53107 description: add support for allowing negative options in input config.
- version:
- v20.0.0
pr-url: https://github.com/nodejs/node/pull/46718 description: The API is no longer experimental.
- version:
- v18.11.0
- v16.19.0
pr-url: https://github.com/nodejs/node/pull/44631 description: Add support for default values in input config.
- version:
- v18.7.0
- v16.17.0
pr-url: https://github.com/nodejs/node/pull/43459 description: add support for returning detailed parse information using tokens in input config and returned properties. -->
config{Object} Used to provide arguments for parsing and to configure
the parser. config supports the following properties:
args{string\[]} array of argument strings. Default:process.argv
with execPath and filename removed.
options{Object} Used to describe arguments known to the parser.
Keys of options are the long names of options and values are an {Object} accepting the following properties:
type{string} Type of argument, which must be eitherbooleanorstring.multiple{boolean} Whether this option can be provided multiple
times. If true, all values will be collected in an array. If false, values for the option are last-wins. Default: false.
short{string} A single character alias for the option.default{string | boolean | string\[] | boolean\[]} The value to assign to
the option if it does not appear in the arguments to be parsed. The value must match the type specified by the type property. If multiple is true, it must be an array. No default value is applied when the option does appear in the arguments to be parsed, even if the provided value is falsy.
strict{boolean} Should an error be thrown when unknown arguments
are encountered, or when arguments are passed that do not match the type configured in options. Default: true.
allowPositionals{boolean} Whether this command accepts positional
arguments. Default: false if strict is true, otherwise true.
allowNegative{boolean} Iftrue, allows explicitly setting boolean
options to false by prefixing the option name with --no-. Default: false.
tokens{boolean} Return the parsed tokens. This is useful for extending
the built-in behavior, from adding additional checks through to reprocessing the tokens in different ways. Default: false.
- Returns: {Object} The parsed command line arguments:
values{Object} A mapping of parsed option names with their {string}
or {boolean} values.
positionals{string\[]} Positional arguments.tokens{Object\[] | undefined} See parseArgs tokens
section. Only returned if config includes tokens: true.
Provides a higher level API for command-line argument parsing than interacting with process.argv directly. Takes a specification for the expected arguments and returns a structured object with the parsed options and positionals.
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
Detailed parse information is available for adding custom behaviors by specifying tokens: true in the configuration. The returned tokens have properties describing:
- all tokens
kind{string} One of 'option', 'positional', or 'option-terminator'.index{number} Index of element inargscontaining token. So the
source argument for a token is args[token.index].
- option tokens
name{string} Long name of option.rawName{string} How option used in args, like-fof--foo.value{string | undefined} Option value specified in args.
Undefined for boolean options.
inlineValue{boolean | undefined} Whether option value specified inline,
like --foo=bar.
- positional tokens
value{string} The value of the positional argument in args (i.e.args[index]).- option-terminator token
The returned tokens are in the order encountered in the input args. Options that appear more than once in args produce a token for each use. Short option groups like -xy expand to a token for each option. So -xxx produces three tokens.
For example, to add support for a negated option like --no-color (which allowNegative supports when the option is of boolean type), the returned tokens can be reprocessed to change the value stored for the negated option.
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 });Example usage showing negated options, and when an option is used multiple ways then last one wins.
$ 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)
<!-- YAML added:
- v21.7.0
- v20.12.0
changes:
- version: v24.10.0
pr-url: https://github.com/nodejs/node/pull/59925 description: This API is no longer experimental. -->
content{string}
The raw contents of a .env file.
- Returns: {Object}
Given an example .env file:
const { parseEnv } = require('node:util');
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }util.promisify(original)
<!-- YAML added: v8.0.0 changes:
- version: v20.8.0
pr-url: https://github.com/nodejs/node/pull/49647 description: Calling promisify on a function that returns a Promise is deprecated. -->
original{Function}- Returns: {Function}
Takes a function following the common error-first callback style, i.e. taking an (err, value) => ... callback as the last argument, and returns a version that returns promises.
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.
});Or, equivalently using async functions:
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();If there is an original[util.promisify.custom] property present, promisify will return its value, see [Custom promisified functions][].
promisify() assumes that original is a function taking a callback as its final argument in all cases. If original is not a function, promisify() will throw an error. If original is a function but its last argument is not an error-first callback, it will still be passed an error-first callback as its last argument.
Using promisify() on class methods or other methods that use this may not work as expected unless handled specially:
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'Custom promisified functions
Using the util.promisify.custom symbol one can override the return value of [util.promisify()][]:
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'This can be useful for cases where the original function does not follow the standard format of taking an error-first callback as the last argument.
For example, with a function that takes in (foo, onSuccessCallback, onErrorCallback):
doSomething[util.promisify.custom] = (foo) => {
return new Promise((resolve, reject) => {
doSomething(foo, resolve, reject);
});
};If promisify.custom is defined but is not a function, promisify() will throw an error.
util.promisify.custom
<!-- YAML added: v8.0.0 changes:
- version:
- v13.12.0
- v12.16.2
pr-url: https://github.com/nodejs/node/pull/31672 description: This is now defined as a shared symbol. -->
- Type: {symbol} that can be used to declare custom promisified variants of functions,
see [Custom promisified functions][].
In addition to being accessible through util.promisify.custom, this symbol is [registered globally][global symbol registry] and can be accessed in any environment as Symbol.for('nodejs.util.promisify.custom').
For example, with a function that takes in (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)
<!-- YAML added: v16.11.0 -->
str{string}- Returns: {string}
Returns str with any ANSI escape codes removed.
console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"util.styleText(format, text[, options])
<!-- YAML added:
- v21.7.0
- v20.12.0
changes:
- version: v24.16.0
pr-url: https://github.com/nodejs/node/pull/61556 description: Add support for hexadecimal colors.
- version: v24.2.0
pr-url: https://github.com/nodejs/node/pull/58437 description: Added the 'none' format as a non-op format.
- version:
- v23.5.0
- v22.13.0
pr-url: https://github.com/nodejs/node/pull/56265 description: styleText is now stable.
- version:
- v22.8.0
- v20.18.0
pr-url: https://github.com/nodejs/node/pull/54389 description: Respect isTTY and environment variables such as NO_COLOR, NODE_DISABLE_COLORS, and FORCE_COLOR. -->
format{string | Array} A text format or an Array
of text formats defined in util.inspect.colors, or a hex color in #RGB or #RRGGBB form.
text{string} The text to be formatted.options{Object}validateStream{boolean} When true,streamis checked to see if it can handle colors. Default:true.stream{Stream} A stream that will be validated if it can be colored. Default:process.stdout.
This function returns a formatted text considering the format passed for printing in a terminal. It is aware of the terminal's capabilities and acts according to the configuration set via NO_COLOR, NODE_DISABLE_COLORS and FORCE_COLOR environment variables.
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 also provides text formats such as italic, and underline and you can combine both:
console.log(
util.styleText(['underline', 'italic'], 'My italic underlined message'),
);When passing an array of formats, the order of the format applied is left to right so the following style might overwrite the previous one.
console.log(
util.styleText(['red', 'green'], 'text'), // green
);The special format value none applies no additional styling to the text.
In addition to predefined color names, util.styleText() supports hex color strings using ANSI TrueColor (24-bit) escape sequences. Hex colors can be specified in either 3-digit (#RGB) or 6-digit (#RRGGBB) format:
// 6-digit hex color
console.log(styleText('#ff5733', 'Orange text'));
// 3-digit hex color (shorthand)
console.log(styleText('#f00', 'Red text'));const { styleText } = require('node:util');
// 6-digit hex color
console.log(styleText('#ff5733', 'Orange text'));
// 3-digit hex color (shorthand)
console.log(styleText('#f00', 'Red text'));The full list of formats can be found in [modifiers][].
Class: util.TextDecoder
<!-- YAML added: v8.3.0 changes:
- version: v11.0.0
pr-url: https://github.com/nodejs/node/pull/22281 description: The class is now available on the global object. -->
An implementation of the [WHATWG Encoding Standard][] TextDecoder API.
const decoder = new TextDecoder();
const u8arr = new Uint8Array([72, 101, 108, 108, 111]);
console.log(decoder.decode(u8arr)); // HelloWHATWG supported encodings
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][])
Encodings supported by default (with full ICU data)
| 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' |
Encodings supported when Node.js is built with the small-icu option
| Encoding | Aliases |
|---|---|
'utf-8' | 'unicode-1-1-utf-8', 'utf8' |
'utf-16le' | 'utf-16' |
'utf-16be' |
Encodings supported when ICU is disabled
| 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]])
encoding{string} Identifies theencodingthat thisTextDecoderinstance
supports. Default: 'utf-8'.
options{Object}fatal{boolean}trueif decoding failures are fatal.
This option is not supported when ICU is disabled (see [Internationalization][]). Default: false.
ignoreBOM{boolean} Whentrue, theTextDecoderwill 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 a 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} AnArrayBuffer,DataView, or
TypedArray instance containing the encoded data.
options{Object}stream{boolean}trueif 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
- Type: {string}
The encoding supported by the TextDecoder instance.
textDecoder.fatal
- Type: {boolean}
The value will be true if decoding errors result in a TypeError being thrown.
textDecoder.ignoreBOM
- Type: {boolean}
The value will be true if the decoding result will include the byte order mark.
Class: util.TextEncoder
<!-- YAML added: v8.3.0 changes:
- version: v11.0.0
pr-url: https://github.com/nodejs/node/pull/22281 description: The class is now available on the global object. -->
An implementation of the [WHATWG Encoding Standard][] TextEncoder API. All instances of TextEncoder only support UTF-8 encoding.
const encoder = new TextEncoder();
const uint8array = encoder.encode('this is some data');The TextEncoder class is also available on the global object.
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)
<!-- YAML added: v12.11.0 -->
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
- Type: {string}
The encoding supported by the TextEncoder instance. Always set to 'utf-8'.
util.toUSVString(string)
<!-- YAML added:
- v16.8.0
- v14.18.0
-->
string{string}
Returns the string after replacing any surrogate code points (or equivalently, any unpaired surrogate code units) with the Unicode "replacement character" U+FFFD.
util.transferableAbortController()
<!-- YAML added: v18.11.0 changes:
- version:
- v23.11.0
- v22.15.0
pr-url: https://github.com/nodejs/node/pull/57510 description: Marking the API stable. -->
Creates and returns an {AbortController} instance whose {AbortSignal} is marked as transferable and can be used with structuredClone() or postMessage().
util.transferableAbortSignal(signal)
<!-- YAML added: v18.11.0 changes:
- version:
- v23.11.0
- v22.15.0
pr-url: https://github.com/nodejs/node/pull/57510 description: Marking the API stable. -->
signal{AbortSignal}- Returns: {AbortSignal}
Marks the given {AbortSignal} as transferable so that it can be used with structuredClone() and postMessage().
const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);util.aborted(signal, resource)
<!-- YAML added:
- v19.7.0
- v18.16.0
changes:
- version: v24.0.0
pr-url: https://github.com/nodejs/node/pull/57765 description: Change stability index for this feature from Experimental to Stable. -->
signal{AbortSignal}resource{Object} Any non-null object tied to the abortable operation and held weakly.
If resource is garbage collected before the signal aborts, the promise remains pending, allowing Node.js to stop tracking it. This helps prevent memory leaks in long-running or non-cancelable operations.
- Returns: {Promise}
Listens to abort event on the provided signal and returns a promise that resolves when the signal is aborted. If resource is provided, it weakly references the operation's associated object, so if resource is garbage collected before the signal aborts, then returned promise shall remain pending. This prevents memory leaks in long-running or non-cancelable operations.
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.
});
// 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
<!-- YAML added: v10.0.0 changes:
- version: v15.3.0
pr-url: https://github.com/nodejs/node/pull/34055 description: Exposed as require('util/types'). -->
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.
The API is accessible via require('node:util').types or require('node:util/types').
util.types.isAnyArrayBuffer(value)
<!-- YAML added: v10.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is a built-in {ArrayBuffer} or {SharedArrayBuffer} instance.
See also [util.types.isArrayBuffer()][] and [util.types.isSharedArrayBuffer()][].
util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns trueutil.types.isArrayBufferView(value)
<!-- YAML added: 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()); // falseutil.types.isArgumentsObject(value)
<!-- YAML added: v10.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is an arguments object.
<!-- eslint-disable prefer-rest-params -->
function foo() {
util.types.isArgumentsObject(arguments); // Returns true
}util.types.isArrayBuffer(value)
<!-- YAML added: 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 falseutil.types.isAsyncFunction(value)
<!-- YAML added: 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 trueutil.types.isBigInt64Array(value)
<!-- YAML added: 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 falseutil.types.isBigIntObject(value)
<!-- YAML added: v10.4.0 -->
value{any}- Returns: {boolean}
Returns true if the value is a BigInt object, e.g. created by Object(BigInt(123)).
util.types.isBigIntObject(Object(BigInt(123))); // Returns true
util.types.isBigIntObject(BigInt(123)); // Returns false
util.types.isBigIntObject(123); // Returns falseutil.types.isBigUint64Array(value)
<!-- YAML added: 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 trueutil.types.isBooleanObject(value)
<!-- YAML added: 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 falseutil.types.isBoxedPrimitive(value)
<!-- YAML added: 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 trueutil.types.isCryptoKey(value)
<!-- YAML added: v16.2.0 -->
value{Object}- Returns: {boolean}
Returns true if value is a {CryptoKey}, false otherwise.
util.types.isDataView(value)
<!-- YAML added: 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 falseSee also [ArrayBuffer.isView()][].
util.types.isDate(value)
<!-- YAML added: v10.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is a built-in {Date} instance.
util.types.isDate(new Date()); // Returns trueutil.types.isExternal(value)
<!-- YAML added: 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][Object.freeze()] 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 data = native.myNapi();
types.isExternal(data); // returns true
types.isExternal(0); // returns false
types.isExternal(new String('foo')); // returns falseconst 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 falseFor further information on napi_create_external, refer to [napi_create_external()][].
util.types.isFloat16Array(value)
<!-- YAML added: v24.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is a built-in {Float16Array} instance.
util.types.isFloat16Array(new ArrayBuffer()); // Returns false
util.types.isFloat16Array(new Float16Array()); // Returns true
util.types.isFloat16Array(new Float32Array()); // Returns falseutil.types.isFloat32Array(value)
<!-- YAML added: 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 falseutil.types.isFloat64Array(value)
<!-- YAML added: 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 trueutil.types.isGeneratorFunction(value)
<!-- YAML added: 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 trueutil.types.isGeneratorObject(value)
<!-- YAML added: 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 trueutil.types.isInt8Array(value)
<!-- YAML added: 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 falseutil.types.isInt16Array(value)
<!-- YAML added: 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 falseutil.types.isInt32Array(value)
<!-- YAML added: 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 falseutil.types.isKeyObject(value)
<!-- YAML added: v16.2.0 -->
value{Object}- Returns: {boolean}
Returns true if value is a {KeyObject}, false otherwise.
util.types.isMap(value)
<!-- YAML added: v10.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is a built-in {Map} instance.
util.types.isMap(new Map()); // Returns trueutil.types.isMapIterator(value)
<!-- YAML added: 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 trueutil.types.isModuleNamespaceObject(value)
<!-- YAML added: v10.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is an instance of a [Module Namespace Object][].
util.types.isModuleNamespaceObject(ns); // Returns trueutil.types.isNativeError(value)
<!-- YAML added: v10.0.0 deprecated: v24.2.0 -->
توجه: Stability: 0 - Deprecated: Use [Error.isError][] instead.
Note: As of Node.js 24, Error.isError() is currently slower than util.types.isNativeError(). If performance is critical, consider benchmarking both in your environment.
value{any}- Returns: {boolean}
Returns true if the value was returned by the constructor of a [built-in Error type][].
console.log(util.types.isNativeError(new Error())); // true
console.log(util.types.isNativeError(new TypeError())); // true
console.log(util.types.isNativeError(new RangeError())); // trueSubclasses of the native error types are also native errors:
class MyError extends Error {}
console.log(util.types.isNativeError(new MyError())); // trueA value being instanceof a native error class is not equivalent to isNativeError() returning true for that value. isNativeError() returns true for errors which come from a different [realm][] while instanceof Error returns false for these errors:
const context = createContext({});
const myError = runInContext('new Error()', context);
console.log(types.isNativeError(myError)); // true
console.log(myError instanceof Error); // falseconst { 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); // falseConversely, isNativeError() returns false for all objects which were not returned by the constructor of a native error. That includes values which are instanceof native errors:
const myError = { __proto__: Error.prototype };
console.log(util.types.isNativeError(myError)); // false
console.log(myError instanceof Error); // trueutil.types.isNumberObject(value)
<!-- YAML added: 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 trueutil.types.isPromise(value)
<!-- YAML added: v10.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is a built-in {Promise}.
util.types.isPromise(Promise.resolve(42)); // Returns trueutil.types.isProxy(value)
<!-- YAML added: 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 trueutil.types.isRegExp(value)
<!-- YAML added: 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 trueutil.types.isSet(value)
<!-- YAML added: v10.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is a built-in {Set} instance.
util.types.isSet(new Set()); // Returns trueutil.types.isSetIterator(value)
<!-- YAML added: 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 trueutil.types.isSharedArrayBuffer(value)
<!-- YAML added: 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 trueutil.types.isStringObject(value)
<!-- YAML added: 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 trueutil.types.isSymbolObject(value)
<!-- YAML added: 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 trueutil.types.isTypedArray(value)
<!-- YAML added: 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 trueSee also [ArrayBuffer.isView()][].
util.types.isUint8Array(value)
<!-- YAML added: 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 falseutil.types.isUint8ClampedArray(value)
<!-- YAML added: 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 falseutil.types.isUint16Array(value)
<!-- YAML added: 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 falseutil.types.isUint32Array(value)
<!-- YAML added: 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 falseutil.types.isWeakMap(value)
<!-- YAML added: v10.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is a built-in {WeakMap} instance.
util.types.isWeakMap(new WeakMap()); // Returns trueutil.types.isWeakSet(value)
<!-- YAML added: v10.0.0 -->
value{any}- Returns: {boolean}
Returns true if the value is a built-in {WeakSet} instance.
util.types.isWeakSet(new WeakSet()); // Returns trueDeprecated APIs
The following APIs are deprecated and should no longer be used. Existing applications and modules should be updated to find alternative approaches.
util._extend(target, source)
<!-- YAML added: v0.7.5 deprecated: v6.0.0 -->
توجه: Stability: 0 - Deprecated: Use [Object.assign()][] instead.
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()][].
An automated migration is available (source):
npx codemod@latest @nodejs/util-extend-to-object-assignutil.isArray(object)
<!-- YAML added: v0.6.0 deprecated: v4.0.0 -->
توجه: Stability: 0 - Deprecated: Use [Array.isArray()][] instead.
object{any}- Returns: {boolean}
Alias for [Array.isArray()][].
Returns true if the given object is an Array. Otherwise, returns false.
const util = require('node:util');
util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: falseAn automated migration is available (source):
npx codemod@latest @nodejs/util-is[Common System Errors]: errors.md#common-system-errors [Custom inspection functions on objects]: #custom-inspection-functions-on-objects [Custom promisified functions]: #custom-promisified-functions [Customizing util.inspect colors]: #customizing-utilinspect-colors [Internationalization]: intl.md [Module Namespace Object]: https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects [WHATWG Encoding Standard]: https://encoding.spec.whatwg.org/ ['uncaughtException']: process.md#event-uncaughtexception ['warning']: process.md#event-warning [Array.isArray()]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray [ArrayBuffer.isView()]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView [Error.isError]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/isError [JSON.stringify()]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify [MIMEparams]: #class-utilmimeparams [Object.assign()]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign [Object.freeze()]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze [Runtime.ScriptId]: https://chromedevtools.github.io/devtools-protocol/1-3/Runtime/#type-ScriptId [assert.deepStrictEqual()]: assert.md#assertdeepstrictequalactual-expected-message [console.error()]: console.md#consoleerrordata-args [mime.toString()]: #mimetostring [mimeParams.entries()]: #mimeparamsentries [napi_create_external()]: n-api.md#napi_create_external [signal(7)]: https://man7.org/linux/man-pages/man7/signal.7.html [target and handler]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy#terminology [tty.hasColors()]: tty.md#writestreamhascolorscount-env [util.diff()]: #utildiffactual-expected [util.format()]: #utilformatformat-args [util.inspect()]: #utilinspectobject-options [util.promisify()]: #utilpromisifyoriginal [util.types.isAnyArrayBuffer()]: #utiltypesisanyarraybuffervalue [util.types.isArrayBuffer()]: #utiltypesisarraybuffervalue [util.types.isSharedArrayBuffer()]: #utiltypesissharedarraybuffervalue [async function]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function [built-in Error type]: https://tc39.es/ecma262/#sec-error-objects [compare function]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#parameters [constructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor [default sort]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort [global symbol registry]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/for [list of deprecated APIS]: deprecations.md#list-of-deprecated-apis [modifiers]: #modifiers [realm]: https://tc39.es/ecma262/#realm [semantically incompatible]: https://github.com/nodejs/node/issues/4179 [util.inspect.custom]: #utilinspectcustom