util.callbackify(original)

• original <Функция> Функция async
• Возвращает: <Функция> функция в стиле обратного вызова

Принимает функцию async (или функцию, возвращающую Promise) и возвращает функцию, следующую стилю обратного вызова «ошибка-сначала», т. е. принимающую (err, value) => ... обратный вызов в качестве последнего аргумента. В обратном вызове первым аргументом будет причина отклонения (или null, если Promise разрешена), а вторым — разрешенное значение.

const util = require('util');

async function fn() {
  return 'hello world';
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  if (err) throw err;
  console.log(ret);
});

Выведет:

hello world

Обратный вызов выполняется асинхронно и имеет ограниченный стек отслеживания. Если обратный вызов вызывает исключение, процесс выпустит событие 'uncaughtException', а если не обработано, завершится.

Поскольку null имеет особое значение в качестве первого аргумента обратного вызова, если обернутая функция отклоняет Promise с ложным значением в качестве причины, значение оборачивается в Error с исходным значением, хранящимся в поле с именем reason.

function fn() {
  return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  // When the Promise was rejected with `null` it is wrapped with an Error and
  // the original value is stored in `reason`.
  err && err.hasOwnProperty('reason') && err.reason === null;  // true
});

util.debuglog(section[, callback])

• section <строка> Строка, идентифицирующая часть приложения, для которой создается функция debuglog.
• callback <Функция> Обратный вызов, вызываемый в первый раз, когда функция ведения журнала вызывается с аргументом функции, являющимся более оптимизированной функцией ведения журнала.
• Возвращает: <Функция> Функция ведения журнала

Метод util.debuglog() используется для создания функции, которая условно записывает сообщения отладки в stderr на основе существования переменной среды NODE_DEBUG. Если имя section встречается в значении этой переменной среды, то возвращаемая функция действует аналогично console.error(). В противном случае возвращаемая функция — это операция без действия.

const util = require('util');
const debuglog = util.debuglog('foo');

debuglog('hello from foo [%d]', 123);

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

FOO 3245: hello from foo [123]

где 3245 — идентификатор процесса. Если она запущена без этой переменной среды, ничего не выводится.

section поддерживает также подстановочные знаки:

const util = require('util');
const debuglog = util.debuglog('foo-bar');

debuglog('hi there, it\'s foo-bar [%d]', 2333);

если она запущена со значением NODE_DEBUG=foo* в среде, она выведет что-то вроде:

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

В переменной среды NODE_DEBUG можно указать несколько имен section, разделенных запятыми: NODE_DEBUG=fs,net,tls.

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

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

debuglog().enabled

• <логическое значение>

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

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

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

hello from foo [123]

util.debug(section)

Псевдоним для util.debuglog. Использование позволяет улучшить читаемость, которая не подразумевает ведение журнала, когда используется только util.debuglog().enabled.

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

• fn <Функция> Функция, которая устаревает.
• msg <строка> Сообщение предупреждения, отображаемое при вызове устаревшей функции.
• code <строка> Код устаревания. Список устаревших API см. в списке устаревших API.
• Возвращает: <Функция> Обёртка устаревшей функции для вывода предупреждения.

Метод util.deprecate() оборачивает fn (которое может быть функцией или классом) таким образом, что оно отмечается как устаревшее.

const util = require('util');

