Node.js tezligi va profil olish

“Dastur sekin ishlayapti” degan gapdan keyin odatda taxmin boshlanadi: sikl sekindir, funksiya og’irdir. Taxmin bo’yicha tuzatilgan kod esa ko’pincha hech narsani o’zgartirmaydi.

To’g’ri tartib boshqacha: avval o’lchang, keyin tuzating.

console.time — eng tez usul

Ikki qator bilan vaqtni o’lchash mumkin:

const fs = require("node:fs");

// Sinash uchun katta JSON yasaymiz
const items = Array.from({ length: 50000 }, (_, i) => ({
  id: i,
  name: "Element " + i,
}));
fs.writeFileSync("sample.json", JSON.stringify({ items }));

console.time("parse");
const data = JSON.parse(fs.readFileSync("sample.json", "utf8"));
console.timeEnd("parse");

console.log("Elementlar:", data.items.length);

node time-demo.js

parse: 19.642ms
Elementlar: 50000

console.time va console.timeEnd bir xil nom bilan chaqiriladi — shu nom orqali juftlashadi.

perf_hooks — aniqroq o’lchov

Natijani o’zgaruvchiga olish kerak bo’lsa, standart modul ishlatiladi:

const { performance } = require("node:perf_hooks");

function slowFibonacci(n) {
  if (n < 2) return n;
  return slowFibonacci(n - 1) + slowFibonacci(n - 2);
}

const start = performance.now();
const result = slowFibonacci(32);
const duration = performance.now() - start;

console.log("Natija:", result);
console.log("Ketgan vaqt (ms):", duration.toFixed(1));

node perf-demo.js

Natija: 2178309
Ketgan vaqt (ms): 31.4

Bu funksiya sekinligining sababi — takroriy hisob: slowFibonacci(30) bir necha marta qaytadan hisoblanadi.

Nima sekinlashtiradi

Node.js kodida uch sabab eng ko’p uchraydi.

Sinxron fayl amallari

fs darsida aytilgan ogohlantirish shu yerda raqamga aylanadi:

const fs = require("node:fs");
const { performance } = require("node:perf_hooks");

// Sinxron: har o'qish tugaguncha oqim band
const syncStart = performance.now();
for (let i = 0; i < 50; i++) {
  fs.readFileSync("sample.json", "utf8");
}
console.log("Sinxron (ms):", (performance.now() - syncStart).toFixed(1));

node sync-demo.js

Sinxron (ms): 402.7

Bu vaqt davomida dastur boshqa hech narsa qila olmaydi. Bitta foydalanuvchi uchun muammo emas, lekin serverda navbatdagi so’rovlar kutib turadi.

Katta JSON

JSON.parse va JSON.stringify sinxron ishlaydi. Yuqoridagi o’lchovda 50 000 elementli fayl uchun 19 ms ketdi — shu vaqt ichida oqim band.

Fayl kattalashsa vaqt ham o’sadi. Ma’lumot juda katta bo’lsa, oqimlar yoki baza ishlatiladi: bazada kerakli qatorni butun faylni o’qimasdan olish mumkin.

Keraksiz takroriy ish

Eng ko’p uchraydigan sabab — bir xil natijani qayta-qayta hisoblash.

Kesh — hisoblangan natijani saqlash

Map bu vazifa uchun qulay:

const { performance } = require("node:perf_hooks");

const cache = new Map();

function slowFibonacci(n) {
  if (n < 2) return n;
  return slowFibonacci(n - 1) + slowFibonacci(n - 2);
}

function cachedFibonacci(n) {
  if (cache.has(n)) {
    return cache.get(n);
  }
  const value = slowFibonacci(n);
  cache.set(n, value);
  return value;
}

const firstStart = performance.now();
cachedFibonacci(32);
const firstDuration = performance.now() - firstStart;

const secondStart = performance.now();
cachedFibonacci(32);
const secondDuration = performance.now() - secondStart;

console.log("Birinchi chaqiruv (ms):", firstDuration.toFixed(1));
console.log("Ikkinchi chaqiruv (ms):", secondDuration.toFixed(3));

node cache-demo.js

Birinchi chaqiruv (ms): 31.5
Ikkinchi chaqiruv (ms): 0.002

Ikkinchi chaqiruvda hisob umuman bajarilmadi — natija Map dan olindi.

Kesh cheksiz o'smasin

Yuqoridagi Map hech qachon tozalanmaydi. Har yangi qiymat xotirada qoladi va uzoq ishlaydigan serverda u to’xtovsiz o’sadi. Natijada xotira tugaydi.

Amalda ikki cheklov qo’yiladi: hajm (masalan, 1000 ta yozuvdan oshmasin) va muddat (eski yozuv o’chiriladi).

