debuglog().enabled

• Тип: <boolean>

Геттер util.debuglog().enabled используется для создания проверки, которую можно использовать в условных выражениях в зависимости от наличия переменной среды NODE_DEBUG. Если имя section содержится в значении этой переменной среды, возвращаемое значение будет true. В противном случае возвращаемое значение будет false.

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

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

Если запустить эту программу с NODE_DEBUG=foo в среде, она выведет что-то вроде:

hello from foo [123] copy

Настройка цветов util.inspect

Вывод цветов (если включен) для util.inspect можно глобально настроить с помощью свойств util.inspect.styles и util.inspect.colors.

util.inspect.styles — это карта, сопоставляющая имя стиля с цветом из util.inspect.colors.

Стили по умолчанию и соответствующие им цвета:

• bigint: yellow
• boolean: yellow
• date: magenta
• module: underline
• name: (без оформления)
• null: bold
• number: yellow
• regexp: red
• special: cyan (например, Proxies)
• string: green
• symbol: green
• undefined: grey

Для оформления цветом используются управляющие коды ANSI, которые могут поддерживаться не всеми терминалами. Чтобы проверить поддержку цветов, используйте tty.hasColors().

Предопределенные управляющие коды перечислены ниже (сгруппированы по категориям «Модификаторы», «Цвета текста» и «Цвета фона»).

Пользовательские функции инспектирования объектов

Объекты также могут определять собственную функцию [util.inspect.custom](depth, opts, inspect), которую util.inspect() вызовет и использует ее результат при инспектировании объекта.

import { inspect } from 'node:util';

class Box {
  constructor(value) {
    this.value = value;
  }

  [inspect.custom](depth, options, inspect) {
    if (depth < 0) {
      return options.stylize('[Box]', 'special');
    }

    const newOptions = Object.assign({}, options, {
      depth: options.depth === null ? null : options.depth - 1,
    });

    // Five space padding because that's the size of "Box< ".
    const padding = ' '.repeat(5);
    const inner = inspect(this.value, newOptions)
                  .replace(/\n/g, `\n${padding}`);
    return `${options.stylize('Box', 'special')}< ${inner} >`;
  }
}

const box = new Box(true);

console.log(inspect(box));
// "Box< true >"

const { inspect } = require('node:util');

class Box {
  constructor(value) {
    this.value = value;
  }

  [inspect.custom](depth, options, inspect) {
    if (depth < 0) {
      return options.stylize('[Box]', 'special');
    }

    const newOptions = Object.assign({}, options, {
      depth: options.depth === null ? null : options.depth - 1,
    });

    // Five space padding because that's the size of "Box< ".
    const padding = ' '.repeat(5);
    const inner = inspect(this.value, newOptions)
                  .replace(/\n/g, `\n${padding}`);
    return `${options.stylize('Box', 'special')}< ${inner} >`;
  }
}

const box = new Box(true);

console.log(inspect(box));
// "Box< true >"

Пользовательские функции [util.inspect.custom](depth, opts, inspect) обычно возвращают строку, но могут возвращать значение любого типа, которое util.inspect() отформатирует соответствующим образом.

import { inspect } from 'node:util';

const obj = { foo: 'this will not show up in the inspect() output' };
obj[inspect.custom] = (depth) => {
  return { bar: 'baz' };
};

console.log(inspect(obj));
// "{ bar: 'baz' }"

const { inspect } = require('node:util');

const obj = { foo: 'this will not show up in the inspect() output' };
obj[inspect.custom] = (depth) => {
  return { bar: 'baz' };
};

console.log(inspect(obj));
// "{ bar: 'baz' }"

util.inspect.custom

• Тип: <symbol>, который можно использовать для объявления пользовательских функций инспектирования.

Помимо доступа через util.inspect.custom, этот символ зарегистрирован глобально и доступен в любой среде как Symbol.for('nodejs.util.inspect.custom').

Это позволяет писать переносимый код: пользовательская функция инспектирования используется в среде Node.js и игнорируется в браузере. Сама функция util.inspect() передается пользовательской функции инспектирования третьим аргументом для обеспечения дополнительной переносимости.

const customInspectSymbol = Symbol.for('nodejs.util.inspect.custom');

class Password {
  constructor(value) {
    this.value = value;
  }

  toString() {
    return 'xxxxxxxx';
  }

  [customInspectSymbol](depth, inspectOptions, inspect) {
    return `Password <${this.toString()}>`;
  }
}

const password = new Password('r0sebud');
console.log(password);
// Prints Password <xxxxxxxx> copy

