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 для получения списка кодов.
• Возвращает: <Функция> Обёрнутая устаревшая функция для вывода предупреждения.

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

const util = require('util');

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

При вызове util.deprecate() вернёт функцию, которая выведет предупреждение с помощью события '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.getSystemErrorMap()

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

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

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 <булево> Если true, неперечисляемые символы и свойства object включены в отформатированный результат. WeakMap и WeakSet записи также включены, а также пользовательские свойства прототипа (исключая свойства методов). По умолчанию: false.
  • depth <число> Указывает количество рекурсий при форматировании object. Это полезно для проверки больших объектов. Для рекурсии до максимального размера стека вызовов передайте Infinity или null. По умолчанию: 2.
  • colors <булево> Если true, вывод стилизован с помощью кодов ANSI-цветов. Цвета настраиваются. См. Настройка цветов util.inspect. По умолчанию: false.
  • customInspect <булево> Если false, функции [util.inspect.custom](depth, opts) не вызываются. По умолчанию: true.
  • showProxy <булево> Если true, проверка Proxy включает объекты target и handler. По умолчанию: false.
  • maxArrayLength <целое> Указывает максимальное количество Array, TypedArray, WeakMap и WeakSet элементов для включения при форматировании. Установите null или Infinity для отображения всех элементов. Установите 0 или отрицательное значение для отображения без элементов. По умолчанию: 100.
  • maxStringLength <целое> Указывает максимальное количество символов для включения при форматировании. Установите null или Infinity для отображения всех элементов. Установите 0 или отрицательное значение для отображения без символов. По умолчанию: 10000.
  • breakLength <целое> Длина, при которой входные значения разбиваются на несколько строк. Установите Infinity для форматирования входных данных в одну строку (в сочетании с compact установленным на true или любое число ≥ 1). По умолчанию: 80.
  • compact <булево> | <целое> Установка этого значения на false приводит к отображению каждого ключа объекта на новой строке. Разбивка на новые строки происходит для текста, длина которого превышает breakLength. Если установлено число, то наиболее n вложенные элементы объединяются на одной строке, при условии, что все свойства помещаются в breakLength. Короткие элементы массива также группируются вместе. Для получения дополнительной информации см. пример ниже. По умолчанию: 3.
  • sorted <булево> | <Функция> Если установлено на true или функцию, все свойства объекта и Set и Map записи сортируются в результирующей строке. Если установлено на true, используется сортировка по умолчанию. Если установлено на функцию, она используется как функция сравнения.
  • getters <булево> | <строка> Если установлено на 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,\nconsectetur adipiscing elit, sed do ' +
      'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
    'test',
    'foo']], 4],
  b: new Map([['za', 1], ['zb', 'test']])
};
console.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));

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

// Setting `compact` to false or an integer creates more reader friendly output.
console.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));

// {
//   a: [
//     1,
//     2,
//     [
//       [
//         'Lorem ipsum dolor sit amet,\n' +
//           'consectetur adipiscing elit, sed do eiusmod \n' +
//           'tempor incididunt ut labore et dolore magna aliqua.',
//         'test',
//         'foo'
//       ]
//     ],
//     4
//   ],
//   b: Map(2) {
//     'za' => 1,
//     'zb' => 'test'
//   }
// }

// Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
// single line.

Опция 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() предполагает, что 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.stripVTControlCharacters(str)

• str <строка>
• Возвращает: <строка>

Возвращает str с удалёнными кодами ANSI.

console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"

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

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

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

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

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

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

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

Реализация спецификации кодирования WHATWG Encoding Standard TextEncoder API. Все экземпляры 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.toUSVString(string)

• string <string>

Возвращает строку string после замены всех суррогатных кодовых точек (или, что эквивалентно, всех несвязанных суррогатных кодовых единиц) на символ замены Юникода U+FFFD.

util.types

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

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

Доступ к API осуществляется через require('util').types или require('util/types').

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.isCryptoKey(value)

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

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

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 они представляют собой замороженные объекты замороженные с прототипом 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 <любой>
• Returns: <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 <любой>
• Returns: <boolean>

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

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

util.types.isGeneratorObject(value)

• value <любой>
• Returns: <boolean>

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

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

util.types.isInt8Array(value)

• value <любой>
• Returns: <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 <любой>
• Returns: <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 <любой>
• Returns: <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.isKeyObject(value)

• value <Объект>
• Returns: <boolean>

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

util.types.isMap(value)

• value <любой>
• Returns: <boolean>

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

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

util.types.isMapIterator(value)

• value <любой>
• Returns: <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 <любой>
• Returns: <boolean>

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

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

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

util.types.isNativeError(value)

• value <любой>
• Returns: <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 <любой>
• Returns: <boolean>

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

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

util.types.isPromise(value)

• value <любой>
• Returns: <boolean>

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

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

util.types.isProxy(value)

• value <любой>
• Returns: <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 <любой>
• Returns: <boolean>

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

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

util.types.isSet(value)

• value <любой>
• Returns: <boolean>

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

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

util.types.isSetIterator(value)

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

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

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

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

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