exports.obsoleteFunction = util.deprecate(() => {
  // Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');

При вызове util.deprecate() вернёт функцию, которая выведет предупреждение DeprecationWarning с помощью события 'warning'. Предупреждение будет выведено и выведено в stderr в первый раз, когда вызывается возвращённая функция. После вывода предупреждения вызывается обернутая функция без вывода предупреждения.

Если тот же необязательный code передаётся в несколько вызовов util.deprecate(), предупреждение будет выведено только один раз для этого code.

const util = require('util');

const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');
const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code

Если используются флаги командной строки --no-deprecation или --no-warnings, или если свойство process.noDeprecation установлено в true до первого предупреждения об устаревании, метод util.deprecate() ничего не делает.

Если флаги командной строки --trace-deprecation или --trace-warnings установлены, или свойство process.traceDeprecation установлено в true, предупреждение и стек отслеживания выводятся в stderr в первый раз, когда вызывается устаревшая функция.

Если установлен флаг командной строки --throw-deprecation или свойство process.throwDeprecation установлено в true, при вызове устаревшей функции будет выброшено исключение.

Флаги командной строки --throw-deprecation и свойство process.throwDeprecation имеют приоритет над --trace-deprecation и process.traceDeprecation.

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

• format <строка> Строка формата, похожая на printf.

Метод util.format() возвращает отформатированную строку, используя первый аргумент в качестве строки формата, похожей на printf, которая может содержать ноль или более спецификаторов формата. Каждый спецификатор заменяется преобразованным значением из соответствующего аргумента. Поддерживаемые спецификаторы:

• %s: String будет использоваться для преобразования всех значений, кроме BigInt, Object и -0. Значения BigInt будут представлены с помощью n, а объекты, у которых нет пользовательской функции toString, проверяются с помощью util.inspect() с опциями { depth: 0, colors: false, compact: 3 }.
• %d: Number будет использоваться для преобразования всех значений, кроме BigInt и Symbol.
• %i: parseInt(value, 10) используется для всех значений, кроме BigInt и Symbol.
• %f: parseFloat(value) используется для всех значений, кроме Symbol.
• %j: JSON. Заменяется строкой '[Circular]', если аргумент содержит циклические ссылки.
• %o: Object. Строковое представление объекта с общим форматированием JavaScript-объектов. Аналогично util.inspect() с опциями { showHidden: true, showProxy: true }. Это покажет весь объект, включая неперечисляемые свойства и прокси.
• %O: Object. Строковое представление объекта с общим форматированием JavaScript-объектов. Аналогично util.inspect() без опций. Это покажет весь объект, не включая неперечисляемые свойства и прокси.
• %c: CSS. Этот спецификатор игнорируется и пропустит любой переданный CSS.
• %%: одиночный знак процента ('%'). Это не потребляет аргумент.
• Возвращает: <строка> Отформатированная строка

Если у спецификатора нет соответствующего аргумента, он не заменяется:

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

Значения, которые не являются частью строки формата, форматируются с помощью util.inspect(), если их тип не string.

Если аргументов, переданных методу util.format(), больше, чем количество спецификаторов, дополнительные аргументы конкатенируются в возвращаемую строку, разделенные пробелами:

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

Если первый аргумент не содержит допустимого спецификатора формата, util.format() возвращает строку, которая является конкатенацией всех аргументов, разделенных пробелами:

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

Если методу util.format() передан только один аргумент, он возвращается как есть без форматирования:

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

util.format() — это синхронный метод, предназначенный в качестве инструмента отладки. Некоторые входные значения могут иметь значительную нагрузку на производительность, которая может заблокировать цикл событий. Используйте эту функцию с осторожностью и никогда в горячей точке кода.

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

• inspectOptions <Объект>
• format <строка>

Эта функция идентична util.format(), за исключением того, что она принимает аргумент inspectOptions, который определяет опции, передаваемые util.inspect().

util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });
// Returns 'See object { foo: 42 }', where `42` is colored as a number
// when printed to a terminal.

util.getSystemErrorName(err)

• err <число>
• Возвращает: <строка>

Возвращает строковое имя для числового кода ошибки, полученного из API Node.js. Сопоставление между кодами ошибок и именами ошибок зависит от платформы. Смотрите Общие системные ошибки для имен распространенных ошибок.

fs.access('file/that/does/not/exist', (err) => {
  const name = util.getSystemErrorName(err.errno);
  console.error(name);  // ENOENT
});

util.getSystemErrorMap()

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