Дополнительные сведения см. в разделе Пользовательские функции инспектирования объектов.

util.inspect.defaultOptions

Значение defaultOptions позволяет настроить параметры по умолчанию, используемые util.inspect. Это полезно для таких функций, как console.log или util.format, которые неявно вызывают util.inspect. Ему следует присвоить объект, содержащий один или несколько допустимых параметров util.inspect(). Также поддерживается непосредственное задание свойств параметров.

import { inspect } from 'node:util';
const arr = Array(156).fill(0);

console.log(arr); // Logs the truncated array
inspect.defaultOptions.maxArrayLength = null;
console.log(arr); // logs the full array

const { inspect } = require('node:util');
const arr = Array(156).fill(0);

console.log(arr); // Logs the truncated array
inspect.defaultOptions.maxArrayLength = null;
console.log(arr); // logs the full array

Конструктор: new MIMEType(input)

• input <string> Входные данные MIME для разбора

Создает новый объект MIMEType, разбирая input.

import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/plain');

const { MIMEType } = require('node:util');

const myMIME = new MIMEType('text/plain');

Будет выброшено исключение TypeError, если input не является допустимым MIME. Обратите внимание, что будет предпринята попытка преобразовать переданные значения в строки. Например:

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

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

mime.type

• Тип: <string>

Получает и задает часть MIME, содержащую тип.

import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/javascript');
console.log(myMIME.type);
// Prints: text
myMIME.type = 'application';
console.log(myMIME.type);
// Prints: application
console.log(String(myMIME));
// Prints: application/javascript

const { MIMEType } = require('node:util');

const myMIME = new MIMEType('text/javascript');
console.log(myMIME.type);
// Prints: text
myMIME.type = 'application';
console.log(myMIME.type);
// Prints: application
console.log(String(myMIME));
// Prints: application/javascript

mime.subtype

• Тип: <string>

Получает и задает часть MIME, содержащую подтип.

import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/ecmascript');
console.log(myMIME.subtype);
// Prints: ecmascript
myMIME.subtype = 'javascript';
console.log(myMIME.subtype);
// Prints: javascript
console.log(String(myMIME));
// Prints: text/javascript

const { MIMEType } = require('node:util');

const myMIME = new MIMEType('text/ecmascript');
console.log(myMIME.subtype);
// Prints: ecmascript
myMIME.subtype = 'javascript';
console.log(myMIME.subtype);
// Prints: javascript
console.log(String(myMIME));
// Prints: text/javascript

mime.essence

• Тип: <string>

Получает основу MIME. Это свойство доступно только для чтения. Для изменения MIME используйте mime.type или mime.subtype.

import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/javascript;key=value');
console.log(myMIME.essence);
// Prints: text/javascript
myMIME.type = 'application';
console.log(myMIME.essence);
// Prints: application/javascript
console.log(String(myMIME));
// Prints: application/javascript;key=value

const { MIMEType } = require('node:util');

const myMIME = new MIMEType('text/javascript;key=value');
console.log(myMIME.essence);
// Prints: text/javascript
myMIME.type = 'application';
console.log(myMIME.essence);
// Prints: application/javascript
console.log(String(myMIME));
// Prints: application/javascript;key=value

mime.params

• Тип: <MIMEParams>

Получает объект MIMEParams, представляющий параметры MIME. Это свойство доступно только для чтения. Подробности см. в документации MIMEParams.

mime.toString()

• Возвращает: <string>

Метод toString() объекта MIMEType возвращает сериализованное представление MIME.

Для соответствия стандартам этот метод не позволяет пользователям настраивать процесс сериализации MIME.

mime.toJSON()

• Возвращает: <string>

Псевдоним для mime.toString().

Этот метод вызывается автоматически, когда объект MIMEType сериализуется с помощью JSON.stringify().

import { MIMEType } from 'node:util';

const myMIMES = [
  new MIMEType('image/png'),
  new MIMEType('image/gif'),
];
console.log(JSON.stringify(myMIMES));
// Prints: ["image/png", "image/gif"]

const { MIMEType } = require('node:util');

const myMIMES = [
  new MIMEType('image/png'),
  new MIMEType('image/gif'),
];
console.log(JSON.stringify(myMIMES));
// Prints: ["image/png", "image/gif"]

Конструктор: new MIMEParams()

Создает новый объект MIMEParams с пустыми параметрами

import { MIMEParams } from 'node:util';

const myParams = new MIMEParams();

const { MIMEParams } = require('node:util');

const myParams = new MIMEParams();

mimeParams.delete(name)

• name <string>

