Util

Исходный код: lib/util.js

Модуль util поддерживает потребности внутренних API Node.js. Многие утилиты также полезны для разработчиков приложений и модулей. Для доступа к нему:

const util = require('util');

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

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

• fn <Функция> Функция, которая устаревает.
• msg <строка> Сообщение об предупреждении, которое отображается при вызове устаревшей функции.
• code <строка> Код устаревания. См. список устаревших 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 <число>
• Возвращает: <строка>

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

fs.access('file/that/does/not/exist', (err) => {
  const name = util.getSystemErrorName(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 <any> Любой примитив JavaScript или Object.
• options <Object>
  • showHidden <boolean> Если true, неперечисляемые символы и свойства object включены в отформатированный результат. WeakMap и WeakSet записи также включены, а также пользовательские свойства прототипов (исключая свойства методов). По умолчанию: false.
  • depth <number> Указывает количество рекурсий при форматировании 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 <integer> Указывает максимальное количество Array, TypedArray, WeakMap и WeakSet элементов для включения при форматировании. Установите null или Infinity, чтобы отобразить все элементы. Установите 0 или отрицательное значение, чтобы не отображать элементы. По умолчанию: 100.
  • maxStringLength <integer> Указывает максимальное количество символов для включения при форматировании. Установите null или Infinity, чтобы отобразить все элементы. Установите 0 или отрицательное значение, чтобы не отображать символы. По умолчанию: Infinity.
  • breakLength <integer> Длина, при которой входные значения разбиваются на несколько строк. Установите Infinity для форматирования входных данных в одну строку (в сочетании с compact установленным на true или любое число ≥ 1). По умолчанию: 80.
  • compact <boolean> | <integer> Установка этого значения в false приводит к отображению каждого ключа объекта на новой строке. Также будут добавлены новые строки для текста, длина которого превышает breakLength. Если задано число, то самые n внутренние элементы объединяются в одну строку, если все свойства помещаются в breakLength. Короткие элементы массива также группируются. Текст не будет сокращен ниже 16 символов, независимо от размера breakLength. Дополнительная информация представлена в примере ниже. По умолчанию: 3.
  • sorted <boolean> | <Function> Если установлено значение true или функция, все свойства объекта, и Set и Map записи сортируются в результирующей строке. Если установлено значение true, используется стандартная сортировка. Если задана функция, она используется как функция сравнения.
  • getters <boolean> | <string> Если установлено значение true, проверяются геттеры. Если установлено значение 'get', проверяются только геттеры без соответствующего сеттера. Если установлено значение 'set', проверяются только геттеры с соответствующим сеттером. Это может вызвать побочные эффекты в зависимости от функции геттера. По умолчанию: false.
• Возвращает: <string> Представление 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] {}'

Циклические ссылки отображаются как '[Circular]':

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

const obj = {};
obj.a = [obj];
obj.b = {};
obj.b.inner = obj.b;
obj.b.obj = obj;

console.log(inspect(obj));
// {
//   a: [ [Circular] ],
//   b: { inner: [Circular], obj: [Circular] }
// }

Следующий пример проверяет все свойства объекта 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 { '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 {
//     '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 { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set { 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().

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() предполагает, что 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'

Настраиваемые функции, преобразованные в обещания

Используя символ 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

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

Помимо доступности через 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 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, кодировки, поддерживаемые API TextDecoder , показаны в таблицах ниже. Для каждой кодировки может быть использовано одно или несколько псевдонимов.

Различные конфигурации сборки Node.js поддерживают различные наборы кодировок. Хотя базовый набор кодировок поддерживается даже в сборках Node.js без включенного ICU, поддержка некоторых кодировок предоставляется только при компиляции Node.js с ICU и использованием полных данных ICU (см. Международные настройки).

Кодировки, поддерживаемые без ICU

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

Кодировки, требующие полных данных ICU

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

new TextDecoder([encoding[, options]])

• encoding <строка> Определяет 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 <Объект>
  • stream <логическое значение> true если ожидаются дополнительные фрагменты данных. По умолчанию: false.
• Возвращает: <строка>

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

Если textDecoder.fatal равно true, ошибки декодирования приведут к сбросу TypeError.

textDecoder.encoding

• <строка>

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

textDecoder.fatal

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

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

textDecoder.ignoreBOM

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

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

Класс: util.TextEncoder

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

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

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

textEncoder.encode([input])

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

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

textEncoder.encodeInto(src, dest)

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

Кодирует строку src в формате UTF-8 в массив 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 <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

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

util.types.isArgumentsObject(value)

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

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

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

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

util.types.isAsyncFunction(value)

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

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

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

util.types.isBigInt64Array(value)

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

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

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

util.types.isBigUint64Array(value)

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

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

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

util.types.isBooleanObject(value)

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

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

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

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

util.types.isDate(value)

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

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

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

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

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

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

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 если значение является экземпляром Модульного пространства имён.

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 , если значение является объектом типа symbol, созданным путём вызова 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 <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('util');

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

util.isBoolean(object)

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

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

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

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

Возвращает 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 <любой>
• Возвращает: <boolean>

Возвращает 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 <любой>
• Возвращает: <boolean>

Возвращает 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 <любой>
• Возвращает: <boolean>

Возвращает 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 <любой>
• Возвращает: <boolean>

Возвращает 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 <любой>
• Возвращает: <boolean>

Возвращает 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 <любой>
• Возвращает: <boolean>

Возвращает 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 является RegExp. В противном случае возвращает 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 является string. В противном случае возвращает 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.');