powerbi-client package
Classes
| AdvancedFilter | |
| BasicFilter | |
| BasicFilterWithKeys | |
| Filter | |
| HierarchyFilter | |
| HierarchyIdentityFilter | |
| IdentityFilter | |
| IncludeExcludeFilter | |
| NotSupportedFilter | |
| PageSelector | |
| RelativeDateFilter | |
| RelativeTimeFilter | |
| Selector | |
| SlicerTargetSelector | |
| TopNFilter | |
| TupleFilter | |
| VisualSelector | |
| VisualTypeSelector | |
| AdvancedFilterBuilder |
Power BI Advanced filter builder component |
| BasicFilterBuilder |
Power BI Basic filter builder component |
| BookmarksManager |
Manages report bookmarks. |
| Create |
A Power BI Report creator component |
| Dashboard |
A Power BI Dashboard embed component |
| FilterBuilder |
Generic filter builder for BasicFilter, AdvancedFilter, RelativeDate, RelativeTime and TopN |
| MIMEParams |
The |
| MIMEType |
An implementation of the MIMEType class. In accordance with browser conventions, all properties of A MIME string is a structured string containing multiple meaningful
components. When parsed, a |
| Page |
A Power BI report page |
| Qna |
The Power BI Q&A embed component |
| QuickCreate |
A Power BI Quick Create component |
| RelativeDateFilterBuilder |
Power BI Relative Date filter builder component |
| RelativeTimeFilterBuilder |
Power BI Relative Time filter builder component |
| Report |
The Power BI Report embed component |
| Service |
The Power BI Service embed component, which is the entry point to embed all other Power BI components into your application |
| Tile |
The Power BI tile embed component |
| TopNFilterBuilder |
Power BI Top N filter builder component |
| Visual |
The Power BI Visual embed component |
| VisualDescriptor |
A Power BI visual within a page |
Interfaces
Type Aliases
Enums
Functions
| is |
Returns See also |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns For example: |
| is |
Returns |
| is |
Returns See also |
| is |
Returns |
| is |
Returns A native For further information on |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns Subclasses of the native error types are also native errors: A value being Conversely, |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns See also |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| is |
Returns |
| inspect(any, boolean, number | null, boolean) | The Circular references point to their anchor by using a reference index: The following example inspects all properties of the The following example highlights the effect of the The The The
|
| promisify<TCustom>(Custom |
Takes a function following the common error-first callback style, i.e. taking
an Or, equivalently using If there is an
Using |
| aborted(Abort |
Listens to abort event on the provided |
| add |
Adds a parameter to the given url |
| assign(any[]) | Copies the values of all enumerable properties from one or more source objects to a target object, and returns the target object. |
| auto |
Checks if the embed url contains autoAuth=true. |
| callbackify(() => Promise<void>) | Takes an Will print: The callback is executed asynchronously, and will have a limited stack trace.
If the callback throws, the process will emit an Since |
| callbackify<TResult>(() => Promise<TResult>) | |
| callbackify<T1>((arg1: T1) => Promise<void>) | |
| callbackify<T1, TResult>((arg1: T1) => Promise<TResult>) | |
| callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>) | |
| callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>) | |
| callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>) | |
| callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>) | |
| callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>) | |
| callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>) | |
| callbackify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>) | |
| callbackify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>) | |
| callbackify<T1, T2, T3, T4, T5, T6>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>) | |
| callbackify<T1, T2, T3, T4, T5, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>) | |
| convert |
The If This is particularly useful when working with processes to determine the exit code based on the signal that terminated the process. |
| create |
Generates a random 5 to 6 character string. |
| debuglog(string, (fn: Debug |
The If this program is run with where The if it is run with Multiple comma-separated The optional |
| deprecate<T>(T, string, string, Deprecate |
The When called, If the same optional If either the If the If the The |
| diff(string | (readonly string[]), string | (readonly string[])) |
If the values are equal, an empty array is returned. |
| find<T>((x: T) => boolean, T[]) | Finds the first value in an array that matches the specified predicate. |
| find |
Finds the index of the first value in an array that matches the specified predicate. |
| format(any, any[]) | The If a specifier does not have a corresponding argument, it is not replaced: Values that are not part of the format string are formatted using If there are more arguments passed to the If the first argument does not contain a valid format specifier, If only one argument is passed to
|
| format |
This function is identical to format, except in that it takes
an |
| generateUUID() | Generates a 20 character uuid. |
| get |
Returns an array of call site objects containing the stack of the caller function. Unlike accessing an It is possible to reconstruct the original locations by setting the option |
| get |
|
| get |
Returns random number |
| get |
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 |
| get |
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. |
| get |
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 |
| get |
Returns the time interval between two dates in milliseconds |
| inherits(unknown, unknown) | Usage of Inherit the prototype methods from one
constructor into another. The
prototype of This mainly adds some input validation on top of
ES6 example using |
| inspect(any, Inspect |
|
| is |
Alias for Returns |
| is |
Checks if the embed type is for create |
| is |
Returns See |
| is |
Checks if the embed url is for RDL report. |
| is |
Checks if the report is saved. |
| parse |
Provides a higher level API for command-line argument parsing than interacting
with |
| parse |
Stability: 1.1 - Active development
Given an example |
| promisify<TResult>((callback: (err: any, result: TResult) => void) => void) | |
| promisify((callback: (err?: any) => void) => void) | |
| promisify<T1, TResult>((arg1: T1, callback: (err: any, result: TResult) => void) => void) | |
| promisify<T1>((arg1: T1, callback: (err?: any) => void) => void) | |
| promisify<T1, T2, TResult>((arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void) | |
| promisify<T1, T2>((arg1: T1, arg2: T2, callback: (err?: any) => void) => void) | |
| promisify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void) | |
| promisify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void) | |
| promisify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void) | |
| promisify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void) | |
| promisify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void) | |
| promisify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void) | |
| promisify(Function) | |
| raise |
Raises a custom event with event data on the specified HTML element. |
| remove<T>((x: T) => boolean, T[]) | |
| set |
Enable or disable printing a stack trace on |
| strip |
Returns |
| style |
This function returns a formatted text considering the
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. The special format value In addition to predefined color names, The full list of formats can be found in modifiers. |
| to |
Returns the |
| transferable |
Creates and returns an |
| transferable |
Marks the given |
Variables
| APINot |
|
| Embed |
|
| Text |
|
| Text |
|
| Document | |
| HTMLIFrame |
|
| Window | |
| config | |
| invalid |
|
| hpm |
|
| router |
|
| wpmp |
Function Details
isAnyArrayBuffer(unknown)
Returns true if the value is a built-in ArrayBuffer or
SharedArrayBuffer instance.
See also util.types.isArrayBuffer() and util.types.isSharedArrayBuffer().
util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
function isAnyArrayBuffer(object: unknown): object is ArrayBufferLikeParameters
- object
-
unknown
Returns
object is ArrayBufferLike
isArgumentsObject(unknown)
Returns true if the value is an arguments object.
function foo() {
util.types.isArgumentsObject(arguments); // Returns true
}
function isArgumentsObject(object: unknown): object is IArgumentsParameters
- object
-
unknown
Returns
object is IArguments
isArrayBuffer(unknown)
Returns true if the value is a built-in ArrayBuffer instance.
This does not include SharedArrayBuffer instances. Usually, it is
desirable to test for both; See util.types.isAnyArrayBuffer() for that.
util.types.isArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer()); // Returns false
function isArrayBuffer(object: unknown): object is ArrayBufferParameters
- object
-
unknown
Returns
object is ArrayBuffer
isArrayBufferView(unknown)
Returns true if the value is an instance of one of the ArrayBuffer views, such as typed
array objects or DataView. Equivalent to
ArrayBuffer.isView().
util.types.isArrayBufferView(new Int8Array()); // true
util.types.isArrayBufferView(Buffer.from('hello world')); // true
util.types.isArrayBufferView(new DataView(new ArrayBuffer(16))); // true
util.types.isArrayBufferView(new ArrayBuffer()); // false
function isArrayBufferView(object: unknown): object is ArrayBufferViewParameters
- object
-
unknown
Returns
object is ArrayBufferView
isAsyncFunction(unknown)
Returns true if the value is an async function.
This only reports back what the JavaScript engine is seeing;
in particular, the return value may not match the original source code if
a transpilation tool was used.
util.types.isAsyncFunction(function foo() {}); // Returns false
util.types.isAsyncFunction(async function foo() {}); // Returns true
function isAsyncFunction(object: unknown): booleanParameters
- object
-
unknown
Returns
boolean
isBigInt64Array(unknown)
Returns true if the value is a BigInt64Array instance.
util.types.isBigInt64Array(new BigInt64Array()); // Returns true
util.types.isBigInt64Array(new BigUint64Array()); // Returns false
function isBigInt64Array(value: unknown): value is BigInt64ArrayParameters
- value
-
unknown
Returns
value is BigInt64Array
isBigIntObject(unknown)
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 false
function isBigIntObject(object: unknown): object is BigIntParameters
- object
-
unknown
Returns
object is BigInt
isBigUint64Array(unknown)
Returns true if the value is a BigUint64Array instance.
util.types.isBigUint64Array(new BigInt64Array()); // Returns false
util.types.isBigUint64Array(new BigUint64Array()); // Returns true
function isBigUint64Array(value: unknown): value is BigUint64ArrayParameters
- value
-
unknown
Returns
value is BigUint64Array
isBooleanObject(unknown)
Returns true if the value is a boolean object, e.g. created
by new Boolean().
util.types.isBooleanObject(false); // Returns false
util.types.isBooleanObject(true); // Returns false
util.types.isBooleanObject(new Boolean(false)); // Returns true
util.types.isBooleanObject(new Boolean(true)); // Returns true
util.types.isBooleanObject(Boolean(false)); // Returns false
util.types.isBooleanObject(Boolean(true)); // Returns false
function isBooleanObject(object: unknown): object is BooleanParameters
- object
-
unknown
Returns
object is Boolean
isBoxedPrimitive(unknown)
Returns true if the value is any boxed primitive object, e.g. created
by new Boolean(), new String() or Object(Symbol()).
For example:
util.types.isBoxedPrimitive(false); // Returns false
util.types.isBoxedPrimitive(new Boolean(false)); // Returns true
util.types.isBoxedPrimitive(Symbol('foo')); // Returns false
util.types.isBoxedPrimitive(Object(Symbol('foo'))); // Returns true
util.types.isBoxedPrimitive(Object(BigInt(5))); // Returns true
function isBoxedPrimitive(object: unknown): object is String | Number | Boolean | Symbol | BigIntParameters
- object
-
unknown
Returns
object is String | Number | Boolean | Symbol | BigInt
isCryptoKey(unknown)
Returns true if value is a CryptoKey, false otherwise.
function isCryptoKey(object: unknown): object is CryptoKeyParameters
- object
-
unknown
Returns
object is CryptoKey
isDataView(unknown)
Returns true if the value is a built-in DataView instance.
const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab)); // Returns true
util.types.isDataView(new Float64Array()); // Returns false
See also ArrayBuffer.isView().
function isDataView(object: unknown): object is DataViewParameters
- object
-
unknown
Returns
object is DataView
isDate(unknown)
Returns true if the value is a built-in Date instance.
util.types.isDate(new Date()); // Returns true
function isDate(object: unknown): object is DateParameters
- object
-
unknown
Returns
object is Date
isExternal(unknown)
Returns true if the value is a native External value.
A native External value is a special type of object that contains a
raw C++ pointer (void*) for access from native code, and has no other
properties. Such objects are created either by Node.js internals or native
addons. In JavaScript, they are
frozen objects with a
null prototype.
#include <js_native_api.h>
#include <stdlib.h>
napi_value result;
static napi_value MyNapi(napi_env env, napi_callback_info info) {
int* raw = (int*) malloc(1024);
napi_status status = napi_create_external(env, (void*) raw, NULL, NULL, &result);
if (status != napi_ok) {
napi_throw_error(env, NULL, "napi_create_external failed");
return NULL;
}
return result;
}
...
DECLARE_NAPI_PROPERTY("myNapi", MyNapi)
...
import native from 'napi_addon.node';
import { types } from 'node:util';
const data = native.myNapi();
types.isExternal(data); // returns true
types.isExternal(0); // returns false
types.isExternal(new String('foo')); // returns false
For further information on napi_create_external, refer to
napi_create_external().
function isExternal(object: unknown): booleanParameters
- object
-
unknown
Returns
boolean
isFloat16Array(unknown)
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 false
function isFloat16Array(object: unknown): object is Float16ArrayParameters
- object
-
unknown
Returns
object is Float16Array
isFloat32Array(unknown)
Returns true if the value is a built-in Float32Array instance.
util.types.isFloat32Array(new ArrayBuffer()); // Returns false
util.types.isFloat32Array(new Float32Array()); // Returns true
util.types.isFloat32Array(new Float64Array()); // Returns false
function isFloat32Array(object: unknown): object is Float32ArrayParameters
- object
-
unknown
Returns
object is Float32Array
isFloat64Array(unknown)
Returns true if the value is a built-in Float64Array instance.
util.types.isFloat64Array(new ArrayBuffer()); // Returns false
util.types.isFloat64Array(new Uint8Array()); // Returns false
util.types.isFloat64Array(new Float64Array()); // Returns true
function isFloat64Array(object: unknown): object is Float64ArrayParameters
- object
-
unknown
Returns
object is Float64Array
isGeneratorFunction(unknown)
Returns true if the value is a generator function.
This only reports back what the JavaScript engine is seeing;
in particular, the return value may not match the original source code if
a transpilation tool was used.
util.types.isGeneratorFunction(function foo() {}); // Returns false
util.types.isGeneratorFunction(function* foo() {}); // Returns true
function isGeneratorFunction(object: unknown): object is GeneratorFunctionParameters
- object
-
unknown
Returns
object is GeneratorFunction
isGeneratorObject(unknown)
Returns true if the value is a generator object as returned from a
built-in generator function.
This only reports back what the JavaScript engine is seeing;
in particular, the return value may not match the original source code if
a transpilation tool was used.
function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator); // Returns true
function isGeneratorObject(object: unknown): object is GeneratorParameters
- object
-
unknown
Returns
object is Generator
isInt16Array(unknown)
Returns true if the value is a built-in Int16Array instance.
util.types.isInt16Array(new ArrayBuffer()); // Returns false
util.types.isInt16Array(new Int16Array()); // Returns true
util.types.isInt16Array(new Float64Array()); // Returns false
function isInt16Array(object: unknown): object is Int16ArrayParameters
- object
-
unknown
Returns
object is Int16Array
isInt32Array(unknown)
Returns true if the value is a built-in Int32Array instance.
util.types.isInt32Array(new ArrayBuffer()); // Returns false
util.types.isInt32Array(new Int32Array()); // Returns true
util.types.isInt32Array(new Float64Array()); // Returns false
function isInt32Array(object: unknown): object is Int32ArrayParameters
- object
-
unknown
Returns
object is Int32Array
isInt8Array(unknown)
Returns true if the value is a built-in Int8Array instance.
util.types.isInt8Array(new ArrayBuffer()); // Returns false
util.types.isInt8Array(new Int8Array()); // Returns true
util.types.isInt8Array(new Float64Array()); // Returns false
function isInt8Array(object: unknown): object is Int8ArrayParameters
- object
-
unknown
Returns
object is Int8Array
isKeyObject(unknown)
Returns true if value is a KeyObject, false otherwise.
function isKeyObject(object: unknown): object is KeyObjectParameters
- object
-
unknown
Returns
object is KeyObject
isMap<T>({} | T)
Returns true if the value is a built-in Map instance.
util.types.isMap(new Map()); // Returns true
function isMap<T>(object: {} | T): object is (T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>)Parameters
- object
-
{} | T
Returns
object is (T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>)
isMapIterator(unknown)
Returns true if the value is an iterator returned for a built-in Map instance.
const map = new Map();
util.types.isMapIterator(map.keys()); // Returns true
util.types.isMapIterator(map.values()); // Returns true
util.types.isMapIterator(map.entries()); // Returns true
util.types.isMapIterator(map[Symbol.iterator]()); // Returns true
function isMapIterator(object: unknown): booleanParameters
- object
-
unknown
Returns
boolean
isModuleNamespaceObject(unknown)
Returns true if the value is an instance of a Module Namespace Object.
import * as ns from './a.js';
util.types.isModuleNamespaceObject(ns); // Returns true
function isModuleNamespaceObject(value: unknown): booleanParameters
- value
-
unknown
Returns
boolean
isNativeError(unknown)
Warning
This API is now deprecated.
The util.types.isNativeError API is deprecated. Please use Error.isError instead.
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())); // true
Subclasses of the native error types are also native errors:
class MyError extends Error {}
console.log(util.types.isNativeError(new MyError())); // true
A 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:
import { createContext, runInContext } from 'node:vm';
import { types } from 'node:util';
const context = createContext({});
const myError = runInContext('new Error()', context);
console.log(types.isNativeError(myError)); // true
console.log(myError instanceof Error); // false
Conversely, 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); // true
function isNativeError(object: unknown): object is ErrorParameters
- object
-
unknown
Returns
object is Error
isNumberObject(unknown)
Returns true if the value is a number object, e.g. created
by new Number().
util.types.isNumberObject(0); // Returns false
util.types.isNumberObject(new Number(0)); // Returns true
function isNumberObject(object: unknown): object is NumberParameters
- object
-
unknown
Returns
object is Number
isPromise(unknown)
Returns true if the value is a built-in Promise.
util.types.isPromise(Promise.resolve(42)); // Returns true
function isPromise(object: unknown): object is Promise<unknown>Parameters
- object
-
unknown
Returns
object is Promise<unknown>
isProxy(unknown)
Returns true if the value is a Proxy instance.
const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target); // Returns false
util.types.isProxy(proxy); // Returns true
function isProxy(object: unknown): booleanParameters
- object
-
unknown
Returns
boolean
isRegExp(unknown)
Returns true if the value is a regular expression object.
util.types.isRegExp(/abc/); // Returns true
util.types.isRegExp(new RegExp('abc')); // Returns true
function isRegExp(object: unknown): object is RegExpParameters
- object
-
unknown
Returns
object is RegExp
isSet<T>({} | T)
Returns true if the value is a built-in Set instance.
util.types.isSet(new Set()); // Returns true
function isSet<T>(object: {} | T): object is (T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>)Parameters
- object
-
{} | T
Returns
object is (T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>)
isSetIterator(unknown)
Returns true if the value is an iterator returned for a built-in Set instance.
const set = new Set();
util.types.isSetIterator(set.keys()); // Returns true
util.types.isSetIterator(set.values()); // Returns true
util.types.isSetIterator(set.entries()); // Returns true
util.types.isSetIterator(set[Symbol.iterator]()); // Returns true
function isSetIterator(object: unknown): booleanParameters
- object
-
unknown
Returns
boolean
isSharedArrayBuffer(unknown)
Returns true if the value is a built-in SharedArrayBuffer instance.
This does not include ArrayBuffer instances. Usually, it is
desirable to test for both; See util.types.isAnyArrayBuffer() for that.
util.types.isSharedArrayBuffer(new ArrayBuffer()); // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer()); // Returns true
function isSharedArrayBuffer(object: unknown): object is SharedArrayBufferParameters
- object
-
unknown
Returns
object is SharedArrayBuffer
isStringObject(unknown)
Returns true if the value is a string object, e.g. created
by new String().
util.types.isStringObject('foo'); // Returns false
util.types.isStringObject(new String('foo')); // Returns true
function isStringObject(object: unknown): object is StringParameters
- object
-
unknown
Returns
object is String
isSymbolObject(unknown)
Returns true if the value is a symbol object, created
by calling Object() on a Symbol primitive.
const symbol = Symbol('foo');
util.types.isSymbolObject(symbol); // Returns false
util.types.isSymbolObject(Object(symbol)); // Returns true
function isSymbolObject(object: unknown): object is SymbolParameters
- object
-
unknown
Returns
object is Symbol
isTypedArray(unknown)
Returns true if the value is a built-in TypedArray instance.
util.types.isTypedArray(new ArrayBuffer()); // Returns false
util.types.isTypedArray(new Uint8Array()); // Returns true
util.types.isTypedArray(new Float64Array()); // Returns true
See also ArrayBuffer.isView().
function isTypedArray(object: unknown): object is TypedArrayParameters
- object
-
unknown
Returns
object is TypedArray
isUint16Array(unknown)
Returns true if the value is a built-in Uint16Array instance.
util.types.isUint16Array(new ArrayBuffer()); // Returns false
util.types.isUint16Array(new Uint16Array()); // Returns true
util.types.isUint16Array(new Float64Array()); // Returns false
function isUint16Array(object: unknown): object is Uint16ArrayParameters
- object
-
unknown
Returns
object is Uint16Array
isUint32Array(unknown)
Returns true if the value is a built-in Uint32Array instance.
util.types.isUint32Array(new ArrayBuffer()); // Returns false
util.types.isUint32Array(new Uint32Array()); // Returns true
util.types.isUint32Array(new Float64Array()); // Returns false
function isUint32Array(object: unknown): object is Uint32ArrayParameters
- object
-
unknown
Returns
object is Uint32Array
isUint8Array(unknown)
Returns true if the value is a built-in Uint8Array instance.
util.types.isUint8Array(new ArrayBuffer()); // Returns false
util.types.isUint8Array(new Uint8Array()); // Returns true
util.types.isUint8Array(new Float64Array()); // Returns false
function isUint8Array(object: unknown): object is Uint8ArrayParameters
- object
-
unknown
Returns
object is Uint8Array
isUint8ClampedArray(unknown)
Returns true if the value is a built-in Uint8ClampedArray instance.
util.types.isUint8ClampedArray(new ArrayBuffer()); // Returns false
util.types.isUint8ClampedArray(new Uint8ClampedArray()); // Returns true
util.types.isUint8ClampedArray(new Float64Array()); // Returns false
function isUint8ClampedArray(object: unknown): object is Uint8ClampedArrayParameters
- object
-
unknown
Returns
object is Uint8ClampedArray
isWeakMap(unknown)
Returns true if the value is a built-in WeakMap instance.
util.types.isWeakMap(new WeakMap()); // Returns true
function isWeakMap(object: unknown): object is WeakMap<object, unknown>Parameters
- object
-
unknown
Returns
object is WeakMap<object, unknown>
isWeakSet(unknown)
Returns true if the value is a built-in WeakSet instance.
util.types.isWeakSet(new WeakSet()); // Returns true
function isWeakSet(object: unknown): object is WeakSet<object>Parameters
- object
-
unknown
Returns
object is WeakSet<object>
inspect(any, boolean, number | null, boolean)
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:
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] }
// }
The following example inspects all properties of the util object:
import util from 'node:util';
console.log(util.inspect(util, { showHidden: true, depth: null }));
The following example highlights the effect of the compact 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: 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.
import { inspect } from 'node:util';
const obj = { a: 1 };
const obj2 = { b: 2 };
const weakSet = new WeakSet([obj, obj2]);
console.log(inspect(weakSet, { showHidden: true }));
// WeakSet { { a: 1 }, { b: 2 } }
The sorted option ensures that an object's property insertion order does not
impact the result of util.inspect().
import { inspect } from 'node:util';
import assert from 'node:assert';
const o1 = {
b: [2, 3, 1],
a: '`a` comes before `b`',
c: new Set([2, 3, 1]),
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }
const o2 = {
c: new Set([2, 1, 3]),
a: '`a` comes before `b`',
b: [2, 3, 1],
};
assert.strict.equal(
inspect(o1, { sorted: true }),
inspect(o2, { sorted: true }),
);
The numericSeparator option adds an underscore every three digits to all
numbers.
import { inspect } from 'node:util';
const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;
console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45
util.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.
function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): stringParameters
- object
-
any
Any JavaScript primitive or Object.
- showHidden
-
boolean
- depth
-
number | null
- color
-
boolean
Returns
string
The representation of object.
promisify<TCustom>(CustomPromisify<TCustom>)
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.
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.
});
Or, equivalently using async functions:
import { promisify } from 'node:util';
import { stat } from 'node:fs';
const promisifiedStat = promisify(stat);
async function callStat() {
const stats = await promisifiedStat('.');
console.log(`This directory is owned by ${stats.uid}`);
}
callStat();
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:
import { promisify } from 'node:util';
class Foo {
constructor() {
this.a = 42;
}
bar(callback) {
callback(null, this.a);
}
}
const foo = new Foo();
const naiveBar = promisify(foo.bar);
// TypeError: Cannot read properties of undefined (reading 'a')
// naiveBar().then(a => console.log(a));
naiveBar.call(foo).then((a) => console.log(a)); // '42'
const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'
function promisify<TCustom>(fn: CustomPromisify<TCustom>): TCustomParameters
- fn
-
CustomPromisify<TCustom>
Returns
TCustom
aborted(AbortSignal, any)
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.
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.
});
function aborted(signal: AbortSignal, resource: any): Promise<void>Parameters
- signal
-
AbortSignal
- resource
-
any
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<void>
addParamToUrl(string, string, string)
Adds a parameter to the given url
function addParamToUrl(url: string, paramName: string, value: string): stringParameters
- url
-
string
- paramName
-
string
- value
-
string
Returns
string
assign(any[])
Copies the values of all enumerable properties from one or more source objects to a target object, and returns the target object.
function assign(args: any[]): anyParameters
- args
-
any[]
Returns
any
autoAuthInEmbedUrl(string)
Checks if the embed url contains autoAuth=true.
function autoAuthInEmbedUrl(embedUrl: string): booleanParameters
- embedUrl
-
string
Returns
boolean
callbackify(() => Promise<void>)
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.
import { callbackify } from 'node:util';
async function fn() {
return 'hello world';
}
const callbackFunction = callbackify(fn);
callbackFunction((err, ret) => {
if (err) throw err;
console.log(ret);
});
Will print:
hello world
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.
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.
import util from '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
});
function callbackify(fn: () => Promise<void>): (callback: (err: ErrnoException) => void) => voidParameters
- fn
-
() => Promise<void>
An async function
Returns
(callback: (err: ErrnoException) => void) => void
a callback style function
callbackify<TResult>(() => Promise<TResult>)
function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: ErrnoException, result: TResult) => void) => voidParameters
- fn
-
() => Promise<TResult>
Returns
(callback: (err: ErrnoException, result: TResult) => void) => void
callbackify<T1>((arg1: T1) => Promise<void>)
function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: ErrnoException) => void) => voidParameters
- fn
-
(arg1: T1) => Promise<void>
Returns
(arg1: T1, callback: (err: ErrnoException) => void) => void
callbackify<T1, TResult>((arg1: T1) => Promise<TResult>)
function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: ErrnoException, result: TResult) => void) => voidParameters
- fn
-
(arg1: T1) => Promise<TResult>
Returns
(arg1: T1, callback: (err: ErrnoException, result: TResult) => void) => void
callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>)
function callbackify<T1, T2>(fn: (arg1: T1, arg2: T2) => Promise<void>): (arg1: T1, arg2: T2, callback: (err: ErrnoException) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2) => Promise<void>
Returns
(arg1: T1, arg2: T2, callback: (err: ErrnoException) => void) => void
callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>)
function callbackify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2) => Promise<TResult>): (arg1: T1, arg2: T2, callback: (err: ErrnoException | null, result: TResult) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2) => Promise<TResult>
Returns
(arg1: T1, arg2: T2, callback: (err: ErrnoException | null, result: TResult) => void) => void
callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>)
function callbackify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: ErrnoException) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<void>
Returns
(arg1: T1, arg2: T2, arg3: T3, callback: (err: ErrnoException) => void) => void
callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>)
function callbackify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: ErrnoException | null, result: TResult) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
Returns
(arg1: T1, arg2: T2, arg3: T3, callback: (err: ErrnoException | null, result: TResult) => void) => void
callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>)
function callbackify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: ErrnoException) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: ErrnoException) => void) => void
callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>)
function callbackify<T1, T2, T3, T4, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: ErrnoException | null, result: TResult) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: ErrnoException | null, result: TResult) => void) => void
callbackify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>)
function callbackify<T1, T2, T3, T4, T5>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: ErrnoException) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: ErrnoException) => void) => void
callbackify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>)
function callbackify<T1, T2, T3, T4, T5, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: ErrnoException | null, result: TResult) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: ErrnoException | null, result: TResult) => void) => void
callbackify<T1, T2, T3, T4, T5, T6>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>)
function callbackify<T1, T2, T3, T4, T5, T6>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: ErrnoException) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: ErrnoException) => void) => void
callbackify<T1, T2, T3, T4, T5, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>)
function callbackify<T1, T2, T3, T4, T5, T6, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: ErrnoException | null, result: TResult) => void) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: ErrnoException | null, result: TResult) => void) => void
convertProcessSignalToExitCode(Signals)
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.
import { convertProcessSignalToExitCode } from '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.
function convertProcessSignalToExitCode(signal: Signals): numberParameters
- signal
-
Signals
A signal name (e.g. 'SIGTERM')
Returns
number
The exit code corresponding to signal
createRandomString()
Generates a random 5 to 6 character string.
function createRandomString(): stringReturns
string
debuglog(string, (fn: DebugLoggerFunction) => void)
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.
import { debuglog } from '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:
import { debuglog } from '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.
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;
});
function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLoggerParameters
- section
-
string
A string identifying the portion of the application for which the debuglog function is being created.
- callback
-
(fn: DebugLoggerFunction) => void
A callback invoked the first time the logging function is called with a function argument that is a more optimized logging function.
Returns
The logging function
deprecate<T>(T, string, string, DeprecateOptions)
The util.deprecate() method wraps fn (which may be a function or class) in
such a way that it is marked as deprecated.
import { deprecate } from 'node:util';
export const 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.
import { deprecate } from 'node:util';
const fn1 = deprecate(
() => 'a value',
'deprecation message',
'DEP0001',
);
const fn2 = deprecate(
() => 'a different value',
'other dep message',
'DEP0001',
);
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code
If 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.
function deprecate<T>(fn: T, msg: string, code?: string, options?: DeprecateOptions): TParameters
- fn
-
T
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
- DeprecateOptions
Returns
T
The deprecated function wrapped to emit a warning.
diff(string | (readonly string[]), string | (readonly string[]))
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'));
// []
function diff(actual: string | (readonly string[]), expected: string | (readonly string[])): DiffEntry[]Parameters
- actual
-
string | (readonly string[])
The first value to compare
- expected
-
string | (readonly string[])
The second value to compare
Returns
An array of difference entries. Each entry is an array with two elements:
- Index 0:
numberOperation code:-1for delete,0for no-op/unchanged,1for insert - Index 1:
stringThe value associated with the operation
find<T>((x: T) => boolean, T[])
Finds the first value in an array that matches the specified predicate.
function find<T>(predicate: (x: T) => boolean, xs: T[]): TParameters
- predicate
-
(x: T) => boolean
- xs
-
T[]
Returns
T
findIndex<T>((x: T) => boolean, T[])
Finds the index of the first value in an array that matches the specified predicate.
function findIndex<T>(predicate: (x: T) => boolean, xs: T[]): numberParameters
- predicate
-
(x: T) => boolean
- xs
-
T[]
Returns
number
format(any, any[])
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:
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.
function format(format?: any, param: any[]): stringParameters
- format
-
any
A printf-like format string.
- param
-
any[]
Returns
string
formatWithOptions(InspectOptions, any, any[])
This function is identical to format, except in that it takes
an inspectOptions argument which specifies options that are passed along to 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.
function formatWithOptions(inspectOptions: InspectOptions, format?: any, param: any[]): stringParameters
- inspectOptions
- InspectOptions
- format
-
any
- param
-
any[]
Returns
string
generateUUID()
Generates a 20 character uuid.
function generateUUID(): stringReturns
string
getCallSites(number, GetCallSitesOptions)
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.
import { getCallSites } from 'node:util';
function exampleFunction() {
const callSites = getCallSites();
console.log('Call Sites:');
callSites.forEach((callSite, index) => {
console.log(`CallSite ${index + 1}:`);
console.log(`Function Name: ${callSite.functionName}`);
console.log(`Script Name: ${callSite.scriptName}`);
console.log(`Line Number: ${callSite.lineNumber}`);
console.log(`Column Number: ${callSite.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, sourceMap will be true by default.
import { getCallSites } from 'node:util';
interface Foo {
foo: string;
}
const callSites = getCallSites({ sourceMap: true });
// With sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 7
// Column Number: 26
// Without sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 2
// Column Number: 26
function getCallSites(frameCount?: number, options?: GetCallSitesOptions): CallSiteObject[]Parameters
- frameCount
-
number
Number of frames to capture as call site objects.
Default: 10. Allowable range is between 1 and 200.
- options
- GetCallSitesOptions
Returns
An array of call site objects
getCallSites(GetCallSitesOptions)
function getCallSites(options: GetCallSitesOptions): CallSiteObject[]Parameters
- options
- GetCallSitesOptions
Returns
getRandomValue()
Returns random number
function getRandomValue(): numberReturns
number
getSystemErrorMap()
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
});
function getSystemErrorMap(): Map<number, [string, string]>Returns
Map<number, [string, string]>
getSystemErrorMessage(number)
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
});
function getSystemErrorMessage(err: number): stringParameters
- err
-
number
Returns
string
getSystemErrorName(number)
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
});
function getSystemErrorName(err: number): stringParameters
- err
-
number
Returns
string
getTimeDiffInMilliseconds(Date, Date)
Returns the time interval between two dates in milliseconds
function getTimeDiffInMilliseconds(start: Date, end: Date): numberParameters
- start
-
Date
- end
-
Date
Returns
number
inherits(unknown, unknown)
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:
import EventEmitter from 'node:events';
class MyStream extends EventEmitter {
write(data) {
this.emit('data', data);
}
}
const stream = new MyStream();
stream.on('data', (data) => {
console.log(`Received data: "${data}"`);
});
stream.write('With ES6');
function inherits(constructor: unknown, superConstructor: unknown)Parameters
- constructor
-
unknown
- superConstructor
-
unknown
inspect(any, InspectOptions)
function inspect(object: any, options?: InspectOptions): stringParameters
- object
-
any
- options
- InspectOptions
Returns
string
isArray(unknown)
Warning
This API is now deprecated.
Since v4.0.0 - Use isArray instead.
Alias for Array.isArray().
Returns true if the given object is an Array. Otherwise, returns false.
import util from 'node:util';
util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false
function isArray(object: unknown): object is unknown[]Parameters
- object
-
unknown
Returns
object is unknown[]
isCreate(string)
Checks if the embed type is for create
function isCreate(embedType: string): booleanParameters
- embedType
-
string
Returns
boolean
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)
Returns true if there is deep strict equality between val1 and val2.
Otherwise, returns false.
See assert.deepStrictEqual() for more information about deep strict
equality.
function isDeepStrictEqual(val1: unknown, val2: unknown, options?: IsDeepStrictEqualOptions): booleanParameters
- val1
-
unknown
- val2
-
unknown
- options
- IsDeepStrictEqualOptions
Returns
boolean
isRDLEmbed(string)
Checks if the embed url is for RDL report.
function isRDLEmbed(embedUrl: string): booleanParameters
- embedUrl
-
string
Returns
boolean
isSavedInternal(HttpPostMessage, string, Window)
Checks if the report is saved.
function isSavedInternal(hpm: HttpPostMessage, uid: string, contentWindow: Window): Promise<boolean>Parameters
- hpm
-
HttpPostMessage
- uid
-
string
- contentWindow
- Window
Returns
Promise<boolean>
parseArgs<T>(T)
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.
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' } []
function parseArgs<T>(config?: T): ParsedResults<T>Parameters
- config
-
T
Used to provide arguments for parsing and to configure the parser. config supports the following properties:
Returns
ParsedResults<T>
The parsed command line arguments:
parseEnv(string)
Stability: 1.1 - Active development
Given an example .env file:
import { parseEnv } from 'node:util';
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
function parseEnv(content: string): Dict<string>Parameters
- content
-
string
The raw contents of a .env file.
Returns
Dict<string>
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>Parameters
- fn
-
(callback: (err: any, result: TResult) => void) => void
Returns
() => Promise<TResult>
promisify((callback: (err?: any) => void) => void)
function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>Parameters
- fn
-
(callback: (err?: any) => void) => void
Returns
() => Promise<void>
promisify<T1, TResult>((arg1: T1, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>Parameters
- fn
-
(arg1: T1, callback: (err: any, result: TResult) => void) => void
Returns
(arg1: T1) => Promise<TResult>
promisify<T1>((arg1: T1, callback: (err?: any) => void) => void)
function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>Parameters
- fn
-
(arg1: T1, callback: (err?: any) => void) => void
Returns
(arg1: T1) => Promise<void>
promisify<T1, T2, TResult>((arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>Parameters
- fn
-
(arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void
Returns
(arg1: T1, arg2: T2) => Promise<TResult>
promisify<T1, T2>((arg1: T1, arg2: T2, callback: (err?: any) => void) => void)
function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>Parameters
- fn
-
(arg1: T1, arg2: T2, callback: (err?: any) => void) => void
Returns
(arg1: T1, arg2: T2) => Promise<void>
promisify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void
Returns
(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
promisify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void)
function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void
Returns
(arg1: T1, arg2: T2, arg3: T3) => Promise<void>
promisify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, T2, T3, T4, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>
promisify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void)
function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
promisify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, T2, T3, T4, T5, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>
promisify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void)
function promisify<T1, T2, T3, T4, T5>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void
Returns
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
promisify(Function)
function promisify(fn: Function): FunctionParameters
- fn
-
Function
Returns
Function
raiseCustomEvent(HTMLElement, string, any)
Raises a custom event with event data on the specified HTML element.
function raiseCustomEvent(element: HTMLElement, eventName: string, eventData: any)Parameters
- element
-
HTMLElement
- eventName
-
string
- eventData
-
any
remove<T>((x: T) => boolean, T[])
function remove<T>(predicate: (x: T) => boolean, xs: T[])Parameters
- predicate
-
(x: T) => boolean
- xs
-
T[]
setTraceSigInt(boolean)
Enable or disable printing a stack trace on SIGINT. The API is only available on the main thread.
function setTraceSigInt(enable: boolean)Parameters
- enable
-
boolean
stripVTControlCharacters(string)
Returns str with any ANSI escape codes removed.
console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"
function stripVTControlCharacters(str: string): stringParameters
- str
-
string
Returns
string
styleText(InspectColor | (readonly InspectColor[]) | Object, string, StyleTextOptions)
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.
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);
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:
import { styleText } from '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.
function styleText(format: InspectColor | (readonly InspectColor[]) | Object, text: string, options?: StyleTextOptions): stringParameters
- format
-
InspectColor | (readonly InspectColor[]) | Object
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 to be formatted.
- options
- StyleTextOptions
Returns
string
toUSVString(string)
Returns the string after replacing any surrogate code points
(or equivalently, any unpaired surrogate code units) with the
Unicode "replacement character" U+FFFD.
function toUSVString(string: string): stringParameters
- string
-
string
Returns
string
transferableAbortController()
Creates and returns an AbortController instance whose AbortSignal is marked
as transferable and can be used with structuredClone() or postMessage().
function transferableAbortController(): AbortControllerReturns
AbortController
A transferable AbortController
transferableAbortSignal(AbortSignal)
Marks the given AbortSignal as transferable so that it can be used withstructuredClone() and postMessage().
const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);
function transferableAbortSignal(signal: AbortSignal): AbortSignalParameters
- signal
-
AbortSignal
The AbortSignal
Returns
AbortSignal
The same AbortSignal
Variable Details
APINotSupportedForRDLError
APINotSupportedForRDLError: "This API is currently not supported for RDL reports"Type
"This API is currently not supported for RDL reports"
EmbedUrlNotSupported
EmbedUrlNotSupported: "Embed URL is invalid for this scenario. Please use Power BI REST APIs to get the valid URL"Type
"Embed URL is invalid for this scenario. Please use Power BI REST APIs to get the valid URL"
TextDecoder
TextDecoder: (label?: string, options?: TextDecoderOptions) => TextDecoderType
(label?: string, options?: TextDecoderOptions) => TextDecoder
TextEncoder
TextEncoder: () => TextEncoderType
() => TextEncoder
Document
Document: () => DocumentType
() => Document
HTMLIFrameElement
HTMLIFrameElement: () => HTMLIFrameElementType
() => HTMLIFrameElement
Window
Window: () => WindowType
() => Window
config
config: { type: string, version: string }Type
{ type: string, version: string }
invalidEmbedUrlErrorMessage
invalidEmbedUrlErrorMessage: stringType
string
hpmFactory
hpmFactory: IHpmFactoryType
IHpmFactory
routerFactory
routerFactory: IRouterFactoryType
IRouterFactory
wpmpFactory
wpmpFactory: IWpmpFactoryType
IWpmpFactory