Удаляет все пары «имя-значение», имя которых — name.

mimeParams.entries()

• Возвращает: <Iterator>

Возвращает итератор по всем парам «имя-значение» в параметрах. Каждый элемент итератора — это массив JavaScript Array. Первый элемент массива — это name, второй элемент массива — это value.

mimeParams.get(name)

• name <string>
• Возвращает: <string> | <null> Строку или null, если пары «имя-значение» с указанным name нет.

Возвращает значение первой пары «имя-значение», имя которой — name. Если таких пар нет, возвращается null.

mimeParams.has(name)

• name <string>
• Возвращает: <boolean>

Возвращает true, если существует хотя бы одна пара «имя-значение», имя которой — name.

mimeParams.keys()

• Возвращает: <Iterator>

Возвращает итератор по именам всех пар «имя-значение».

import { MIMEType } from 'node:util';

const { params } = new MIMEType('text/plain;foo=0;bar=1');
for (const name of params.keys()) {
  console.log(name);
}
// Prints:
//   foo
//   bar

const { MIMEType } = require('node:util');

const { params } = new MIMEType('text/plain;foo=0;bar=1');
for (const name of params.keys()) {
  console.log(name);
}
// Prints:
//   foo
//   bar

mimeParams.set(name, value)

• name <string>
• value <string>

Устанавливает в объекте MIMEParams значение value для name. Если уже существуют пары «имя-значение» с именем name, значение первой такой пары устанавливается в value.

import { MIMEType } from 'node:util';

const { params } = new MIMEType('text/plain;foo=0;bar=1');
params.set('foo', 'def');
params.set('baz', 'xyz');
console.log(params.toString());
// Prints: foo=def;bar=1;baz=xyz

const { MIMEType } = require('node:util');

const { params } = new MIMEType('text/plain;foo=0;bar=1');
params.set('foo', 'def');
params.set('baz', 'xyz');
console.log(params.toString());
// Prints: foo=def;bar=1;baz=xyz

mimeParams.values()

• Возвращает: <Iterator>

Возвращает итератор по значениям всех пар «имя-значение».

mimeParams[Symbol.iterator]()

• Возвращает: <Iterator>

Псевдоним для mimeParams.entries().

import { MIMEType } from 'node:util';

const { params } = new MIMEType('text/plain;foo=bar;xyz=baz');
for (const [name, value] of params) {
  console.log(name, value);
}
// Prints:
//   foo bar
//   xyz baz

const { MIMEType } = require('node:util');

const { params } = new MIMEType('text/plain;foo=bar;xyz=baz');
for (const [name, value] of params) {
  console.log(name, value);
}
// Prints:
//   foo bar
//   xyz baz

parseArgs tokens

Подробная информация о разборе доступна для добавления пользовательского поведения; для этого укажите tokens: true в конфигурации. Возвращаемые токены имеют свойства, описывающие:

• все токены
  • kind <string> Одно из значений 'option', 'positional' или 'option-terminator'.
  • index <number> Индекс элемента в args, содержащего токен. Таким образом, исходный аргумент для токена — это args[token.index].
• токены параметров
  • name <string> Длинное имя параметра.
  • rawName <string> Способ использования параметра в аргументах, например -f для --foo.
  • value <string> | <undefined> Значение параметра, заданное в аргументах. Для логических параметров не определено.
  • inlineValue <boolean> | <undefined> Указывает, задано ли значение параметра непосредственно, например --foo=bar.
• позиционные токены
  • value <string> Значение позиционного аргумента в аргументах (то есть args[index]).
• токен завершения параметров

Возвращаемые токены расположены в том же порядке, в котором они встречаются во входных аргументах. Для параметров, встречающихся в аргументах несколько раз, создается токен для каждого использования. Группы коротких параметров, например -xy, преобразуются в отдельный токен для каждого параметра. Таким образом, -xxx создает три токена.

Например, чтобы добавить поддержку параметра с отрицанием, такого как --no-color (поддерживаемого allowNegative, если параметр имеет тип boolean), возвращаемые токены можно обработать повторно, чтобы изменить сохраненное значение параметра с отрицанием.

import { parseArgs } from 'node:util';

const options = {
  'color': { type: 'boolean' },
  'no-color': { type: 'boolean' },
  'logfile': { type: 'string' },
  'no-logfile': { type: 'boolean' },
};
const { values, tokens } = parseArgs({ options, tokens: true });

