The `util` module is primarily designed to support the needs of Node.js' own

internal APIs. However, many of the utilities are useful for application and

module developers as well. It can be accessed using:

```js

const util = require('util');

```

## util.callbackify(original)

<!-- YAML

added: REPLACEME

-->

* `original` {Function} An `async` function

* Returns: {Function} a callback style function

Takes an `async` function (or a function that returns a Promise) and returns a

function following the Node.js error first callback style. 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.

For example:

```js

const util = require('util');

async function fn() {

return await Promise.resolve('hello world');

}

const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {

if (err) throw err;

console.log(ret);

});

```

Will print:

```txt

hello world

```

*Note*:

* 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`.

```js

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 && err.hasOwnProperty('reason') && err.reason === null; // true

});

```

<!-- YAML

added: v0.11.3

-->

* Returns: {Function} The logging function

The `util.debuglog()` method is used to create a function that conditionally

writes debug messages to `stderr` based on the existence of the `NODE_DEBUG`

environment variable. If the `section` name appears within the value of that

For example:

```

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.

Multiple comma-separated `section` names may be specified in the `NODE_DEBUG`

environment variable. For example: `NODE_DEBUG=fs,net,tls`.

<!-- YAML

added: v0.8.0

-->

```js

const util = require('util');

process.stdout.write(arguments[i] + '\n');

}

}, 'util.puts: Use console.log instead');

```

this warning will be emitted and printed to `stderr` exactly once, the first

time it is called. After the warning is emitted, the wrapped `function`

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

<!-- YAML

added: v0.5.3

-->

The `util.format()` method returns a formatted string using the first argument

as a `printf`-like format.

The first argument is a string containing zero or more *placeholder* tokens.

Each placeholder token is replaced with the converted value from the

corresponding argument. Supported placeholders are:

* `%s` - String.

* `%d` - Number (integer or floating point value).

* `%i` - Integer.

* `%f` - Floating point value.

* `%%` - single percent sign (`'%'`). This does not consume an argument.

If the placeholder does not have a corresponding argument, the placeholder is

not replaced.

If there are more arguments passed to the `util.format()` method than the

number of placeholders, the extra arguments are coerced into strings (for

objects and symbols, `util.inspect()` is used) then concatenated to the

returned string, each delimited by a space.

```js

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

```

If the first argument is not a format string then `util.format()` returns

a string that is the concatenation of all arguments separated by spaces.

Each argument is converted to a string using `util.inspect()`.

```js

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

```

If only one argument is passed to `util.format()`, it is returned as it is

without any formatting.

```js

util.format('%% %s'); // '%% %s'

```

<!-- YAML

added: v0.3.0

changes:

- version: v5.0.0

pr-url: https://github.com/nodejs/node/pull/3455

description: The `constructor` parameter can refer to an ES6 class now.

*Note*: 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][].

* `constructor` {Function}

* `superConstructor` {Function}

Inherit the prototype methods from one [constructor][] into another. The

prototype of `constructor` will be set to a new object created from

`superConstructor`.

As an additional convenience, `superConstructor` will be accessible

through the `constructor.super_` property.

```js

const util = require('util');

const EventEmitter = require('events');

this.emit('data', data);

};

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`

```js

const EventEmitter = require('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');

```

<!-- YAML

added: v0.3.0

changes:

- version: v6.6.0

pr-url: https://github.com/nodejs/node/pull/8174

description: Custom inspection functions can now return `this`.

- version: v6.3.0

pr-url: https://github.com/nodejs/node/pull/7499

description: The `breakLength` option is supported now.

- version: v6.1.0

pr-url: https://github.com/nodejs/node/pull/6334

description: The `maxArrayLength` option is supported now; in particular,

long arrays are truncated by default.

- version: v6.1.0

pr-url: https://github.com/nodejs/node/pull/6465

description: The `showProxy` option is supported now.

* `object` {any} Any JavaScript primitive or Object.

* `options` {Object}

* `showHidden` {boolean} If `true`, the `object`'s non-enumerable symbols and

properties will be included in the formatted result. Defaults to `false`.

* `depth` {number} Specifies the number of times to recurse while formatting

the `object`. This is useful for inspecting large complicated objects.

Defaults to `2`. To make it recurse indefinitely pass `null`.

* `colors` {boolean} If `true`, the output will be styled with ANSI color

codes. Defaults to `false`. Colors are customizable, see

[Customizing `util.inspect` colors][].

* `customInspect` {boolean} If `false`, then custom `inspect(depth, opts)`

