util.callbackify(original)#

• original<Function> Anasync function
• Returns:<Function> a callback style function

Takes anasync function (or a function that returns aPromise) and returns afunction following the error-first callback style, i.e. takingan(err, value) => ... callback as the last argument. In the callback, thefirst argument will be the rejection reason (ornull if thePromiseresolved), and the second argument will be the resolved value.

import { callbackify }from'node:util';asyncfunctionfn() {return'hello world';}const callbackFunction =callbackify(fn);callbackFunction((err, ret) => {if (err)throw err;console.log(ret);});const { callbackify } =require('node:util');asyncfunctionfn() {return'hello world';}const callbackFunction =callbackify(fn);callbackFunction((err, ret) => {if (err)throw err;console.log(ret);});copy

Will print:

hello worldcopy

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

Sincenull has a special meaning as the first argument to a callback, if awrapped function rejects aPromise with a falsy value as a reason, the valueis wrapped in anError with the original value stored in a field namedreason.

functionfn() {returnPromise.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});copy

util.debuglog(section[, callback])#

• section<string> A string identifying the portion of the application forwhich thedebuglog function is being created.
• callback<Function> A callback invoked the first time the logging functionis called with a function argument that is a more optimized logging function.
• Returns:<Function> The logging function

Theutil.debuglog() method is used to create a function that conditionallywrites debug messages tostderr based on the existence of theNODE_DEBUGenvironment variable. If thesection name appears within the value of thatenvironment variable, then the returned function operates similar toconsole.error(). If not, then the returned function is a no-op.

import { debuglog }from'node:util';const log =debuglog('foo');log('hello from foo [%d]',123);const { debuglog } =require('node:util');const log =debuglog('foo');log('hello from foo [%d]',123);copy

If this program is run withNODE_DEBUG=foo in the environment, thenit will output something like:

FOO 3245: hello from foo [123]copy

where3245 is the process id. If it is not run with thatenvironment variable set, then it will not print anything.

Thesection supports wildcard also:

import { debuglog }from'node:util';const log =debuglog('foo');log('hi there, it\'s foo-bar [%d]',2333);const { debuglog } =require('node:util');const log =debuglog('foo');log('hi there, it\'s foo-bar [%d]',2333);copy

if it is run withNODE_DEBUG=foo* in the environment, then it will outputsomething like:

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

Multiple comma-separatedsection names may be specified in theNODE_DEBUGenvironment variable:NODE_DEBUG=fs,net,tls.

The optionalcallback argument can be used to replace the logging functionwith a different function that doesn't have any initialization orunnecessary wrapping.

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

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

hello from foo [123]copy

util.debug(section)#

Alias forutil.debuglog. Usage allows for readability of that doesn't implylogging when only usingutil.debuglog().enabled.

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

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

Theutil.deprecate() method wrapsfn (which may be a function or class) insuch a way that it is marked as deprecated.

