Sertifikat olingYANGIW3Schools ilovasiiOS va AndroidSarguzashtni boshlang

Util moduli

ULASHISH

Util moduli nima?

Util moduli asosiy Node.js moduli bo‘lib, umumiy vazifalar uchun yordamchi funksiyalar to‘plamini taqdim etadi.

Bu Node.js ishlab chiquvchilari uchun Shveytsariya armiyasi pichog‘iga o‘xshab, quyidagilar uchun yechim taklif qiladi:

Umumiy foydalanish holatlari

  • To‘ldiruvchilar bilan stringlarni formatlash
  • Nosozliklarni tuzatish uchun obyektlarni tekshirish
  • Callback-lar va Promiselar o‘rtasida konvertatsiya qilish
  • Turni tekshirish va tekshirish
  • Eskirish haqida ogohlantirishlarni ko‘rib chiqish
  • Nosozliklarni tuzatish va jurnalga yozish

Asosiy afzalliklari

  • Tashqi bog‘liqliklar yo‘q
  • Ishlash uchun optimallashtirilgan yordamchi dasturlar
  • Node.js yadrosiga mos keladi
  • Nosozliklarni tuzatish va rivojlantirish uchun ajoyib
  • Ishlab chiqarish kodi uchun foydali

Eslatma: Util modulidagi ba’zi funksiyalar Node.js tomonidan ichki foydalanish uchun mo‘ljallangan bo‘lsa-da, ularning aksariyati Node.js ilovalarini yaratuvchi dasturchilar uchun qimmatli vositalardir.

Modul Node.js tarkibiga kiritilgan, shuning uchun o‘rnatish talab qilinmaydi.

Util bilan ishlashni boshlash

Util modulidan bir nechta yordamchi dasturlarni amalda ko‘rsatadigan amaliy misol:

Asosiy foydalanish misoli

const util = require('util');
const fs = require('fs');

// Convert callback-based fs.readFile to Promise-based
const readFile = util.promisify(fs.readFile);
// Format strings with placeholders
const greeting = util.format('Hello, %s! Today is %s', 'Developer', new Date().toDateString());
console.log(greeting);
// Inspect an object with custom options
const obj = {
  name: 'Test',
  nested: { a: 1, b: [2, 3] },
  fn: function() { return 'test'; }
};
console.log(util.inspect(obj, { colors: true, depth: 2 }));
// Use debug logging
const debug = util.debuglog('app');
debug('This will only show if NODE_DEBUG=app');
// Example of using promisify with async/await
async function readConfig() {
  try {
    const data = await readFile('package.json', 'utf8');
    console.log('Package name:', JSON.parse(data).name);
  } catch (err) {
    console.error('Error reading config:', err);
  }
}
readConfig();
Misolni ishga tushirish »

Import va sozlash

Util moduli modul tizimi va ehtiyojlariga qarab bir necha usul bilan import qilinishi mumkin:

CommonJS (Node.js’da standart)

// Import the entire module
const util = require('util');

// Import specific functions using destructuring
const { promisify, inspect, format } = require('util');

// Using strict mode (recommended)
const assert = require('assert').strict;

// For TypeScript users
// import * as util from 'util';
// import { promisify, inspect } from 'util';

ES modullari (Node.js 12+)

// Default import
import util from 'util';

// Named imports
import { promisify, inspect } from 'util';

// Rename imports
import { promisify as pify } from 'util';

// Dynamic import (Node.js 14+)
const { promisify } = await import('util');

// Using with TypeScript types
// import * as util from 'util';
// import type { InspectOptions } from 'util';

Eng yaxshi amaliyot: Daraxtlarni yaxshiroq silkitish va kichikroq to‘plamlar uchun faqat kerakli funksiyalarni import qilishni afzal ko‘ring.

Util moduli juda katta va siz odatda uning funksiyalarining kichik bir qismidan foydalanasiz.

String formatlash va tekshirish

Util moduli stringlarni formatlash va obyektlarni tekshirish uchun kuchli vositalarni taqdim etadi, ular ayniqsa jurnalga yozish va debug uchun foydalidir.

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

Birinchi argumentni printfga o‘xshash format stringi sifatida ishlatib, formatlangan stringni qaytaradi.

Bu console.log() ga o‘xshaydi, lekin uni chop etish o‘rniga formatlangan stringni qaytaradi.