Возвращает Map всех системных кодов ошибок, доступных из API Node.js. Сопоставление между кодами ошибок и именами ошибок зависит от платформы. Смотрите Общие системные ошибки для имен распространенных ошибок.

fs.access('file/that/does/not/exist', (err) => {
  const errorMap = util.getSystemErrorMap();
  const name = errorMap.get(err.errno);
  console.error(name);  // ENOENT
});

util.inherits(constructor, superConstructor)

• constructor <Функция>
• superConstructor <Функция>

Использование util.inherits() не рекомендуется. Пожалуйста, используйте ключевые слова ES6 class и extends, чтобы получить поддержку наследования на уровне языка. Также обратите внимание, что два стиля семантически несовместимы.

Унаследовать методы прототипа из одного конструктора в другой. Прототип constructor будет установлен на новый объект, созданный из superConstructor.

В основном добавляет некоторую проверку ввода поверх Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). В качестве дополнительного удобства superConstructor будет доступен через свойство constructor.super_.

const util = require('util');
const EventEmitter = require('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 с использованием class и extends:

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

util.inspect(object[, options])

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

• object <любой> Любой примитив JavaScript или Object.
• options <Объект>
  • showHidden <boolean> Если true, неперечисляемые символы и свойства object включаются в отформатированный результат. WeakMap и WeakSet записи также включаются, а также пользовательские свойства прототипа (исключая свойства методов). По умолчанию: false.
  • depth <число> Указывает количество рекурсий при форматировании object. Это полезно для проверки больших объектов. Для рекурсии до максимального размера стека вызовов передайте Infinity или null. По умолчанию: 2.
  • colors <boolean> Если true, вывод стилизуется с кодами ANSI-цветов. Цвета настраиваются. См. Настройка цветов util.inspect. По умолчанию: false.
  • customInspect <boolean> Если false, функции [util.inspect.custom](depth, opts) не вызываются. По умолчанию: true.
  • showProxy <boolean> Если true, проверка Proxy включает в себя объекты target и handler. По умолчанию: false.
  • maxArrayLength <целое число> Указывает максимальное количество Array, TypedArray, WeakMap и WeakSet элементов для включения при форматировании. Установите в null или Infinity для отображения всех элементов. Установите в 0 или отрицательное значение для отображения ни одного элемента. По умолчанию: 100.
  • maxStringLength <целое число> Указывает максимальное количество символов для включения при форматировании. Установите в null или Infinity для отображения всех элементов. Установите в 0 или отрицательное значение для отображения ни одного символа. По умолчанию: Infinity.
  • breakLength <целое число> Длина, при которой входные значения разбиваются на несколько строк. Установите в Infinity для форматирования входных данных в одну строку (в сочетании с compact установленным в true или любое число ≥ 1). По умолчанию: 80.
  • compact <boolean> | <целое число> Установка этого значения в false приводит к отображению каждого ключа объекта на новой строке. Также добавляет новые строки к тексту, длина которого превышает breakLength. Если установлено число, то самые n вложенные элементы объединяются в одну строку, если все свойства помещаются в breakLength. Короткие элементы массивов также группируются вместе. Текст не будет сокращен ниже 16 символов, независимо от размера breakLength. Более подробную информацию см. в примере ниже. По умолчанию: 3.
  • sorted <boolean> | <Функция> Если установлено в true или функцию, все свойства объекта, а также Set и Map записи сортируются в результирующей строке. Если установлено в true, используется стандартная сортировка. Если установлено в функцию, она используется как функция сравнения.
  • getters <boolean> | <строка> Если установлено в true, проверяются геттеры. Если установлено в 'get', проверяются только геттеры без соответствующего сеттера. Если установлено в 'set', проверяются только геттеры с соответствующим сеттером. Это может вызвать побочные эффекты в зависимости от функции геттера. По умолчанию: false.
• Возвращает: <строка> Представление object.

Метод util.inspect() возвращает строковое представление object, предназначенное для отладки. Вывод util.inspect может меняться в любое время и не должен использоваться в программировании. Дополнительные options могут быть переданы для изменения результата. util.inspect() будет использовать имя конструктора и/или @@toStringTag для создания идентифицирующей метки проверяемого значения.

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] {}'