import { deprecate }from'node:util';exportconst obsoleteFunction =deprecate(() => {// Do something here.},'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');const { deprecate } =require('node:util');exports.obsoleteFunction =deprecate(() => {// Do something here.},'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');copy

When called,util.deprecate() will return a function that will emit aDeprecationWarning using the'warning' event. The warning willbe emitted and printed tostderr the first time the returned function iscalled. After the warning is emitted, the wrapped function is called withoutemitting a warning.

If the same optionalcode is supplied in multiple calls toutil.deprecate(),the warning will be emitted only once for thatcode.

import { deprecate }from'node:util';const fn1 =deprecate(() =>'a value','deprecation message','DEP0001',);const fn2 =deprecate(() =>'a  different value','other dep message','DEP0001',);fn1();// Emits a deprecation warning with code DEP0001fn2();// 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 DEP0001fn2();// Does not emit a deprecation warning because it has the same codecopy

If either the--no-deprecation or--no-warnings command-line flags areused, or if theprocess.noDeprecation property is set totrueprior tothe first deprecation warning, theutil.deprecate() method does nothing.

If the--trace-deprecation or--trace-warnings command-line flags are set,or theprocess.traceDeprecation property is set totrue, a warning and astack trace are printed tostderr the first time the deprecated function iscalled.

If the--throw-deprecation command-line flag is set, or theprocess.throwDeprecation property is set totrue, then an exception will bethrown when the deprecated function is called.

The--throw-deprecation command-line flag andprocess.throwDeprecationproperty take precedence over--trace-deprecation andprocess.traceDeprecation.

util.diff(actual, expected)#

• 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:-1 for delete,0 for no-op/unchanged,1 for insert
  • 1<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 algorithmused internally by assertion error messages.

If the values are equal, an empty array is returned.

const { diff } =require('node:util');// Comparing stringsconst 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 arraysconst 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 arrayconsole.log(diff('same','same'));// []copy

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

• format<string> Aprintf-like format string.

Theutil.format() method returns a formatted string using the first argumentas aprintf-like format string which can contain zero or more formatspecifiers. Each specifier is replaced with the converted value from thecorresponding argument. Supported specifiers are:

• %s:String will be used to convert all values exceptBigInt,Objectand-0.BigInt values will be represented with ann and Objects thathave neither a user definedtoString function norSymbol.toPrimitive function are inspected usingutil.inspect()with options{ depth: 0, colors: false, compact: 3 }.
• %d:Number will be used to convert all values exceptBigInt andSymbol.
• %i:parseInt(value, 10) is used for all values exceptBigInt andSymbol.
• %f:parseFloat(value) is used for all values expectSymbol.
• %j: JSON. Replaced with the string'[Circular]' if the argument containscircular references.
• %o:Object. A string representation of an object with generic JavaScriptobject formatting. Similar toutil.inspect() with options{ showHidden: true, showProxy: true }. This will show the full objectincluding non-enumerable properties and proxies.
• %O:Object. A string representation of an object with generic JavaScriptobject formatting. Similar toutil.inspect() without options. This will showthe 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'copy

Values that are not part of the format string are formatted usingutil.inspect() if their type is notstring.

If there are more arguments passed to theutil.format() method than thenumber of specifiers, the extra arguments are concatenated to the returnedstring, separated by spaces:

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

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

If only one argument is passed toutil.format(), it is returned as it iswithout any formatting:

util.format('%% %s');// Returns: '%% %s'copy

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 theevent loop. Use this function with care and never in a hot code path.

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

• inspectOptions<Object>
• format<string>

This function is identical toutil.format(), except in that it takesaninspectOptions argument which specifies options that are passed along toutil.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.copy

util.getCallSites([frameCount][, options])#

• frameCount<number> Optional number of frames to capture as call site objects.Default:10. Allowable range is between 1 and 200.
• options<Object> Optional
  • sourceMap<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 thefunction for this call site.
  • scriptId<string> Returns the unique id of the script, as in Chrome DevTools protocolRuntime.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 ofthe caller function.

import { getCallSites }from'node:util';functionexampleFunction() {const callSites =getCallSites();console.log('Call Sites:');  callSites.forEach((callSite, index) => {console.log(`CallSite${index +1}:`);console.log(`Function Name:${callSite.functionName}`);console.log(`Script Name:${callSite.scriptName}`);console.log(`Line Number:${callSite.lineNumber}`);console.log(`Column Number:${callSite.column}`);  });// CallSite 1:// Function Name: exampleFunction// Script Name: /home/example.js// Line Number: 5// Column Number: 26// CallSite 2:// Function Name: anotherFunction// Script Name: /home/example.js// Line Number: 22// Column Number: 3// ...}// A function to simulate another stack layerfunctionanotherFunction() {exampleFunction();}anotherFunction();const { getCallSites } =require('node:util');functionexampleFunction() {const callSites =getCallSites();console.log('Call Sites:');  callSites.forEach((callSite, index) => {console.log(`CallSite${index +1}:`);console.log(`Function Name:${callSite.functionName}`);console.log(`Script Name:${callSite.scriptName}`);console.log(`Line Number:${callSite.lineNumber}`);console.log(`Column Number:${callSite.column}`);  });// CallSite 1:// Function Name: exampleFunction// Script Name: /home/example.js// Line Number: 5// Column Number: 26// CallSite 2:// Function Name: anotherFunction// Script Name: /home/example.js// Line Number: 22// Column Number: 3// ...}// A function to simulate another stack layerfunctionanotherFunction() {exampleFunction();}anotherFunction();copy

It is possible to reconstruct the original locations by setting the optionsourceMap totrue.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.

import { getCallSites }from'node:util';interfaceFoo {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: 26copy

const { getCallSites } =require('node:util');const callSites =getCallSites({sourceMap:true });// With sourceMap:// Function Name: ''// Script Name: example.js// Line Number: 7// Column Number: 26// Without sourceMap:// Function Name: ''// Script Name: example.js// Line Number: 2// Column Number: 26copy

util.getSystemErrorName(err)#

• 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.SeeCommon 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});copy

util.getSystemErrorMap()#

• 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.SeeCommon 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});copy

util.getSystemErrorMessage(err)#

• err<number>
• Returns:<string>

Returns the string message for a numeric error code that comes from a Node.jsAPI.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});copy

util.setTraceSigInt(enable)#

• enable<boolean>

Enable or disable printing a stack trace onSIGINT. The API is only available on the main thread.

util.inherits(constructor, superConstructor)#

• constructor<Function>
• superConstructor<Function>

Usage ofutil.inherits() is discouraged. Please use the ES6class andextends keywords to get language level inheritance support. Also notethat the two styles aresemantically incompatible.

Inherit the prototype methods from oneconstructor into another. Theprototype ofconstructor will be set to a new object created fromsuperConstructor.

This mainly adds some input validation on top ofObject.setPrototypeOf(constructor.prototype, superConstructor.prototype).As an additional convenience,superConstructor will be accessiblethrough theconstructor.super_ property.

const util =require('node:util');constEventEmitter =require('node:events');functionMyStream() {EventEmitter.call(this);}util.inherits(MyStream,EventEmitter);MyStream.prototype.write =function(data) {this.emit('data', data);};const stream =newMyStream();console.log(streaminstanceofEventEmitter);// trueconsole.log(MyStream.super_ ===EventEmitter);// truestream.on('data',(data) => {console.log(`Received data: "${data}"`);});stream.write('It works!');// Received data: "It works!"copy