// Reprocess the option tokens and overwrite the returned values.
tokens
  .filter((token) => token.kind === 'option')
  .forEach((token) => {
    if (token.name.startsWith('no-')) {
      // Store foo:false for --no-foo
      const positiveName = token.name.slice(3);
      values[positiveName] = false;
      delete values[token.name];
    } else {
      // Resave value so last one wins if both --foo and --no-foo.
      values[token.name] = token.value ?? true;
    }
  });

const color = values.color;
const logfile = values.logfile ?? 'default.log';

console.log({ logfile, color });

const { parseArgs } = require('node:util');

const options = {
  'color': { type: 'boolean' },
  'no-color': { type: 'boolean' },
  'logfile': { type: 'string' },
  'no-logfile': { type: 'boolean' },
};
const { values, tokens } = parseArgs({ options, tokens: true });

// Reprocess the option tokens and overwrite the returned values.
tokens
  .filter((token) => token.kind === 'option')
  .forEach((token) => {
    if (token.name.startsWith('no-')) {
      // Store foo:false for --no-foo
      const positiveName = token.name.slice(3);
      values[positiveName] = false;
      delete values[token.name];
    } else {
      // Resave value so last one wins if both --foo and --no-foo.
      values[token.name] = token.value ?? true;
    }
  });

const color = values.color;
const logfile = values.logfile ?? 'default.log';

console.log({ logfile, color });

Пример использования, демонстрирующий параметры с отрицанием и правило «последнее значение побеждает», если параметр используется несколькими способами.

$ node negate.js
{ logfile: 'default.log', color: undefined }
$ node negate.js --no-logfile --no-color
{ logfile: false, color: false }
$ node negate.js --logfile=test.log --color
{ logfile: 'test.log', color: true }
$ node negate.js --no-logfile --logfile=test.log --color --no-color
{ logfile: 'test.log', color: false } copy

Пользовательские функции с поддержкой промисов

С помощью символа util.promisify.custom можно переопределить возвращаемое значение util.promisify():

import { promisify } from 'node:util';

function doSomething(foo, callback) {
  // ...
}

doSomething[promisify.custom] = (foo) => {
  return getPromiseSomehow();
};

const promisified = promisify(doSomething);
console.log(promisified === doSomething[promisify.custom]);
// prints 'true'

const { promisify } = require('node:util');

function doSomething(foo, callback) {
  // ...
}

doSomething[promisify.custom] = (foo) => {
  return getPromiseSomehow();
};

const promisified = promisify(doSomething);
console.log(promisified === doSomething[promisify.custom]);
// prints 'true'

Это может быть полезно, если исходная функция не соответствует стандартному формату, в котором обратный вызов с ошибкой в первом аргументе передаётся в качестве последнего аргумента.

Например, для функции, принимающей (foo, onSuccessCallback, onErrorCallback):

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

Если promisify.custom определено, но не является функцией, promisify() выбросит ошибку.

util.promisify.custom

• Тип: <symbol>, который можно использовать для объявления пользовательских вариантов функций с поддержкой промисов; см. раздел Пользовательские функции с поддержкой промисов.

Помимо доступа через util.promisify.custom, этот символ зарегистрирован глобально и доступен в любой среде как Symbol.for('nodejs.util.promisify.custom').

Например, для функции, принимающей (foo, onSuccessCallback, onErrorCallback):

const kCustomPromisifiedSymbol = Symbol.for('nodejs.util.promisify.custom');

doSomething[kCustomPromisifiedSymbol] = (foo) => {
  return new Promise((resolve, reject) => {
    doSomething(foo, resolve, reject);
  });
}; copy

Поддерживаемые кодировки WHATWG

Согласно стандарту кодирования WHATWG, кодировки, поддерживаемые API TextDecoder, перечислены в таблицах ниже. Для каждой кодировки можно использовать один или несколько псевдонимов.

Различные конфигурации сборки Node.js поддерживают разные наборы кодировок. (см. раздел Интернационализация)

new TextDecoder([encoding[, options]])

• encoding <string> Определяет кодировку encoding, поддерживаемую этим экземпляром TextDecoder. По умолчанию: 'utf-8'.
• options <Object>
  • fatal <boolean> true, если ошибки декодирования должны считаться фатальными. Этот параметр не поддерживается, если ICU отключён (см. раздел Интернационализация). По умолчанию: false.
  • ignoreBOM <boolean> Если true, TextDecoder будет включать метку порядка байтов в результат декодирования. Если false, метка порядка байтов будет удалена из выходных данных. Этот параметр используется только в том случае, если encoding имеет значение 'utf-8', 'utf-16be' или 'utf-16le'. По умолчанию: false.