Format ko‘rsatkichlari:

  • %s - String
  • %d - Number (both integer and float)
  • %i - butun son
  • %f - suzuvchi nuqta qiymati
  • %j - JSON (agar argumentda aylanma havolalar bo‘lsa, '[Circular]' bilan almashtiriladi)
  • %o - Object (inspect the object)
  • %O - Object (obyektni barcha tafsilotlari bilan ko‘rib chiqish)
  • %% - Yagona foiz belgisi ('%')
const util = require('util');

// Basic formatting
const formatted = util.format('Hello, %s!', 'World');
console.log(formatted); // 'Hello, World!'

// Multiple placeholders
const multiFormatted = util.format(
  'My name is %s. I am %d years old and I love %s.',
  'Kai',
  30,
  'Node.js'
);
console.log(multiFormatted);
// 'My name is Kai. I am 30 years old and I love Node.js.'

// Available specifiers
const specifiers = util.format(
  'String: %s, Number: %d, JSON: %j, Character: %c',
  'hello',
  42,
  { name: 'Object' },
  65  // ASCII code for 'A'
);
console.log(specifiers);

// Extra arguments are concatenated with spaces
const extra = util.format('Hello', 'World', 'from', 'Node.js');
console.log(extra); // 'Hello World from Node.js'
O‘zingiz sinab ko‘ring »

util.inspect(object[, options])

Nosozliklarni tuzatish uchun foydali bo‘lgan obyektning string tasvirini qaytaradi.

Bu Node.js obyektlarni konsolga chop etish uchun ichki foydalanadi.

Umumiy foydalanish holatlari:

  • Murakkab obyektlarni debug qilish
  • Inson tomonidan o‘qiladigan obyektlar tasvirlarini yaratish
  • Obyektlarni dumaloq havolalar bilan jurnalga olish
  • Jurnallarda obyektni ko‘rsatishni sozlash

Umumiy variantlar:

  • showHidden - sanab bo‘lmaydigan xususiyatlarni ko‘rsatish (standart: noto‘g‘ri)
  • depth - Qaytariladigan darajalar soni (standart: 2, cheksiz uchun null)
  • colors - ANSI rang kodlarini qo‘shing (standart: noto‘g‘ri)
  • customInspect - Maxsus tekshirish funksiyalaridan foydalaning (standart: rost)
  • showProxy - Proksi-server ma’lumotlarini ko‘rsatish (standart: noto‘g‘ri)
  • maxArrayLength - Massiv elementlarining maksimal soni (standart: 100)
  • breakLength - Obyekt kalitlarini sindirish uzunligi (standart: 60)
  • compact - Xususiyatlarni yangi satrlarga ajratish (standart: massivlar uchun true, obyektlar uchun false)
  • sorted - Saralash xususiyatlari (standart: noto‘g‘ri, alifbo bo‘yicha rost, maxsus tartiblash funksiyasi)
const util = require('util');

// Basic usage
const obj = {
  name: 'John',
  age: 30,
  hobbies: ['reading', 'coding'],
  address: {
    city: 'New York',
    country: 'USA'
  },
  toString() {
    return `${this.name}, ${this.age}`;
  }
};

// Default inspection
console.log(util.inspect(obj));

// Custom options
console.log(util.inspect(obj, {
  colors: true, // Add ANSI color codes
  depth: 0, // Only inspect the first level
  showHidden: true, // Show non-enumerable properties
  compact: false, // Don't format objects on a single line
  showProxy: true, // Show proxy details
  maxArrayLength: 3, // Limit array elements displayed
  breakLength: 50, // Line break after 50 characters
  sorted: true // Sort object properties alphabetically
}));

// Circular references
const circular = { name: 'Circular' };
circular.self = circular;
console.log(util.inspect(circular));
O‘zingiz sinab ko‘ring »

util.inspect.custom

Obyektni tekshirishni sozlash uchun ishlatiladigan belgi.

Bu tekshirilganda obyektlarga o‘z string tasvirini aniqlash imkonini beradi.

Eng yaxshi amaliyotlar:

  • Yaxshiroq moslik uchun inspect() usulidan ko‘ra, maxsus tekshirish uchun util.inspect.custom dan foydalaning
  • Maxsus tekshiruv natijalarini qisqa va informatsion saqlang
  • Chiqishda muhim obyekt holatini qo‘shing
  • Tez-tez tekshiriladigan obyektlarning ishlashini ko‘rib chiqing
  • Cheksiz rekursiyani oldini olish uchun dumaloq havolalarni ishlating
const util = require('util');

// Class with custom inspection
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
    this._private = 'hidden information';
  }
  
  // Custom inspect method
  [util.inspect.custom](depth, options) {
    return `Person(${this.name}, ${this.age})`;
  }
}
const kai = new Person('Kai', 30);