ES6 example usingclass andextends:

importEventEmitterfrom'node:events';classMyStreamextendsEventEmitter {write(data) {this.emit('data', data);  }}const stream =newMyStream();stream.on('data',(data) => {console.log(`Received data: "${data}"`);});stream.write('With ES6');constEventEmitter =require('node:events');classMyStreamextendsEventEmitter {write(data) {this.emit('data', data);  }}const stream =newMyStream();stream.on('data',(data) => {console.log(`Received data: "${data}"`);});stream.write('With ES6');copy

util.inspect(object[, options])#

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

• object<any> Any JavaScript primitive orObject.
• options<Object>
  • showHidden<boolean> Iftrue,object's non-enumerable symbols andproperties are included in the formatted result.<WeakMap> and<WeakSet> entries are also included as well as user defined prototypeproperties (excluding method properties).Default:false.
  • depth<number> Specifies the number of times to recurse while formattingobject. This is useful for inspecting large objects. To recurse up tothe maximum call stack size passInfinity ornull.Default:2.
  • colors<boolean> Iftrue, the output is styled with ANSI colorcodes. Colors are customizable. SeeCustomizingutil.inspect colors.Default:false.
  • customInspect<boolean> Iffalse,[util.inspect.custom](depth, opts, inspect) functions are not invoked.Default:true.
  • showProxy<boolean> Iftrue,Proxy inspection includesthetarget andhandler objects.Default:false.
  • maxArrayLength<integer> Specifies the maximum number ofArray,<TypedArray>,<Map>,<WeakMap>, and<WeakSet> elements to include when formatting.Set tonull orInfinity to show all elements. Set to0 ornegative to show no elements.Default:100.
  • maxStringLength<integer> Specifies the maximum number of characters toinclude when formatting. Set tonull orInfinity to show all elements.Set to0 or negative to show no characters.Default:10000.
  • breakLength<integer> The length at which input values are split acrossmultiple lines. Set toInfinity to format the input as a single line(in combination withcompact set totrue or any number >=1).Default:80.
  • compact<boolean> |<integer> Setting this tofalse causes each object keyto be displayed on a new line. It will break on new lines in text that islonger thanbreakLength. If set to a number, the mostn inner elementsare united on a single line as long as all properties fit intobreakLength. Short array elements are also grouped together. For moreinformation, see the example below.Default:3.
  • sorted<boolean> |<Function> If set totrue or a function, all propertiesof an object, andSet andMap entries are sorted in the resultingstring. If set totrue thedefault sort is used. If set to a function,it is used as acompare function.
  • getters<boolean> |<string> If set totrue, getters are inspected. If setto'get', only getters without a corresponding setter are inspected. Ifset 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 toseparate every three digits in all bigints and numbers.Default:false.
• Returns:<string> The representation ofobject.

Theutil.inspect() method returns a string representation ofobject that isintended for debugging. The output ofutil.inspect may change at any timeand should not be depended upon programmatically. Additionaloptions may bepassed that alter the result.util.inspect() will use the constructor's name and/orSymbol.toStringTagproperty to make an identifiable tag for an inspected value.

classFoo {  get [Symbol.toStringTag]() {return'bar';  }}classBar {}const baz =Object.create(null, { [Symbol.toStringTag]: {value:'foo' } });util.inspect(newFoo());// 'Foo [bar] {}'util.inspect(newBar());// 'Bar {}'util.inspect(baz);// '[foo] {}'copy

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

import { inspect }from'node:util';const obj = {};obj.a = [obj];obj.b = {};obj.b.inner = obj.b;obj.b.obj = obj;console.log(inspect(obj));// <ref *1> {//   a: [ [Circular *1] ],//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }// }const { inspect } =require('node:util');const obj = {};obj.a = [obj];obj.b = {};obj.b.inner = obj.b;obj.b.obj = obj;console.log(inspect(obj));// <ref *1> {//   a: [ [Circular *1] ],//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }// }copy

The following example inspects all properties of theutil object:

import utilfrom'node:util';console.log(util.inspect(util, {showHidden:true,depth:null }));const util =require('node:util');console.log(util.inspect(util, {showHidden:true,depth:null }));copy

The following example highlights the effect of thecompact option:

import { inspect }from'node:util';const o = {a: [1,2, [['Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.','test','foo']],4],b:newMap([['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:newMap([['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.copy

TheshowHidden option allows<WeakMap> and<WeakSet> entries to beinspected. If there are more entries thanmaxArrayLength, there is noguarantee which entries are displayed. That means retrieving the same<WeakSet> entries twice may result in different output. Furthermore, entrieswith no remaining strong references may be garbage collected at any time.

import { inspect }from'node:util';const obj = {a:1 };const obj2 = {b:2 };const weakSet =newWeakSet([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 =newWeakSet([obj, obj2]);console.log(inspect(weakSet, {showHidden:true }));// WeakSet { { a: 1 }, { b: 2 } }copy

Thesorted option ensures that an object's property insertion order does notimpact the result ofutil.inspect().

import { inspect }from'node:util';import assertfrom'node:assert';const o1 = {b: [2,3,1],a:'`a` comes before `b`',c:newSet([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:newSet([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:newSet([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:newSet([2,1,3]),a:'`a` comes before `b`',b: [2,3,1],};assert.strict.equal(inspect(o1, {sorted:true }),inspect(o2, {sorted:true }),);copy

ThenumericSeparator option adds an underscore every three digits to allnumbers.

import { inspect }from'node:util';const thousand =1000;const million =1000000;const bigNumber =123456789n;const bigDecimal =1234.12345;console.log(inspect(thousand, {numericSeparator:true }));// 1_000console.log(inspect(million, {numericSeparator:true }));// 1_000_000console.log(inspect(bigNumber, {numericSeparator:true }));// 123_456_789nconsole.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_000console.log(inspect(million, {numericSeparator:true }));// 1_000_000console.log(inspect(bigNumber, {numericSeparator:true }));// 123_456_789nconsole.log(inspect(bigDecimal, {numericSeparator:true }));// 1_234.123_45copy

util.inspect() is a synchronous method intended for debugging. Its maximumoutput length is approximately 128 MiB. Inputs that result in longer output willbe truncated.

import { inspect }from'node:util';classBox {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 =newBox(true);console.log(inspect(box));// "Box< true >"const { inspect } =require('node:util');classBox {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 =newBox(true);console.log(inspect(box));// "Box< true >"copy

import { inspect }from'node:util';const obj = {foo:'this will not show up in the inspect() output' };obj[inspect.custom] =(depth) => {return {bar:'baz' };};console.log(inspect(obj));// "{ bar: 'baz' }"const { inspect } =require('node:util');const obj = {foo:'this will not show up in the inspect() output' };obj[inspect.custom] =(depth) => {return {bar:'baz' };};console.log(inspect(obj));// "{ bar: 'baz' }"copy

const customInspectSymbol =Symbol.for('nodejs.util.inspect.custom');classPassword {constructor(value) {this.value = value;  }toString() {return'xxxxxxxx';  }  [customInspectSymbol](depth, inspectOptions, inspect) {return`Password <${this.toString()}>`;  }}const password =newPassword('r0sebud');console.log(password);// Prints Password <xxxxxxxx>copy

import { inspect }from'node:util';const arr =Array(156).fill(0);console.log(arr);// Logs the truncated arrayinspect.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 arrayinspect.defaultOptions.maxArrayLength =null;console.log(arr);// logs the full arraycopy

util.isDeepStrictEqual(val1, val2[, options])#

• val1<any>
• val2<any>
• skipPrototype<boolean> Iftrue, prototype and constructorcomparison is skipped during deep strict equality check.Default:false.
• Returns:<boolean>

Returnstrue if there is deep strict equality betweenval1 andval2.Otherwise, returnsfalse.

By default, deep strict equality includes comparison of object prototypes andconstructors. WhenskipPrototype istrue, objects withdifferent prototypes or constructors can still be considered equal if theirenumerable properties are deeply strictly equal.

const util =require('node:util');classFoo {constructor(a) {this.a = a;  }}classBar {constructor(a) {this.a = a;  }}const foo =newFoo(1);const bar =newBar(1);// Different constructors, same propertiesconsole.log(util.isDeepStrictEqual(foo, bar));// falseconsole.log(util.isDeepStrictEqual(foo, bar,true));// truecopy

Seeassert.deepStrictEqual() for more information about deep strictequality.

Class:util.MIMEType#

An implementation ofthe MIMEType class.

In accordance with browser conventions, all properties ofMIMEType objectsare implemented as getters and setters on the class prototype, rather than asdata properties on the object itself.

A MIME string is a structured string containing multiple meaningfulcomponents. When parsed, aMIMEType object is returned containingproperties for each of these components.

import {MIMEType }from'node:util';const myMIME =newMIMEType('text/plain');const {MIMEType } =require('node:util');const myMIME =newMIMEType('text/plain');copy

import {MIMEType }from'node:util';const myMIME =newMIMEType({toString:() =>'text/plain' });console.log(String(myMIME));// Prints: text/plainconst {MIMEType } =require('node:util');const myMIME =newMIMEType({toString:() =>'text/plain' });console.log(String(myMIME));// Prints: text/plaincopy

import {MIMEType }from'node:util';const myMIME =newMIMEType('text/javascript');console.log(myMIME.type);// Prints: textmyMIME.type ='application';console.log(myMIME.type);// Prints: applicationconsole.log(String(myMIME));// Prints: application/javascriptconst {MIMEType } =require('node:util');const myMIME =newMIMEType('text/javascript');console.log(myMIME.type);// Prints: textmyMIME.type ='application';console.log(myMIME.type);// Prints: applicationconsole.log(String(myMIME));// Prints: application/javascriptcopy

import {MIMEType }from'node:util';const myMIME =newMIMEType('text/ecmascript');console.log(myMIME.subtype);// Prints: ecmascriptmyMIME.subtype ='javascript';console.log(myMIME.subtype);// Prints: javascriptconsole.log(String(myMIME));// Prints: text/javascriptconst {MIMEType } =require('node:util');const myMIME =newMIMEType('text/ecmascript');console.log(myMIME.subtype);// Prints: ecmascriptmyMIME.subtype ='javascript';console.log(myMIME.subtype);// Prints: javascriptconsole.log(String(myMIME));// Prints: text/javascriptcopy

import {MIMEType }from'node:util';const myMIME =newMIMEType('text/javascript;key=value');console.log(myMIME.essence);// Prints: text/javascriptmyMIME.type ='application';console.log(myMIME.essence);// Prints: application/javascriptconsole.log(String(myMIME));// Prints: application/javascript;key=valueconst {MIMEType } =require('node:util');const myMIME =newMIMEType('text/javascript;key=value');console.log(myMIME.essence);// Prints: text/javascriptmyMIME.type ='application';console.log(myMIME.essence);// Prints: application/javascriptconsole.log(String(myMIME));// Prints: application/javascript;key=valuecopy

import {MIMEType }from'node:util';const myMIMES = [newMIMEType('image/png'),newMIMEType('image/gif'),];console.log(JSON.stringify(myMIMES));// Prints: ["image/png", "image/gif"]const {MIMEType } =require('node:util');const myMIMES = [newMIMEType('image/png'),newMIMEType('image/gif'),];console.log(JSON.stringify(myMIMES));// Prints: ["image/png", "image/gif"]copy

Class:util.MIMEParams#

TheMIMEParams API provides read and write access to the parameters of aMIMEType.

import {MIMEParams }from'node:util';const myParams =newMIMEParams();const {MIMEParams } =require('node:util');const myParams =newMIMEParams();copy

import {MIMEType }from'node:util';const { params } =newMIMEType('text/plain;foo=0;bar=1');for (const nameof params.keys()) {console.log(name);}// Prints://   foo//   barconst {MIMEType } =require('node:util');const { params } =newMIMEType('text/plain;foo=0;bar=1');for (const nameof params.keys()) {console.log(name);}// Prints://   foo//   barcopy

import {MIMEType }from'node:util';const { params } =newMIMEType('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 } =newMIMEType('text/plain;foo=0;bar=1');params.set('foo','def');params.set('baz','xyz');console.log(params.toString());// Prints: foo=def;bar=1;baz=xyzcopy

import {MIMEType }from'node:util';const { params } =newMIMEType('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 } =newMIMEType('text/plain;foo=bar;xyz=baz');for (const [name, value]of params) {console.log(name, value);}// Prints://   foo bar//   xyz bazcopy

util.parseArgs([config])#

• config<Object> Used to provide arguments for parsing and to configurethe parser.config supports the following properties:

  • args<string[]> array of argument strings.Default:process.argvwithexecPath andfilename removed.
  • options<Object> Used to describe arguments known to the parser.Keys ofoptions are the long names of options and values are an<Object> accepting the following properties:
    • type<string> Type of argument, which must be eitherboolean orstring.
    • multiple<boolean> Whether this option can be provided multipletimes. Iftrue, all values will be collected in an array. Iffalse, 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 tothe option if it does not appear in the arguments to be parsed. The valuemust match the type specified by thetype property. Ifmultiple istrue, it must be an array. No default value is applied when the optiondoes appear in the arguments to be parsed, even if the provided valueis falsy.
  • strict<boolean> Should an error be thrown when unknown argumentsare encountered, or when arguments are passed that do not match thetype configured inoptions.Default:true.
  • allowPositionals<boolean> Whether this command accepts positionalarguments.Default:false ifstrict istrue, otherwisetrue.
  • allowNegative<boolean> Iftrue, allows explicitly setting booleanoptions tofalse by prefixing the option name with--no-.Default:false.
  • tokens<boolean> Return the parsed tokens. This is useful for extendingthe built-in behavior, from adding additional checks through to reprocessingthe 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> SeeparseArgs tokenssection. Only returned ifconfig includestokens: true.

Provides a higher level API for command-line argument parsing than interactingwithprocess.argv directly. Takes a specification for the expected argumentsand returns a structured object with the parsed options and positionals.

import { parseArgs }from'node:util';const args = ['-f','--bar','b'];const options = {foo: {type:'boolean',short:'f',  },bar: {type:'string',  },};const {  values,  positionals,} =parseArgs({ args, options });console.log(values, positionals);// Prints: [Object: null prototype] { foo: true, bar: 'b' } []const { parseArgs } =require('node:util');const args = ['-f','--bar','b'];const options = {foo: {type:'boolean',short:'f',  },bar: {type:'string',  },};const {  values,  positionals,} =parseArgs({ args, options });console.log(values, positionals);// Prints: [Object: null prototype] { foo: true, bar: 'b' } []copy

import { parseArgs }from'node:util';const options = {'color': {type:'boolean' },'no-color': {type:'boolean' },'logfile': {type:'string' },'no-logfile': {type:'boolean' },};const { values, tokens } =parseArgs({ options,tokens:true });// Reprocess the option tokens and overwrite the returned values.tokens  .filter((token) => token.kind ==='option')  .forEach((token) => {if (token.name.startsWith('no-')) {// Store foo:false for --no-fooconst 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-fooconst 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 });copy

$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 }copy

util.parseEnv(content)#

• 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' }import { parseEnv }from'node:util';parseEnv('HELLO=world\nHELLO=oh my\n');// Returns: { HELLO: 'oh my' }copy

util.promisify(original)#

• original<Function>
• Returns:<Function>

Takes a function following the common error-first callback style, i.e. takingan(err, value) => ... callback as the last argument, and returns a versionthat returns promises.

import { promisify }from'node:util';import { stat }from'node:fs';const promisifiedStat =promisify(stat);promisifiedStat('.').then((stats) => {// Do something with `stats`}).catch((error) => {// Handle the error.});const { promisify } =require('node:util');const { stat } =require('node:fs');const promisifiedStat =promisify(stat);promisifiedStat('.').then((stats) => {// Do something with `stats`}).catch((error) => {// Handle the error.});copy

Or, equivalently usingasync functions:

import { promisify }from'node:util';import { stat }from'node:fs';const promisifiedStat =promisify(stat);asyncfunctioncallStat() {const stats =awaitpromisifiedStat('.');console.log(`This directory is owned by${stats.uid}`);}callStat();const { promisify } =require('node:util');const { stat } =require('node:fs');const promisifiedStat =promisify(stat);asyncfunctioncallStat() {const stats =awaitpromisifiedStat('.');console.log(`This directory is owned by${stats.uid}`);}callStat();copy

If there is anoriginal[util.promisify.custom] property present,promisifywill return its value, seeCustom promisified functions.

promisify() assumes thatoriginal is a function taking a callback as itsfinal argument in all cases. Iforiginal is not a function,promisify()will throw an error. Iforiginal is a function but its last argument is notan error-first callback, it will still be passed an error-firstcallback as its last argument.

Usingpromisify() on class methods or other methods that usethis may notwork as expected unless handled specially:

import { promisify }from'node:util';classFoo {constructor() {this.a =42;  }bar(callback) {callback(null,this.a);  }}const foo =newFoo();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');classFoo {constructor() {this.a =42;  }bar(callback) {callback(null,this.a);  }}const foo =newFoo();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'copy

import { promisify }from'node:util';functiondoSomething(foo, callback) {// ...}doSomething[promisify.custom] =(foo) => {returngetPromiseSomehow();};const promisified =promisify(doSomething);console.log(promisified === doSomething[promisify.custom]);// prints 'true'const { promisify } =require('node:util');functiondoSomething(foo, callback) {// ...}doSomething[promisify.custom] =(foo) => {returngetPromiseSomehow();};const promisified =promisify(doSomething);console.log(promisified === doSomething[promisify.custom]);// prints 'true'copy

doSomething[util.promisify.custom] =(foo) => {returnnewPromise((resolve, reject) => {doSomething(foo, resolve, reject);  });};copy

const kCustomPromisifiedSymbol =Symbol.for('nodejs.util.promisify.custom');doSomething[kCustomPromisifiedSymbol] =(foo) => {returnnewPromise((resolve, reject) => {doSomething(foo, resolve, reject);  });};copy

util.stripVTControlCharacters(str)#

• str<string>
• Returns:<string>

Returnsstr with any ANSI escape codes removed.

console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));// Prints "value"copy

util.styleText(format, text[, options])#

• format<string> |<Array> A text format or an Arrayof text formats defined inutil.inspect.colors.
• text<string> The text to to be formatted.
• options<Object>
  • validateStream<boolean> When true,stream is 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 theformat passedfor printing in a terminal. It is aware of the terminal's capabilitiesand acts according to the configuration set viaNO_COLOR,NODE_DISABLE_COLORS andFORCE_COLOR environment variables.

import { styleText }from'node:util';import { stderr }from'node:process';const successMessage =styleText('green','Success!');console.log(successMessage);const errorMessage =styleText('red','Error! Error!',// Validate if process.stderr has TTY  {stream: stderr },);console.error(errorMessage);const { styleText } =require('node:util');const { stderr } =require('node:process');const successMessage =styleText('green','Success!');console.log(successMessage);const errorMessage =styleText('red','Error! Error!',// Validate if process.stderr has TTY  {stream: stderr },);console.error(errorMessage);copy

util.inspect.colors also provides text formats such asitalic, andunderline and you can combine both:

console.log(  util.styleText(['underline','italic'],'My italic underlined message'),);copy

When passing an array of formats, the order of the format appliedis left to right so the following style might overwrite the previous one.

console.log(  util.styleText(['red','green'],'text'),// green);copy

The special format valuenone applies no additional styling to the text.

The full list of formats can be found inmodifiers.

Class:util.TextDecoder#

An implementation of theWHATWG Encoding StandardTextDecoder API.

const decoder =newTextDecoder();const u8arr =newUint8Array([72,101,108,108,111]);console.log(decoder.decode(u8arr));// Hellocopy

Class:util.TextEncoder#

An implementation of theWHATWG Encoding StandardTextEncoder API. Allinstances ofTextEncoder only support UTF-8 encoding.

const encoder =newTextEncoder();const uint8array = encoder.encode('this is some data');copy

TheTextEncoder class is also available on the global object.

const encoder =newTextEncoder();const src ='this is some data';const dest =newUint8Array(10);const { read, written } = encoder.encodeInto(src, dest);copy

util.toUSVString(string)#

• string<string>

Returns thestring after replacing any surrogate code points(or equivalently, any unpaired surrogate code units) with theUnicode "replacement character" U+FFFD.

util.transferableAbortController()#

Creates and returns an<AbortController> instance whose<AbortSignal> is markedas transferable and can be used withstructuredClone() orpostMessage().

util.transferableAbortSignal(signal)#

• signal<AbortSignal>
• Returns:<AbortSignal>

Marks the given<AbortSignal> as transferable so that it can be used withstructuredClone() andpostMessage().

const signal =transferableAbortSignal(AbortSignal.timeout(100));const channel =newMessageChannel();channel.port2.postMessage(signal, [signal]);copy

util.aborted(signal, resource)#

• signal<AbortSignal>
• resource<Object> Any non-null object tied to the abortable operation and held weakly.Ifresource is garbage collected before thesignal 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 providedsignal and returns a promise that resolves when thesignal is aborted.Ifresource is provided, it weakly references the operation's associated object,so ifresource is garbage collected before thesignal 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.});import { aborted }from'node:util';// Obtain an object with an abortable signal, like a custom resource or operation.const dependent =obtainSomethingAbortable();// Pass `dependent` as the resource, indicating the promise should only resolve// if `dependent` is still in memory when the signal is aborted.aborted(dependent.signal, dependent).then(() => {// This code runs when `dependent` is aborted.console.log('Dependent resource was aborted.');});// Simulate an event that triggers the abort.dependent.on('event',() => {  dependent.abort();// This will cause the `aborted` promise to resolve.});copy

util.types#

util.types provides type checks for different kinds of built-in objects.Unlikeinstanceof orObject.prototype.toString.call(value), these checks donot inspect properties of the object that are accessible from JavaScript (liketheir prototype), and usually have the overhead of calling into C++.

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

The API is accessible viarequire('node:util').types orrequire('node:util/types').

util.types.isAnyArrayBuffer(newArrayBuffer());// Returns trueutil.types.isAnyArrayBuffer(newSharedArrayBuffer());// Returns truecopy

util.types.isArrayBufferView(newInt8Array());// trueutil.types.isArrayBufferView(Buffer.from('hello world'));// trueutil.types.isArrayBufferView(newDataView(newArrayBuffer(16)));// trueutil.types.isArrayBufferView(newArrayBuffer());// falsecopy

functionfoo() {  util.types.isArgumentsObject(arguments);// Returns true}copy

util.types.isArrayBuffer(newArrayBuffer());// Returns trueutil.types.isArrayBuffer(newSharedArrayBuffer());// Returns falsecopy

util.types.isAsyncFunction(functionfoo() {});// Returns falseutil.types.isAsyncFunction(asyncfunctionfoo() {});// Returns truecopy

util.types.isBigInt64Array(newBigInt64Array());// Returns trueutil.types.isBigInt64Array(newBigUint64Array());// Returns falsecopy

util.types.isBigIntObject(Object(BigInt(123)));// Returns trueutil.types.isBigIntObject(BigInt(123));// Returns falseutil.types.isBigIntObject(123);// Returns falsecopy

util.types.isBigUint64Array(newBigInt64Array());// Returns falseutil.types.isBigUint64Array(newBigUint64Array());// Returns truecopy

util.types.isBooleanObject(false);// Returns falseutil.types.isBooleanObject(true);// Returns falseutil.types.isBooleanObject(newBoolean(false));// Returns trueutil.types.isBooleanObject(newBoolean(true));// Returns trueutil.types.isBooleanObject(Boolean(false));// Returns falseutil.types.isBooleanObject(Boolean(true));// Returns falsecopy

util.types.isBoxedPrimitive(false);// Returns falseutil.types.isBoxedPrimitive(newBoolean(false));// Returns trueutil.types.isBoxedPrimitive(Symbol('foo'));// Returns falseutil.types.isBoxedPrimitive(Object(Symbol('foo')));// Returns trueutil.types.isBoxedPrimitive(Object(BigInt(5)));// Returns truecopy

const ab =newArrayBuffer(20);util.types.isDataView(newDataView(ab));// Returns trueutil.types.isDataView(newFloat64Array());// Returns falsecopy

util.types.isDate(newDate());// Returns truecopy

#include<js_native_api.h>#include<stdlib.h>napi_value result;static napi_valueMyNapi(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");returnNULL;  }return result;}...DECLARE_NAPI_PROPERTY("myNapi", MyNapi)...copy

import nativefrom'napi_addon.node';import { types }from'node:util';const data = native.myNapi();types.isExternal(data);// returns truetypes.isExternal(0);// returns falsetypes.isExternal(newString('foo'));// returns falseconst native =require('napi_addon.node');const { types } =require('node:util');const data = native.myNapi();types.isExternal(data);// returns truetypes.isExternal(0);// returns falsetypes.isExternal(newString('foo'));// returns falsecopy

util.types.isFloat16Array(newArrayBuffer());// Returns falseutil.types.isFloat16Array(newFloat16Array());// Returns trueutil.types.isFloat16Array(newFloat32Array());// Returns falsecopy

util.types.isFloat32Array(newArrayBuffer());// Returns falseutil.types.isFloat32Array(newFloat32Array());// Returns trueutil.types.isFloat32Array(newFloat64Array());// Returns falsecopy

util.types.isFloat64Array(newArrayBuffer());// Returns falseutil.types.isFloat64Array(newUint8Array());// Returns falseutil.types.isFloat64Array(newFloat64Array());// Returns truecopy

util.types.isGeneratorFunction(functionfoo() {});// Returns falseutil.types.isGeneratorFunction(function*foo() {});// Returns truecopy

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

util.types.isInt8Array(newArrayBuffer());// Returns falseutil.types.isInt8Array(newInt8Array());// Returns trueutil.types.isInt8Array(newFloat64Array());// Returns falsecopy

util.types.isInt16Array(newArrayBuffer());// Returns falseutil.types.isInt16Array(newInt16Array());// Returns trueutil.types.isInt16Array(newFloat64Array());// Returns falsecopy

util.types.isInt32Array(newArrayBuffer());// Returns falseutil.types.isInt32Array(newInt32Array());// Returns trueutil.types.isInt32Array(newFloat64Array());// Returns falsecopy

util.types.isMap(newMap());// Returns truecopy

const map =newMap();util.types.isMapIterator(map.keys());// Returns trueutil.types.isMapIterator(map.values());// Returns trueutil.types.isMapIterator(map.entries());// Returns trueutil.types.isMapIterator(map[Symbol.iterator]());// Returns truecopy

import *as nsfrom'./a.js';util.types.isModuleNamespaceObject(ns);// Returns truecopy

console.log(util.types.isNativeError(newError()));// trueconsole.log(util.types.isNativeError(newTypeError()));// trueconsole.log(util.types.isNativeError(newRangeError()));// truecopy

classMyErrorextendsError {}console.log(util.types.isNativeError(newMyError()));// truecopy

import { createContext, runInContext }from'node:vm';import { types }from'node:util';const context =createContext({});const myError =runInContext('new Error()', context);console.log(types.isNativeError(myError));// trueconsole.log(myErrorinstanceofError);// 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));// trueconsole.log(myErrorinstanceofError);// falsecopy

const myError = {__proto__:Error.prototype };console.log(util.types.isNativeError(myError));// falseconsole.log(myErrorinstanceofError);// truecopy

util.types.isNumberObject(0);// Returns falseutil.types.isNumberObject(newNumber(0));// Returns truecopy

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

const target = {};const proxy =newProxy(target, {});util.types.isProxy(target);// Returns falseutil.types.isProxy(proxy);// Returns truecopy

util.types.isRegExp(/abc/);// Returns trueutil.types.isRegExp(newRegExp('abc'));// Returns truecopy

util.types.isSet(newSet());// Returns truecopy

const set =newSet();util.types.isSetIterator(set.keys());// Returns trueutil.types.isSetIterator(set.values());// Returns trueutil.types.isSetIterator(set.entries());// Returns trueutil.types.isSetIterator(set[Symbol.iterator]());// Returns truecopy

util.types.isSharedArrayBuffer(newArrayBuffer());// Returns falseutil.types.isSharedArrayBuffer(newSharedArrayBuffer());// Returns truecopy

util.types.isStringObject('foo');// Returns falseutil.types.isStringObject(newString('foo'));// Returns truecopy

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

util.types.isTypedArray(newArrayBuffer());// Returns falseutil.types.isTypedArray(newUint8Array());// Returns trueutil.types.isTypedArray(newFloat64Array());// Returns truecopy

util.types.isUint8Array(newArrayBuffer());// Returns falseutil.types.isUint8Array(newUint8Array());// Returns trueutil.types.isUint8Array(newFloat64Array());// Returns falsecopy

util.types.isUint8ClampedArray(newArrayBuffer());// Returns falseutil.types.isUint8ClampedArray(newUint8ClampedArray());// Returns trueutil.types.isUint8ClampedArray(newFloat64Array());// Returns falsecopy

util.types.isUint16Array(newArrayBuffer());// Returns falseutil.types.isUint16Array(newUint16Array());// Returns trueutil.types.isUint16Array(newFloat64Array());// Returns falsecopy

util.types.isUint32Array(newArrayBuffer());// Returns falseutil.types.isUint32Array(newUint32Array());// Returns trueutil.types.isUint32Array(newFloat64Array());// Returns falsecopy

util.types.isWeakMap(newWeakMap());// Returns truecopy

util.types.isWeakSet(newWeakSet());// Returns truecopy

Deprecated APIs#

The following APIs are deprecated and should no longer be used. Existingapplications and modules should be updated to find alternative approaches.

const util =require('node:util');util.isArray([]);// Returns: trueutil.isArray(newArray());// Returns: trueutil.isArray({});// Returns: falsecopy