Циклические ссылки указывают на своё якорное значение с помощью индекса ссылки:

const { inspect } = require('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] }
// }

Следующий пример проверяет все свойства объекта util:

const util = require('util');

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

Следующий пример показывает влияние опции compact:

const util = require('util');

const o = {
  a: [1, 2, [[
    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +
      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',
    'test',
    'foo']], 4],
  b: new Map([['za', 1], ['zb', 'test']])
};
console.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));

// { a:
//   [ 1,
//     2,
//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line
//           'test',
//           'foo' ] ],
//     4 ],
//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }

// Setting `compact` to false changes the output to be more reader friendly.
console.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));

// {
//   a: [
//     1,
//     2,
//     [
//       [
//         'Lorem ipsum dolor sit amet, consectetur ' +
//           'adipiscing elit, sed do eiusmod 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.
// Reducing the `breakLength` will split the "Lorem ipsum" text in smaller
// chunks.

Опция showHidden позволяет проверять записи WeakMap и WeakSet. Если записей больше, чем maxArrayLength, нет гарантии, какие записи будут отображены. Это означает, что получение одних и тех же записей WeakSet дважды может привести к разному результату. Кроме того, записи без оставшихся сильных ссылок могут быть удалены из памяти в любое время.

const { inspect } = require('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 } }

Опция sorted гарантирует, что порядок вставки свойств объекта не повлияет на результат util.inspect().

const { inspect } = require('util');
const assert = require('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 })
);

util.inspect() — это синхронный метод, предназначенный для отладки. Максимальная длина его вывода составляет примерно 128 МБ. Входные данные, приводящие к более длинному выводу, будут усечены.

Настройка цветов 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().

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

Модификаторы

Поддержка модификаторов варьируется в зависимости от терминала. Они в основном будут игнорироваться, если не поддерживаются.

• reset — Сбрасывает все (цветные) модификаторы к значениям по умолчанию
• жирный — Сделать текст жирным
• курсив — Сделать текст курсивом
• подчеркнутый — Подчеркнуть текст
• зачеркнутый — Проводит горизонтальную линию по центру текста (Псевдоним: strikeThrough, crossedout, crossedOut)
• hidden — Выводит текст, но делает его невидимым (Псевдоним: скрыть)
• приглушенный — Уменьшенная интенсивность цвета (Псевдоним: faint)
• перечеркнутый — Надчеркнуть текст
• мигание — Скрывает и отображает текст с интервалом
• инверсия — Меняет местами цвета переднего и заднего плана (Псевдоним: swapcolors, swapColors)
• двойное подчеркивание — Сделать текст двойным подчеркнутым (Псевдоним: doubleUnderline)
• рамка — Нарисовать рамку вокруг текста

Цвета переднего плана

• black
• red
• green
• yellow
• blue
• magenta
• cyan
• white
• gray (псевдоним: grey, blackBright)
• redBright
• greenBright
• yellowBright
• blueBright
• magentaBright
• cyanBright
• whiteBright

Цвета фона

• bgBlack
• bgRed
• bgGreen
• bgYellow
• bgBlue
• bgMagenta
• bgCyan
• bgWhite
• bgGray (псевдоним: bgGrey, bgBlackBright)
• bgRedBright
• bgGreenBright
• bgYellowBright
• bgBlueBright
• bgMagentaBright
• bgCyanBright
• bgWhiteBright

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

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

const util = require('util');

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

  [util.inspect.custom](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);
    const inner = util.inspect(this.value, newOptions)
                      .replace(/\n/g, `\n${padding}`);
    return `${options.stylize('Box', 'special')}< ${inner} >`;
  }
}

const box = new Box(true);

util.inspect(box);
// Returns: "Box< true >"

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

const util = require('util');

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