// Custom inspection is used
console.log(util.inspect(kai)); // Person(Kai, 30)

// Directly using console.log also uses custom inspection
console.log(kai); // Person(Kai, 30)
O‘zingiz sinab ko‘ring »

Promises va Async Utilities

Node.js ning Util moduli asinxron kod bilan ishlash uchun bir nechta yordamchi dasturlarni taqdim etadi, bu ham callback funksiyasiqa asoslangan, ham Promise-ga asoslangan API bilan ishlashni osonlashtiradi.

util.promisify(original)

Node.js callback funksiyasi naqshidan keyin callback funksiyasiqa asoslangan funksiyani Promise-ni qaytaruvchi funksiyaga aylantiradi.

Bu callback funksiyasilardan foydalanadigan eski Node.js API bilan ishlash uchun foydalidir.

util.promisify qachon foydalanish kerak:

  • Callback-lardan foydalanadigan eski Node.js API bilan ishlash
  • Callback-ga asoslangan kutubxonalarni Promises’dan foydalanishga aylantirish
  • Callback-larni olib tashlash orqali async/await kodini soddalashtirish
  • Node.js callback pattern’iga (avval xato, yagona natija) amal qiladigan funksiyalar bilan ishlash

Cheklovlar:

  • Faqat Node.js callback funksiyasi qilish sxemasiga amal qiluvchi funksiyalar bilan ishlaydi: (err, value) => {}
  • callback-da bir nechta qiymatlarni qaytaradigan funksiyalar bilan ishlamaydi
  • Murakkab API-lar uchun maxsus Promise talab qilinishi mumkin
const util = require('util');
const fs = require('fs');

// Convert fs.readFile from callback-based to Promise-based
const readFilePromise = util.promisify(fs.readFile);

// Now we can use it with async/await or Promise chaining
async function readFileExample() {
  try {
    // Using the promisified function
    const data = await readFilePromise('package.json', 'utf8');
    console.log('File content:', data.substring(0, 100) + '...');
    
    // Error handling with try/catch
    return 'File read successfully';
  } catch (err) {
    console.error('Error reading file:', err.message);
    return 'Error reading file';
  }
}

readFileExample().then(result => {
  console.log('Result:', result);
});
Misolni ishga tushirish »

util.callbackify(original)

Promise-ni qaytaruvchi funksiyani Node.js callback funksiyasi naqshiga amal qiladigan funksiyaga aylantiradi.

Bu callback funksiyasi qilish funksiyalarini kutadigan eski Node.js API bilan ishlash uchun foydalidir.

util.callbackify qachon foydalanish kerak:

  • Promise-ga asoslangan kodni callback funksiyasiqa asoslangan API bilan integratsiyalash
  • Kutubxonalarda orqaga qarab muvofiqlikni saqlash
  • Node.js uslubidagi callback funksiyasilarni kutadigan API bilan ishlash
  • Asta-sekin callback funksiyasilardan Promiselarga o‘tish

Eng yaxshi amaliyotlar:

  • Iloji bo‘lsa, to‘g‘ridan-to‘g‘ri Promiselardan foydalanishni afzal ko‘ring
  • Funksiya o‘zining JSDoc-da callback funksiyasilardan foydalanishi haqidagi hujjat
  • API-larda Promise va callback funksiyasi interfeyslarini taqdim etishni o‘ylab ko‘ring
  • callback-da Promiselarni rad etishni to‘g‘ri bajaring
const util = require('util');

// A Promise-based function
async function fetchUserData(id) {
  if (!id) {
    throw new Error('ID is required');
  }
  
  // Simulate API request
  return {
    id,
    name: `User ${id}`,
    email: `user${id}@example.com`
  };
}

// Convert to callback-based
const fetchUserDataCallback = util.callbackify(fetchUserData);

// Using the callback-based function
fetchUserDataCallback(1, (err, user) => {
  if (err) {
    console.error('Error:', err);
    return;
  }
  
  console.log('User data:', user);
});

// Error handling
fetchUserDataCallback(null, (err, user) => {
  if (err) {
    console.error('Error occurred:', err.message);
    return;
  }
  
  console.log('User data:', user); // This won't execute
});
Misolni ishga tushirish »

util.promisify.custom

Promise berish xatti-harakatini sozlash uchun belgi. Bu sizga funksiya Promise qilinganda maxsus dasturni taqdim etish imkonini beradi.