functions exported on the `object` being inspected will not be called.

Defaults to `true`.

* `showProxy` {boolean} If `true`, then objects and functions that are

objects. Defaults to `false`.

* `maxArrayLength` {number} Specifies the maximum number of array and

`TypedArray` elements to include when formatting. Defaults to `100`. Set to

`null` to show all array elements. Set to `0` or negative to show no array

elements.

* `breakLength` {number} The length at which an object's keys are split

across multiple lines. Set to `Infinity` to format an object as a single

line. Defaults to 60 for legacy compatibility.

The `util.inspect()` method returns a string representation of `object` that is

primarily useful for debugging. Additional `options` may be passed that alter

certain aspects of the formatted string.

The following example inspects all properties of the `util` object:

```js

const util = require('util');

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

```

the options object passed to `util.inspect()`.

### Customizing `util.inspect` colors

<!-- type=misc -->

via the `util.inspect.styles` and `util.inspect.colors` properties.

`util.inspect.styles` is a map associating a style name to a color from

`util.inspect.colors`.

The default styles and associated colors are:

* `number` - `yellow`

* `boolean` - `yellow`

* `string` - `green`

* `date` - `magenta`

* `regexp` - `red`

* `null` - `bold`

* `undefined` - `grey`

* `special` - `cyan` (only applied to functions at this time)

* `name` - (no styling)

The predefined color codes are: `white`, `grey`, `black`, `blue`, `cyan`,

`green`, `magenta`, `red` and `yellow`. There are also `bold`, `italic`,

`underline` and `inverse` codes.

Color styling uses ANSI control codes that may not be supported on all

terminals.

<!-- type=misc -->

Objects may also define their own `[util.inspect.custom](depth, opts)`

(or, equivalently `inspect(depth, opts)`) function that `util.inspect()` will

invoke and use the result of when inspecting the object:

```js

const util = require('util');

class Box {

constructor(value) {

this.value = value;

}

inspect(depth, options) {

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

.replace(/\n/g, `\n${padding}`);

return `${options.stylize('Box', 'special')}< ${inner} >`;

}

}

const box = new Box(true);

Custom `[util.inspect.custom](depth, opts)` functions typically return a string

but may return a value of any type that will be formatted accordingly by

const util = require('util');

const obj = { foo: 'this will not show up in the inspect() output' };

obj[util.inspect.custom] = function(depth) {

return { bar: 'baz' };

};

util.inspect(obj);

```

A custom inspection method can alternatively be provided by exposing

an `inspect(depth, opts)` method on the object:

```js

const util = require('util');

obj.inspect = function(depth) {

return { bar: 'baz' };

};

### util.inspect.custom

<!-- YAML

added: v6.6.0

-->

A Symbol that can be used to declare custom inspect functions, see

[Custom inspection functions on Objects][].

<!-- YAML

added: v6.4.0

-->

The `defaultOptions` value allows customization of the default options used by

`util.inspect`. This is useful for functions like `console.log` or

`util.format` which implicitly call into `util.inspect`. It shall be set to an

object containing one or more valid [`util.inspect()`][] options. Setting

option properties directly is also supported.

```js

const util = require('util');

console.log(arr); // logs the truncated array

util.inspect.defaultOptions.maxArrayLength = null;

console.log(arr); // logs the full array

```

## util.promisify(original)

<!-- YAML

-->

* `original` {Function}

Takes a function following the common Node.js callback style, i.e. taking a

`(err, value) => ...` callback as the last argument, and returns a version

that returns promises.

For example:

```js

const util = require('util');

const fs = require('fs');

const stat = util.promisify(fs.stat);

stat('.').then((stats) => {

// Do something with `stats`

}).catch((error) => {

// Handle the error.

});

```

Or, equivalently using `async function`s:

```js

const util = require('util');

const fs = require('fs');

const stat = util.promisify(fs.stat);

async function callStat() {

const stats = await stat('.');

console.log(`This directory is owned by ${stats.uid}`);

}

```

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, and the returned function will result in undefined

### Custom promisified functions

Using the `util.promisify.custom` symbol one can override the return value of

[`util.promisify()`][]:

```js

const util = require('util');

function doSomething(foo, callback) {

// ...

}

doSomething[util.promisify.custom] = function(foo) {

return getPromiseSomehow();

};

const promisified = util.promisify(doSomething);

console.log(promisified === doSomething[util.promisify.custom]);

// prints 'true'

```

This can be useful for cases where the original function does not follow the

standard format of taking an error-first callback as the last argument.

### util.promisify.custom