Создаёт новый экземпляр TextDecoder. В encoding можно указать одну из поддерживаемых кодировок или её псевдоним.

Класс TextDecoder также доступен в глобальном объекте.

textDecoder.decode([input[, options]])

• input <ArrayBuffer> | <DataView> | <TypedArray> Экземпляр ArrayBuffer, DataView или TypedArray, содержащий закодированные данные.
• options <Object>
  • stream <boolean> true, если ожидаются дополнительные фрагменты данных. По умолчанию: false.
• Возвращает: <string>

Декодирует input и возвращает строку. Если options.stream имеет значение true, неполные последовательности байтов в конце input буферизуются внутри и выдаются после следующего вызова textDecoder.decode().

Если textDecoder.fatal имеет значение true, возникающие ошибки декодирования приводят к выбрасыванию TypeError.

textDecoder.encoding

• Тип: <string>

Кодировка, поддерживаемая экземпляром TextDecoder.

textDecoder.fatal

• Тип: <boolean>

Значение будет true, если ошибки декодирования приводят к выбрасыванию TypeError.

textDecoder.ignoreBOM

• Тип: <boolean>

Значение будет true, если результат декодирования будет включать метку порядка байтов.

textEncoder.encode([input])

• input <string> Текст для кодирования. По умолчанию: пустая строка.
• Возвращает: <Uint8Array>

Кодирует строку input в UTF-8 и возвращает Uint8Array с закодированными байтами.

textEncoder.encodeInto(src, dest)

• src <string> Текст для кодирования.
• dest <Uint8Array> Массив для хранения результата кодирования.
• Возвращает: <Object>
  • read <number> Количество прочитанных кодовых единиц Unicode из src.
  • written <number> Количество записанных байтов UTF-8 в dest.

Кодирует строку src в UTF-8 и записывает результат в Uint8Array dest, а затем возвращает объект, содержащий количество прочитанных кодовых единиц Unicode и записанных байтов UTF-8.

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

textEncoder.encoding

• Тип: <string>

Кодировка, поддерживаемая экземпляром TextEncoder. Всегда имеет значение 'utf-8'.