util.inspect(obj);
// Returns: "{ bar: 'baz' }"

util.inspect.custom

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

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

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

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

  toString() {
    return 'xxxxxxxx';
  }

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

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

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

util.inspect.defaultOptions

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

const util = require('util');
const arr = Array(101).fill(0);

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

util.isDeepStrictEqual(val1, val2)

• val1 <любой>
• val2 <любой>
• Возвращает: <логическое>

Возвращает true , если между val1 и val2 существует глубокое строгое равенство. В противном случае возвращает false.

См. assert.deepStrictEqual() для получения дополнительной информации о глубоком строгом равенстве.

util.promisify(original)

• original <Функция>
• Возвращает: <Функция>

Принимает функцию, следующую общепринятому стилю обратного вызова с ошибкой в первую очередь, т. е. принимающую (err, value) => ... обратный вызов в качестве последнего аргумента, и возвращает версию, которая возвращает обещания.

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

Или, в эквивалентной форме, с использованием async function:

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

Если свойство original[util.promisify.custom] присутствует, promisify вернет его значение, см. Пользовательские функции promisify.

promisify() предполагает, что original в любом случае является функцией, принимающей обратный вызов в качестве последнего аргумента. Если original не является функцией, promisify() выдаст ошибку. Если original является функцией, но ее последний аргумент не является обратным вызовом с ошибкой в первую очередь, он все равно будет передан с обратным вызовом с ошибкой в первую очередь в качестве последнего аргумента.

Использование promisify() для методов класса или других методов, использующих this , может работать не так, как ожидается, если не обработано специальным образом:

const util = require('util');

class Foo {
  constructor() {
    this.a = 42;
  }

  bar(callback) {
    callback(null, this.a);
  }
}

const foo = new Foo();

const naiveBar = util.promisify(foo.bar);
// TypeError: Cannot read property 'a' of undefined
// 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'

Пользовательские функции promisify

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

const util = require('util');

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

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

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

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

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

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

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

util.promisify.custom

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

Помимо доступности через 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);
  });
};

Класс: util.TextDecoder

Реализация стандарта кодировок WHATWG WHATWG Encoding Standard TextDecoder API.

const decoder = new TextDecoder('shift_jis');
let string = '';
let buffer;
while (buffer = getNextChunkSomehow()) {
  string += decoder.decode(buffer, { stream: true });
}
string += decoder.decode(); // end-of-stream

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

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

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

Кодировки, поддерживаемые по умолчанию (с полными данными ICU)

Кодировки, поддерживаемые при сборке Node.js с опцией small-icu

Кодировки, поддерживаемые при отключенной ICU

Кодировка 'iso-8859-16', указанная в WHATWG Encoding Standard, не поддерживается.

new TextDecoder([encoding[, options]])

• encoding <строка> Определяет кодировку, которую поддерживает данный экземпляр TextDecoder. По умолчанию: 'utf-8'.
• options <Объект>
  • fatal <логическое значение> true если ошибки декодирования являются фатальными. Эта опция не поддерживается при отключенной ICU (см. Локализация). По умолчанию: false.
  • ignoreBOM <логическое значение> Если 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 если результат декодирования будет включать маркер порядка байтов.

Класс: util.TextEncoder

Реализация API стандарта кодирования WHATWG WHATWG Encoding Standard. Все экземпляры TextEncoder поддерживают только кодировку UTF-8.

const encoder = new TextEncoder();
const uint8array = encoder.encode('this is some data');

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

textEncoder.encode([input])

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

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

textEncoder.encodeInto(src, dest)

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

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

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

textEncoder.encoding

• <string>

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

util.types

util.types предоставляет проверки типов для различных встроенных объектов. В отличие от instanceof или Object.prototype.toString.call(value), эти проверки не проверяют свойства объекта, доступные из JavaScript (например, их прототип), и обычно имеют накладные расходы при вызове в C++.