Maxsus Promiselar uchun holatlardan foydalaning:

  • Standart callback funksiyasi qilish tartibiga amal qilmaydigan funksiyalar
  • callback-da bir nechta qiymatlarni qaytaradigan API
  • Maxsus xatolarni qayta ishlash yoki natijalarni o‘zgartirish
  • Muayyan foydalanish holatlari uchun ishlashni optimallashtirish
  • Promise berish paytida qo‘shimcha funksiyalarni qo‘shish
const util = require('util');

// Function with custom promisification
function doSomething(options, callback) {
  callback(null, 'regular result');
}

// Define custom promisification
doSomething[util.promisify.custom] = (options) => {
  return Promise.resolve('custom promisified result');
};

// Use the custom promisification
const promisified = util.promisify(doSomething);

// Compare the results
async function compareResults() {
  // Original function with callback
  doSomething({}, (err, result) => {
    console.log('Callback result:', result);
  });

  // Custom promisified function
  const customResult = await promisified({});
  console.log('Promisified result:', customResult);
}

compareResults();
Misolni ishga tushirish »

Utilitalarni tekshirish

Util moduli JavaScript-ning typeof operatoriga qaraganda ishonchliroq turlarni tekshirish uchun keng qamrovli yordamchi dasturlarni taqdim etadi, ayniqsa o‘rnatilgan obyektlar va Node.js-ga xos turlar uchun.

Nega util.types dan foydalaniladi?

  • Ko‘p o‘rnatilgan turlar uchun typeof dan aniqroq
  • Node.js versiyalarida izchil harakat
  • Buffer kabi Node.js-ga xos turlar bilan ishlaydi
  • Ko‘p hollarda qo‘lda tekshirishdan ko‘ra yaxshiroq ishlash
  • Handles edge cases properly (e.g., cross-realm objects)
const util = require('util');

// Example values
const values = [
  'string',
  123,
  true,
  Symbol('symbol'),
  { key: 'value' },
  [1, 2, 3],
  null,
  undefined,
  () => {},
  BigInt(123),
  new Date(),
  /regex/,
  Buffer.from('buffer'),
  new Error('error')
];

// Check types for each value
values.forEach(value => {
  console.log(`Value: ${util.inspect(value)}`);
  console.log(`- isArray: ${util.types.isArrayBuffer(value)}`);
  console.log(`- isDate: ${util.types.isDate(value)}`);
  console.log(`- isRegExp: ${util.types.isRegExp(value)}`);
  console.log(`- isNativeError: ${util.types.isNativeError(value)}`);
  console.log(`- isPromise: ${util.types.isPromise(value)}`);
  console.log(`- isPrimitive: ${util.isPrimitive(value)}`);
  console.log(`- isString: ${util.isString(value)}`);
  console.log(`- isNumber: ${util.isNumber(value)}`);
  console.log(`- isBoolean: ${util.isBoolean(value)}`);
  console.log(`- isSymbol: ${util.types.isSymbol(value)}`);
  console.log(`- isNull: ${value === null}`);
  console.log(`- isUndefined: ${value === undefined}`);
  console.log(`- isFunction: ${util.types.isFunction(value)}`);
  console.log(`- isBuffer: ${Buffer.isBuffer(value)}`);
  console.log('---');
});
Misolni ishga tushirish »

util-dagi ko‘plab turdagi tekshirish funksiyalari util.types yoki JavaScript-ning Array.isArray() kabi o‘rnatilgan turini tekshirish usullari foydasiga eskirgan.

util.types

util.types turli xil JavaScript turlari va Node.js-ga xos obyektlar uchun turdagi tekshirish funksiyalarini taqdim etadi:

const util = require('util');

// JavaScript built-in types
console.log('util.types.isDate(new Date()):',
  util.types.isDate(new Date()));
console.log('util.types.isRegExp(/test/):',
  util.types.isRegExp(/test/));
console.log('util.types.isPromise(Promise.resolve()):',
  util.types.isPromise(Promise.resolve()));

// Node.js-specific types
console.log('util.types.isArrayBuffer(new ArrayBuffer(0)):',
  util.types.isArrayBuffer(new ArrayBuffer(0)));
console.log('util.types.isSharedArrayBuffer(new SharedArrayBuffer(0)):',
  util.types.isSharedArrayBuffer(new SharedArrayBuffer(0)));
console.log('util.types.isUint8Array(new Uint8Array()):',
  util.types.isUint8Array(new Uint8Array()));

// More advanced types
console.log('util.types.isProxy(new Proxy({}, {})):',
  util.types.isProxy(new Proxy({}, {})));
console.log('util.types.isExternal(Requiring C++ binding):',
  'Not demonstrated in this example');