util.types.isAnyArrayBuffer(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <ArrayBuffer> или <SharedArrayBuffer>.

См. также util.types.isArrayBuffer() и util.types.isSharedArrayBuffer().

util.types.isAnyArrayBuffer(new ArrayBuffer());  // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer());  // Returns true copy

util.types.isArrayBufferView(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром одного из представлений <ArrayBuffer>, например типизированным массивом или <DataView>. Эквивалентно 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 copy

util.types.isArgumentsObject(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является объектом arguments.

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

util.types.isArrayBuffer(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <ArrayBuffer>. Сюда не входят экземпляры <SharedArrayBuffer>. Обычно желательно проверять оба типа; для этого см. util.types.isAnyArrayBuffer().

util.types.isArrayBuffer(new ArrayBuffer());  // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer());  // Returns false copy

util.types.isAsyncFunction(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является асинхронной функцией. Здесь сообщается только то, что видит движок JavaScript; в частности, возвращаемое значение может не соответствовать исходному коду, если использовался инструмент транспиляции.

util.types.isAsyncFunction(function foo() {});  // Returns false
util.types.isAsyncFunction(async function foo() {});  // Returns true copy

util.types.isBigInt64Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром BigInt64Array.

util.types.isBigInt64Array(new BigInt64Array());   // Returns true
util.types.isBigInt64Array(new BigUint64Array());  // Returns false copy

util.types.isBigIntObject(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является объектом BigInt, например созданным с помощью Object(BigInt(123)).

util.types.isBigIntObject(Object(BigInt(123)));   // Returns true
util.types.isBigIntObject(BigInt(123));   // Returns false
util.types.isBigIntObject(123);  // Returns false copy

util.types.isBigUint64Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром BigUint64Array.

util.types.isBigUint64Array(new BigInt64Array());   // Returns false
util.types.isBigUint64Array(new BigUint64Array());  // Returns true copy

util.types.isBooleanObject(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является логическим объектом, например созданным с помощью 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 copy

util.types.isBoxedPrimitive(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является любым объектом-обёрткой примитива, например созданным с помощью new Boolean(), new String() или Object(Symbol()).

Например:

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 copy

util.types.isCryptoKey(value)

• value <Object>
• Возвращает: <boolean>

Возвращает true, если value является <CryptoKey>, и false в противном случае.

util.types.isDataView(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <DataView>.

const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab));  // Returns true
util.types.isDataView(new Float64Array());  // Returns false copy

См. также ArrayBuffer.isView().

util.types.isDate(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Date>.

util.types.isDate(new Date());  // Returns true copy

util.types.isExternal(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является нативным значением External.

Нативное значение External — это специальный тип объекта, содержащий необработанный указатель C++ (void*) для доступа из нативного кода и не имеющий других свойств. Такие объекты создаются либо внутренними механизмами Node.js, либо нативными дополнениями. В JavaScript это замороженные объекты с прототипом null.

#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)
... copy

import native from 'napi_addon.node';
import { types } from 'node:util';

const data = native.myNapi();
types.isExternal(data); // returns true
types.isExternal(0); // returns false
types.isExternal(new String('foo')); // returns false

const native = require('napi_addon.node');
const { types } = require('node:util');

const data = native.myNapi();
types.isExternal(data); // returns true
types.isExternal(0); // returns false
types.isExternal(new String('foo')); // returns false

Дополнительные сведения о napi_create_external см. в разделе napi_create_external().

util.types.isFloat16Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Float16Array>.

util.types.isFloat16Array(new ArrayBuffer());  // Returns false
util.types.isFloat16Array(new Float16Array());  // Returns true
util.types.isFloat16Array(new Float32Array());  // Returns false copy

util.types.isFloat32Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Float32Array>.

util.types.isFloat32Array(new ArrayBuffer());  // Returns false
util.types.isFloat32Array(new Float32Array());  // Returns true
util.types.isFloat32Array(new Float64Array());  // Returns false copy

util.types.isFloat64Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Float64Array>.

util.types.isFloat64Array(new ArrayBuffer());  // Returns false
util.types.isFloat64Array(new Uint8Array());  // Returns false
util.types.isFloat64Array(new Float64Array());  // Returns true copy

util.types.isGeneratorFunction(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является функцией-генератором. Здесь сообщается только то, что видит движок JavaScript; в частности, возвращаемое значение может не соответствовать исходному коду, если использовался инструмент транспиляции.

util.types.isGeneratorFunction(function foo() {});  // Returns false
util.types.isGeneratorFunction(function* foo() {});  // Returns true copy

util.types.isGeneratorObject(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является объектом-генератором, возвращённым встроенной функцией-генератором. Эта функция сообщает только то, что видит движок JavaScript; в частности, возвращаемое значение может не совпадать с исходным исходным кодом, если использовался инструмент транспиляции.

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

util.types.isInt8Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Int8Array>.

util.types.isInt8Array(new ArrayBuffer());  // Returns false
util.types.isInt8Array(new Int8Array());  // Returns true
util.types.isInt8Array(new Float64Array());  // Returns false copy

util.types.isInt16Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Int16Array>.

util.types.isInt16Array(new ArrayBuffer());  // Returns false
util.types.isInt16Array(new Int16Array());  // Returns true
util.types.isInt16Array(new Float64Array());  // Returns false copy

util.types.isInt32Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Int32Array>.

util.types.isInt32Array(new ArrayBuffer());  // Returns false
util.types.isInt32Array(new Int32Array());  // Returns true
util.types.isInt32Array(new Float64Array());  // Returns false copy

util.types.isKeyObject(value)

• value <Object>
• Возвращает: <boolean>

Возвращает true, если value является <KeyObject>, и false в противном случае.

util.types.isMap(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Map>.

util.types.isMap(new Map());  // Returns true copy

util.types.isMapIterator(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является итератором, возвращённым для экземпляра встроенного <Map>.

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 copy

util.types.isModuleNamespaceObject(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром объекта пространства имён модуля.

import * as ns from './a.js';

util.types.isModuleNamespaceObject(ns);  // Returns true copy

util.types.isNativeError(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение было возвращено конструктором встроенного типа Error.

console.log(util.types.isNativeError(new Error()));  // true
console.log(util.types.isNativeError(new TypeError()));  // true
console.log(util.types.isNativeError(new RangeError()));  // true copy

Подклассы встроенных типов ошибок также являются встроенными ошибками:

class MyError extends Error {}
console.log(util.types.isNativeError(new MyError()));  // true copy

То, что значение instanceof является экземпляром встроенного класса ошибок, не равнозначно isNativeError() возвращению true для этого значения. isNativeError() возвращает true для ошибок из другой области выполнения, тогда как instanceof Error возвращает false для этих ошибок:

import { createContext, runInContext } from 'node:vm';
import { types } from 'node:util';

const context = createContext({});
const myError = runInContext('new Error()', context);
console.log(types.isNativeError(myError)); // true
console.log(myError instanceof Error); // false

const { createContext, runInContext } = require('node:vm');
const { types } = require('node:util');

const context = createContext({});
const myError = runInContext('new Error()', context);
console.log(types.isNativeError(myError)); // true
console.log(myError instanceof Error); // false

И наоборот, isNativeError() возвращает false для всех объектов, которые не были возвращены конструктором встроенной ошибки. Сюда входят значения, которые instanceof являются встроенными ошибками:

const myError = { __proto__: Error.prototype };
console.log(util.types.isNativeError(myError)); // false
console.log(myError instanceof Error); // true copy

util.types.isNumberObject(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является объектом числа, например созданным с помощью new Number().

util.types.isNumberObject(0);  // Returns false
util.types.isNumberObject(new Number(0));   // Returns true copy

util.types.isPromise(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является встроенным <Promise>.

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

util.types.isProxy(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром <Proxy>.

const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target);  // Returns false
util.types.isProxy(proxy);  // Returns true copy

util.types.isRegExp(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является объектом регулярного выражения.

util.types.isRegExp(/abc/);  // Returns true
util.types.isRegExp(new RegExp('abc'));  // Returns true copy

util.types.isSet(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Set>.

util.types.isSet(new Set());  // Returns true copy

util.types.isSetIterator(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является итератором, возвращённым для экземпляра встроенного <Set>.

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 copy

util.types.isSharedArrayBuffer(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <SharedArrayBuffer>. Сюда не входят экземпляры <ArrayBuffer>. Обычно рекомендуется проверять оба типа; для этого см. util.types.isAnyArrayBuffer().

util.types.isSharedArrayBuffer(new ArrayBuffer());  // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer());  // Returns true copy

util.types.isStringObject(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является объектом строки, например созданным с помощью new String().

util.types.isStringObject('foo');  // Returns false
util.types.isStringObject(new String('foo'));   // Returns true copy

util.types.isSymbolObject(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является объектом символа, созданным вызовом Object() для примитива Symbol.

const symbol = Symbol('foo');
util.types.isSymbolObject(symbol);  // Returns false
util.types.isSymbolObject(Object(symbol));   // Returns true copy

util.types.isTypedArray(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <TypedArray>.

util.types.isTypedArray(new ArrayBuffer());  // Returns false
util.types.isTypedArray(new Uint8Array());  // Returns true
util.types.isTypedArray(new Float64Array());  // Returns true copy

См. также ArrayBuffer.isView().

util.types.isUint8Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является экземпляром встроенного <Uint8Array>.

util.types.isUint8Array(new ArrayBuffer());  // Returns false
util.types.isUint8Array(new Uint8Array());  // Returns true
util.types.isUint8Array(new Float64Array());  // Returns false copy

util.types.isUint8ClampedArray(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является встроенным экземпляром <Uint8ClampedArray>.

util.types.isUint8ClampedArray(new ArrayBuffer());  // Returns false
util.types.isUint8ClampedArray(new Uint8ClampedArray());  // Returns true
util.types.isUint8ClampedArray(new Float64Array());  // Returns false copy

util.types.isUint16Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является встроенным экземпляром <Uint16Array>.

util.types.isUint16Array(new ArrayBuffer());  // Returns false
util.types.isUint16Array(new Uint16Array());  // Returns true
util.types.isUint16Array(new Float64Array());  // Returns false copy

util.types.isUint32Array(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является встроенным экземпляром <Uint32Array>.

util.types.isUint32Array(new ArrayBuffer());  // Returns false
util.types.isUint32Array(new Uint32Array());  // Returns true
util.types.isUint32Array(new Float64Array());  // Returns false copy

util.types.isWeakMap(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является встроенным экземпляром <WeakMap>.

util.types.isWeakMap(new WeakMap());  // Returns true copy

util.types.isWeakSet(value)

• value <any>
• Возвращает: <boolean>

Возвращает true, если значение является встроенным экземпляром <WeakSet>.

util.types.isWeakSet(new WeakSet());  // Returns true copy

util._extend(target, source)

• target <Object>
• source <Object>

Метод util._extend() никогда не предназначался для использования вне внутренних модулей Node.js. Тем не менее сообщество обнаружило его и стало использовать.

Он устарел и не должен использоваться в новом коде. В JavaScript есть очень похожие встроенные возможности — Object.assign().

util.isArray(object)

• object <any>
• Возвращает: <boolean>

Псевдоним для Array.isArray().

Возвращает true, если заданное значение object является Array. В противном случае возвращает false.

const util = require('node:util');

util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false copy

util.isBoolean(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object является Boolean. В противном случае возвращает false.

const util = require('node:util');

util.isBoolean(1);
// Returns: false
util.isBoolean(0);
// Returns: false
util.isBoolean(false);
// Returns: true copy

util.isBuffer(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object является Buffer. В противном случае возвращает false.

const util = require('node:util');

util.isBuffer({ length: 0 });
// Returns: false
util.isBuffer([]);
// Returns: false
util.isBuffer(Buffer.from('hello world'));
// Returns: true copy

util.isDate(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object является Date. В противном случае возвращает false.

const util = require('node:util');

util.isDate(new Date());
// Returns: true
util.isDate(Date());
// false (without 'new' returns a String)
util.isDate({});
// Returns: false copy

util.isError(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object является <Error>. В противном случае возвращает false.

const util = require('node:util');

util.isError(new Error());
// Returns: true
util.isError(new TypeError());
// Returns: true
util.isError({ name: 'Error', message: 'an error occurred' });
// Returns: false copy

Этот метод зависит от поведения Object.prototype.toString(). Если аргумент object изменяет @@toStringTag, результат может оказаться неверным.

const util = require('node:util');
const obj = { name: 'Error', message: 'an error occurred' };

util.isError(obj);
// Returns: false
obj[Symbol.toStringTag] = 'Error';
util.isError(obj);
// Returns: true copy

util.isFunction(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object является Function. В противном случае возвращает false.

const util = require('node:util');

function Foo() {}
const Bar = () => {};

util.isFunction({});
// Returns: false
util.isFunction(Foo);
// Returns: true
util.isFunction(Bar);
// Returns: true copy

util.isNull(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object строго равно null. В противном случае возвращает false.

const util = require('node:util');

util.isNull(0);
// Returns: false
util.isNull(undefined);
// Returns: false
util.isNull(null);
// Returns: true copy

util.isNullOrUndefined(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object равно null или undefined. В противном случае возвращает false.

const util = require('node:util');

util.isNullOrUndefined(0);
// Returns: false
util.isNullOrUndefined(undefined);
// Returns: true
util.isNullOrUndefined(null);
// Returns: true copy

util.isNumber(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object является Number. В противном случае возвращает false.

const util = require('node:util');

util.isNumber(false);
// Returns: false
util.isNumber(Infinity);
// Returns: true
util.isNumber(0);
// Returns: true
util.isNumber(NaN);
// Returns: true copy

util.isObject(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object строго является Object и не является Function (хотя в JavaScript функции являются объектами). В противном случае возвращает false.

const util = require('node:util');

util.isObject(5);
// Returns: false
util.isObject(null);
// Returns: false
util.isObject({});
// Returns: true
util.isObject(() => {});
// Returns: false copy

util.isPrimitive(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object имеет примитивный тип. В противном случае возвращает false.

const util = require('node:util');

util.isPrimitive(5);
// Returns: true
util.isPrimitive('foo');
// Returns: true
util.isPrimitive(false);
// Returns: true
util.isPrimitive(null);
// Returns: true
util.isPrimitive(undefined);
// Returns: true
util.isPrimitive({});
// Returns: false
util.isPrimitive(() => {});
// Returns: false
util.isPrimitive(/^$/);
// Returns: false
util.isPrimitive(new Date());
// Returns: false copy

util.isRegExp(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object является RegExp. В противном случае возвращает false.

const util = require('node:util');

util.isRegExp(/some regexp/);
// Returns: true
util.isRegExp(new RegExp('another regexp'));
// Returns: true
util.isRegExp({});
// Returns: false copy

util.isString(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object является string. В противном случае возвращает false.

const util = require('node:util');

util.isString('');
// Returns: true
util.isString('foo');
// Returns: true
util.isString(String('foo'));
// Returns: true
util.isString(5);
// Returns: false copy

util.isSymbol(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object является Symbol. В противном случае возвращает false.

const util = require('node:util');

util.isSymbol(5);
// Returns: false
util.isSymbol('foo');
// Returns: false
util.isSymbol(Symbol('foo'));
// Returns: true copy

util.isUndefined(object)

• object <any>
• Возвращает: <boolean>

Возвращает true, если заданное значение object равно undefined. В противном случае возвращает false.

const util = require('node:util');

const foo = undefined;
util.isUndefined(5);
// Returns: false
util.isUndefined(foo);
// Returns: true
util.isUndefined(null);
// Returns: false copy

util.log(string)

• string <string>

Метод util.log() выводит переданную строку string в stdout с добавлением временной метки.

const util = require('node:util');

util.log('Timestamped message.'); copy