Eng sodda hajm cheklovi:

const MAX_CACHE_SIZE = 1000;

function addToCache(cache, key, value) {
  if (cache.size >= MAX_CACHE_SIZE) {
    // Eng eski kalitni o'chiramiz
    const oldestKey = cache.keys().next().value;
    cache.delete(oldestKey);
  }
  cache.set(key, value);
}

const cache = new Map();
addToCache(cache, "a", 1);
addToCache(cache, "b", 2);
console.log("Kesh hajmi:", cache.size);

Kesh hajmi: 2

–cpu-prof bilan profil olish

O’lchash kerakli joyni bilganda ishlaydi. Sekin joy qayerdaligi noma’lum bo’lsa, profil olinadi.

Sinov uchun bir nechta funksiyasi bor fayl yozamiz. profile-target.js:

function slowFibonacci(n) {
  if (n < 2) return n;
  return slowFibonacci(n - 1) + slowFibonacci(n - 2);
}

function buildText(count) {
  let text = "";
  for (let i = 0; i < count; i++) {
    text += "Qator " + i + "\n";
  }
  return text;
}

console.log("Fibonachchi:", slowFibonacci(30));
console.log("Matn uzunligi:", buildText(100000).length);

Profil bilan ishga tushiramiz:

node --cpu-prof profile-target.js

Fibonachchi: 832040
Matn uzunligi: 1188890

Papkada .cpuprofile bilan tugaydigan fayl paydo bo’ladi:

ls *.cpuprofile

CPU.20260912.162034.15208.0.001.cpuprofile

Uni ochish uchun Chrome DevTools ishlatiladi:

Chrome’da chrome://inspect sahifasini oching;
Open dedicated DevTools for Node havolasini bosing;
Performance yorlig’iga o’ting;
Yuklash tugmasi orqali .cpuprofile faylini tanlang.

Ochilgan jadvalda har funksiya qancha vaqt olgani ko’rinadi. Ro’yxat tepasidagi funksiya — birinchi navbatda qaraladigan joy.

DevTools bilan debug darsida ishlagansiz, oyna o’sha.

Xotirani o’lchash

Ba’zan muammo tezlikda emas, xotirada:

const before = process.memoryUsage().heapUsed;

const numbers = [];
for (let i = 0; i < 1000000; i++) {
  numbers.push(i);
}

const after = process.memoryUsage().heapUsed;

console.log("Elementlar:", numbers.length);
console.log("Xotira o'sishi (MB):", ((after - before) / 1024 / 1024).toFixed(1));

node memory-demo.js

Elementlar: 1000000
Xotira o'sishi (MB): 41.6

Bu usul oqimlar darsida ishlatilgan edi.

O’lchash tartibi

Amaliy ketma-ketlik:

Muammoni aniqlang — qaysi amal sekin;
O’lchang — console.time yoki performance.now();
Profil oling — sabab noma’lum bo’lsa --cpu-prof;
Bitta narsani o’zgartiring — bir vaqtda bittasini;
Qayta o’lchang — farq haqiqatan bormi;
Testlarni yuriting — testlar hali o’tyaptimi.

Amaliy mashq

node-start papkasida bajaring:

console.time bilan katta JSON faylini o’qish va tahlil qilish vaqtini o’lchang;
Xuddi shu o’lchovni uch marta takrorlab, natijalar farq qilishini ko’ring;
slowFibonacci ni performance.now() bilan o’lchab, n qiymatini oshirganda vaqt qanday o’sishini kuzating;
Map bilan kesh qo’shib, ikkinchi chaqiruv vaqtini solishtiring;
--cpu-prof bilan profil olib, faylni DevTools’da oching;
process.memoryUsage().heapUsed bilan katta massiv qancha xotira olishini o’lchang.

2-qadam eng muhimi: bitta o’lchovga tayanib xulosa chiqarish noto’g’ri qarorga olib keladi.

Qisqacha xulosa

Avval o’lchang, keyin tuzating — taxmin bo’yicha optimallashtirish vaqt yo’qotadi.
console.time tez o’lchov uchun, performance.now() natijani o’zgaruvchiga olish uchun.
Bitta o’lchov ishonchli emas: bir necha marta yuritib solishtiring.
Sinxron fayl amallari va katta JSON oqimni to’sadi.
Map bilan keshlash takroriy hisobni yo’q qiladi.
Kesh hajmi cheklanmasa xotira to’xtovsiz o’sadi.
--cpu-prof sekin funksiyani topadi, natija DevTools’da ochiladi.

Keyingi darsda yakuniy loyiha — baza, jurnal va testlarni bitta xizmatda birlashtirasiz.