Misolni ishga tushirish »

Eskirish uchun yordamchi dasturlar

Node.js API eskirishlarini boshqarishga yordam beradigan yordamchi dasturlarni taqdim etadi, bu esa orqaga qarab muvofiqlikni saqlab, kod bazasini rivojlantirishni osonlashtiradi.

Depretsiya strategiyasi:

  1. Eskirgan funksiyalarni util.deprecate() bilan belgilang
  2. Eskirish xabarida migratsiya bo‘yicha aniq ko‘rsatmalar bering
  3. Kuzatuvni osonlashtirish uchun eskirish kodini kiriting
  4. API hujjatlarida eskirishni hujjatlashtiring
  5. Kelajakdagi asosiy versiyada eskirgan funksiyalarni olib tashlang

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

Funksiyani eskirgan deb belgilaydi va chaqirilganda ogohlantirish beradi.

const util = require('util');

// Original function
function oldFunction(x, y) {
  return x + y;
}

// Deprecate the function
const deprecatedFunction = util.deprecate(
  oldFunction,
  'oldFunction() is deprecated. Use newFunction() instead.',
  'DEP0001'
);

// New function
function newFunction(x, y) {
  return x + y;
}

// Using the deprecated function will show a warning
console.log('Result:', deprecatedFunction(5, 10));

// Using the new function
console.log('Result:', newFunction(5, 10));
Misolni ishga tushirish »

Eskirish haqida ogohlantirishlarni boshqarish

Muhit o‘zgaruvchilari yordamida eskirish haqida ogohlantirishlar ko‘rinishini boshqarishingiz mumkin:

# Show all deprecation warnings
NODE_OPTIONS='--trace-deprecation'

# Show only the first occurrence of each deprecation
NODE_OPTIONS='--no-deprecation'

# Silence all deprecation warnings
NODE_OPTIONS='--no-warnings'

# Turn deprecation warnings into exceptions
NODE_OPTIONS='--throw-deprecation'

Nosozliklarni tuzatish va ishlab chiqish uchun yordamchi dasturlar

Node.js nosozliklarni tuzatish va ishlab chiqishda yordam beradigan bir nechta yordamchi dasturlarni taqdim etadi, bu muammolarni tashxislashni va dastur xatti-harakatlarini tushunishni osonlashtiradi.

util.debuglog(section)

NODE_DEBUG muhit o‘zgaruvchisi asosida stderr ga debug xabarlarini shartli ravishda yozadigan funksiya yaratadi.

Bu to‘liq xususiyatli jurnallar kutubxonalariga yengil muqobildir.

Nosozliklarni tuzatish jurnali uchun eng yaxshi amaliyotlar:

  • Ilovangiz modullariga mos keladigan tavsiflovchi bo‘lim nomlaridan foydalaning
  • Nosozliklarni tuzatish xabarlariga tegishli kontekstni qo‘shing
  • Yaxshiroq ishlash uchun string to‘ldiruvchilardan foydalaning
  • Nosozliklarni tuzatish xabarlarini ixcham, ammo ma’lumotli saqlang
  • Nosozliklarni tuzatish xabarlari uchun hisoblash qiymatlarining ishlash ta’sirini ko‘rib chiqing

Qo‘llash misoli:

// Enable debug logging for specific modules
// NODE_DEBUG=app,db node your-app.js

// In your application
const debugApp = util.debuglog('app');
const debugDB = util.debuglog('db');

// These will only log when 'app' is in NODE_DEBUG
debugApp('Application started with config: %j', config);

// These will only log when 'db' is in NODE_DEBUG
debugDB('Connected to database: %s', connectionString);

// Enable all debug logs (not recommended in production)
// NODE_DEBUG=* node your-app.js
const util = require('util');

// Create debug loggers for different sections
const debugApp = util.debuglog('app');
const debugDB = util.debuglog('db');
const debugAuth = util.debuglog('auth');

// These messages only appear when NODE_DEBUG includes 'app'
debugApp('Application starting...');
debugApp('Configuration loaded from %j', { source: 'config.json' });

// These messages only appear when NODE_DEBUG includes 'db'
debugDB('Connected to database');
debugDB('Query executed: %s', 'SELECT * FROM users');

// These messages only appear when NODE_DEBUG includes 'auth'
debugAuth('User authenticated: %s', 'john.doe');

// To see these messages, run your app with:
// NODE_DEBUG=app,db node your-app.js
console.log('Application running normally (this always shows)');
‹ OrqagaKeyingisi

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tishKirish