Утиліти Node.js у модулі util

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

const message = util.format(
  'Користувач %s має %d повідомлення',
  'Olena',
  5
);

console.log(message);
// Користувач Olena має 5 повідомлення

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

console.log(util.format('Статус:', 'готово', 200));
// Статус: готово 200

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

console.log(util.format({ name: 'Olena', active: true }));
// { name: 'Olena', active: true }

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

const user = {
  id: 42,
  name: 'Olena',
  settings: {
    theme: 'dark',
    notifications: true
  }
};

console.log(util.inspect(user, {
  depth: null,
  colors: false,
  compact: false
}));

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

console.log(util.types.isDate(new Date()));
// true

console.log(util.types.isRegExp(/node/i));
// true

console.log(util.types.isMap(new Map()));
// true

console.log(util.types.isSet(new Set()));
// true

console.log(util.types.isPromise(Promise.resolve()));
// true

console.log(util.types.isNativeError(new TypeError('Некоректне значення')));
// true

const value = [1, 2, 3];

console.log(Array.isArray(value));
console.log(typeof value === 'string');
console.log(value === null);

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

const values = [
  new ArrayBuffer(8),
  new Uint8Array(4),
  new Date(),
  new Map(),
  Promise.resolve(10)
];

for (const value of values) {
  console.log({
    isArrayBuffer: util.types.isArrayBuffer(value),
    isTypedArray: util.types.isTypedArray(value),
    isDate: util.types.isDate(value),
    isMap: util.types.isMap(value),
    isPromise: util.types.isPromise(value)
  });
}

util.isArray(value);
util.isDate(value);
util.isError(value);

Array.isArray(value);
util.types.isDate(value);
util.types.isNativeError(value);

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

function Logger(prefix) {
  EventEmitter.call(this);
  this.prefix = prefix;
}

util.inherits(Logger, EventEmitter);

Logger.prototype.write = function (message) {
  const fullMessage = `[${this.prefix}] ${message}`;

  console.log(fullMessage);
  this.emit('written', fullMessage);
};

const logger = new Logger('APP');

logger.on('written', (message) => {
  console.log('Подію отримано:', message);
});

logger.write('Сервер запущено');

const { EventEmitter } = require('node:events');

class Logger extends EventEmitter {
  constructor(prefix) {
    super();
    this.prefix = prefix;
  }

  write(message) {
    const fullMessage = `[${this.prefix}] ${message}`;

    console.log(fullMessage);
    this.emit('written', fullMessage);
  }
}

function operation(input, callback) {
  // callback отримує помилку або результат
  callback(error, result);
}

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

function getUser(id, callback) {
  setTimeout(() => {
    if (id <= 0) {
      callback(new Error('Ідентифікатор має бути додатним'));
      return;
    }

    callback(null, {
      id,
      name: 'Olena'
    });
  }, 100);
}

const getUserAsync = promisify(getUser);

async function main() {
  try {
    const user = await getUserAsync(42);
    console.log(user);
  } catch (error) {
    console.error('Помилка:', error.message);
  }
}

main();

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

const counter = {
  value: 10,

  getValue(callback) {
    callback(null, this.value);
  }
};

const getValueAsync = promisify(counter.getValue).bind(counter);

async function main() {
  console.log(await getValueAsync());
}

main();

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

async function loadSettings() {
  return {
    theme: 'dark',
    language: 'uk'
  };
}

const loadSettingsWithCallback = callbackify(loadSettings);

loadSettingsWithCallback((error, settings) => {
  if (error) {
    console.error('Помилка:', error.message);
    return;
  }

  console.log('Налаштування:', settings);
});

(error, value) => {}

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

async function loadData() {
  throw new Error('Не вдалося завантажити дані');
}

const loadDataWithCallback = callbackify(loadData);

loadDataWithCallback((error, data) => {
  if (error) {
    console.error(error.message);
    return;
  }

  console.log(data);
});

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

function Repository(name) {
  EventEmitter.call(this);
  this.name = name;
}

util.inherits(Repository, EventEmitter);

Repository.prototype.findById = function (id, callback) {
  setTimeout(() => {
    if (!Number.isInteger(id) || id <= 0) {
      callback(new TypeError('id має бути додатним цілим числом'));
      return;
    }

    const record = {
      id,
      name: 'Olena',
      createdAt: new Date()
    };

    this.emit('found', record);
    callback(null, record);
  }, 50);
};

const repository = new Repository('users');

repository.on('found', (record) => {
  console.log(util.format(
    'Знайдено запис #%d: %s',
    record.id,
    record.name
  ));

  console.log('createdAt є датою:', util.types.isDate(record.createdAt));
});

const findByIdAsync = util.promisify(
  repository.findById.bind(repository)
);

async function loadUser() {
  const user = await findByIdAsync(7);

  console.log(util.inspect(user, {
    depth: null,
    colors: false
  }));

  return user;
}

const loadUserWithCallback = util.callbackify(loadUser);

loadUserWithCallback((error, user) => {
  if (error) {
    console.error('Помилка:', error.message);
    return;
  }

  console.log('Завантаження завершено для:', user.name);
});

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

const promiseFunction = async () => 42;
const converted = promisify(promiseFunction);

const converted = promisify(object.method);

const converted = promisify(object.method.bind(object));

try {
  const result = await convertedFunction();
} catch (error) {
  console.error(error);
}