Результат, как правило, не гарантирует, какие свойства или поведение значение предоставляет в JavaScript. Они в первую очередь полезны для разработчиков плагинов, которые предпочитают выполнять проверку типов в JavaScript.

util.types.isAnyArrayBuffer(value)

• value <любое>
• Возвращает: <логическое>

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

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

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

util.types.isArrayBufferView(value)

• value <любое>
• Возвращает: <логическое>

Возвращает 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

util.types.isArgumentsObject(value)

• value <любое>
• Возвращает: <логическое>

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

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

util.types.isArrayBuffer(value)

• value <любое>
• Возвращает: <логическое>

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

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

util.types.isAsyncFunction(value)

• value <любое>
• Возвращает: <логическое>

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

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

util.types.isBigInt64Array(value)

• value <любое>
• Возвращает: <логическое>

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

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

util.types.isBigUint64Array(value)

• value <любое>
• Возвращает: <логическое>

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

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

util.types.isBooleanObject(value)

• value <любое>
• Возвращает: <логическое>

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

util.types.isBoxedPrimitive(value)

• value <любое>
• Возвращает: <логическое>

Возвращает 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

util.types.isDataView(value)

• value <любое>
• Возвращает: <логическое>

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

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

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

util.types.isDate(value)

• value <любое>
• Возвращает: <логическое>

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

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

util.types.isExternal(value)

• value <любое>
• Возвращает: <логическое>

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

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

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

Дополнительную информацию об napi_create_external, см. napi_create_external().

util.types.isFloat32Array(value)

• value <любое>
• Возвращает: <логическое>

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

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

util.types.isFloat64Array(value)

• value <любое>
• Возвращает: <логическое>

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

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

util.types.isGeneratorFunction(value)

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

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

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

util.types.isGeneratorObject(value)

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

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

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

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

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

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

util.types.isMap(value)

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

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

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

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

util.types.isModuleNamespaceObject(value)

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

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

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

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

util.types.isNativeError(value)

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

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

util.types.isNativeError(new Error());  // Returns true
util.types.isNativeError(new TypeError());  // Returns true
util.types.isNativeError(new RangeError());  // Returns true

util.types.isNumberObject(value)

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

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

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

util.types.isPromise(value)

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

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

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

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

util.types.isRegExp(value)

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

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

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

util.types.isSet(value)

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

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

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

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

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

util.types.isStringObject(value)

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

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

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

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

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

См. также 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

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

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

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

util.types.isWeakMap(value)

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

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

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

util.types.isWeakSet(value)

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

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

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

util.types.isWebAssemblyCompiledModule(value)

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

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

const module = new WebAssembly.Module(wasmBuffer);
util.types.isWebAssemblyCompiledModule(module);  // Returns true

Устаревшие API

Следующие API устарели и больше не должны использоваться. Существующие приложения и модули должны быть обновлены, чтобы найти альтернативные подходы.

util._extend(target, source)

• target <Объект>
• source <Объект>

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

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

util.isArray(object)

• object <любой>
• Возвращает: <булево>

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

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

const util = require('util');

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

util.isBoolean(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('util');

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

util.isBuffer(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('util');

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

util.isDate(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('util');

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

util.isError(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('util');

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

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

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

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

util.isFunction(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('util');

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

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

util.isNull(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('util');

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

util.isNullOrUndefined(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('util');

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

util.isNumber(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('util');

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

util.isObject(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('util');

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

util.isPrimitive(object)

• object <любой>
• Возвращает: <булево>

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

const util = require('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

util.isRegExp(object)

• object <любой>
• Возвращает: <boolean>

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

const util = require('util');

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

util.isString(object)

• object <любой>
• Возвращает: <boolean>

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

const util = require('util');

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

util.isSymbol(object)

• object <любой>
• Возвращает: <boolean>

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

const util = require('util');

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

util.isUndefined(object)

• object <любой>
• Возвращает: <boolean>

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

const util = require('util');

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

util.log(string)

• string <строка>

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

const util = require('util');

util.log('Timestamped message.');