10-dars

🧠 Stack va Heap nima?

JavaScript'da hamma narsa xotirada saqlanadi. Asosiy ikkita joy bor:

• Stack — tezkor, tartibli xotira
• Heap — katta, moslashuvchan xotira

Ularni tushunish:

• Primitive vs Reference farqini
• === xatti-harakati
• Memory leak va stack overflow

ni to'g'ri tushunishga yordam beradi.

---

1️⃣ Stack nima?

Stack — bu tezkor xotira joyi bo'lib, u yerda:

• Primitive qiymatlar: number, string, boolean, null, undefined, symbol, bigint
• Reference'lar: object/array/function'ga bo'lgan manzil (adres)
• Function chaqirilganda yaratiladigan execution context (call frame) ma'lumotlari

saqlanadi.

Stack LIFO bo'yicha ishlaydi

Stack — LIFO: Last In, First Out (oxiri kirgan — birinchi chiqadi).

function a() {
  b();
}

function b() {
  c();
}

function c() {}

a();

Call stack ketma-ketligi:

1. a() chaqiladi → stack: a
2. a() ichida b() chaqiladi → stack: a → b
3. b() ichida c() chaqiladi → stack: a → b → c
4. c tugaydi → stackdan chiqadi → qoladi a → b
5. b tugaydi → chiqadi → qoladi a
6. a tugaydi → stack bo'sh

✅ Stack juda tez, chunki:

• Tartibli
• Har doim faqat tepadan (oxiridan) qo'shadi va olib tashlaydi

---

2️⃣ Heap nima?

Heap — bu katta, moslashuvchan “ombor” xotira. U yerda:

• Object
• Array
• Function (object sifatida)
• class instance'lar
• Katta strukturali data

saqlanadi.

Heap'da joylashuv:

• Tartibli emas
• “Qayerdan bo'sh joy topsa, o'sha yerga” joylashtiriladi

✅ Heap:

• Katta, moslashuvchan

❌ Stack'dan sekinroq, chunki:

• Joy ajratish (allocation)
• Garbage Collector (GC) ishlashi

bor.

---

3️⃣ Primitive vs Reference — eng muhim farq

Primitive turlar — Stack'da (qiymat nusxalanadi)

let a = 5;
let b = a;

b = 10;

console.log(a); // 5
console.log(b); // 10

Nega a o'zgarmadi?

• a ning qiymati (5) stack'da turadi
• b = a bo'lganda — qiymat nusxalanadi
• b o'zgartirilsa — bu a ga ta'sir qilmaydi

Reference turlar — Heap + Stack (manzil nusxalanadi)

let obj1 = { x: 1 };
let obj2 = obj1;

obj2.x = 99;

console.log(obj1.x); // 99
console.log(obj2.x); // 99

Nega ikkalasi ham 99?

• { x: 1 } — Heap'da saqlanadi
• obj1 — Stack'da, ichida heap'dagi obyektga manzil (reference) bor
• obj2 = obj1 → reference nusxalanadi (bitta manzilga ishora qiladi)

Shuning uchun obj1 va obj2 bitta obyektni ko'rsatadi.

Buni chizma qilib tasavvur qilamiz

let user = { name: "Ali" };

Stack:

• user → manzil: 0xA12

Heap:

• 0xA12 → { name: "Ali" }

Stack'da obyektning o'zi yo'q — faqat adres (manzil) bor.

---

4️⃣ Nega bu farq juda muhim?

1) === reference'larda boshqacha ishlaydi

[] === []        // false
{} === {}        // false

Nega?

• Heap'da ikkita boshqa obyekt
• Demak ikkita boshqa adres

const a = [];
const b = a;

console.log(a === b); // true

Bu yerda:

• a va b bir xil manzilni ko'rsatadi
• Shuning uchun === true

2) Function ichidagi local variable'lar qayerda?

function test() {
  let n = 1;        // primitive → qiymat stack'da
  let arr = [1, 2]; // arr reference → stack, [1, 2] → heap
}

• Har bir function chaqirilganda yangi call frame stack'ga qo'shiladi
• Shu frame ichida local o'zgaruvchilar saqlanadi

---

5️⃣ Stack vs Heap — qisqa taqqoslash

Narsa	Stack	Heap
Saqlanadigan data	Primitive qiymatlar, reference adreslar, call frames	Object / Array / Function / katta strukturalar
Tezlik	Juda tez	Nisbatan sekinroq
Tartib	LIFO (tartibli)	Tartibsiz (allocation bo'yicha)
O'lcham	Kichikroq / limitli	Kattaroq
Tozalash	Funksiya tugaganda avtomatik chiqib ketadi	Garbage Collector orqali
Tipik xatolik	Stack overflow	Memory leak / GC bosimi

---

6️⃣ Stack overflow (chuqur recursion)

function f() {
  f();
}

f(); // RangeError: Maximum call stack size exceeded

Nega?

• Har chaqirilganda f uchun yangi call frame stack'ga qo'shiladi
• Stack cheksiz emas
• Ma'lum bir chuqurlikdan keyin "Maximum call stack size exceeded" xatosi chiqadi

Bu — stack overflow.

---

7️⃣ Memory leak (heap to'lib borishi)

Agar sen heap'dagi obyektlarga reference'ni ushlab tursang, Garbage Collector ularni o'chirolmaydi.

const globalArray = [];

function addData() {
  const bigData = new Array(1000000).fill("salom");
  globalArray.push(bigData);
}

setInterval(addData, 1000);

Bu kod:

• Har sekund yangi katta massiv yaratadi
• Uni globalArray ichiga qo'shadi
• Unga reference doim bor → GC o'chira olmaydi
• Xotira tobora ko'payib boradi → memory leak

✅ Memory leakdan qochish uchun:

• Kerak bo'lmagan reference'larni o'chirish
• Global state'ni keraksiz ko'paytirmaslik
• Uzoq yashaydigan obyektlarga ehtiyot bo'lish kerak

---

8️⃣ Amaliy misollar — Primitive vs Reference

Primitive — mustaqil nusxa

let x = 10;
let y = x;

y++;

console.log(x); // 10
console.log(y); // 11

Reference — bir obyekt, bir nechta reference

let user1 = { name: "Ali" };
let user2 = user1;

user2.name = "Vali";

console.log(user1.name); // "Vali"
console.log(user2.name); // "Vali"

Agar yangi obyekt kerak bo'lsa:

const user1 = { name: "Ali" };
const user2 = { ...user1 }; // shallow copy

user2.name = "Vali";

console.log(user1.name); // "Ali"
console.log(user2.name); // "Vali"

---

📝 Xulosa

• Stack — tezkor, tartibli, LIFO; primitive qiymatlar, reference adreslar va call frame'lar saqlanadi
• Heap — katta, moslashuvchan; object/array/function va katta strukturalar saqlanadi
• Primitive'lar nusxalanadi → o'zgarishlar boshqa o'zgaruvchilarga ta'sir qilmaydi
• Reference'larda adres nusxalanadi → bir obyektni bir nechta o'zgaruvchi ko'rsatishi mumkin
• [] === [] false, chunki manzillar boshqacha; bir xil reference bo'lsa — true
• Stack overflow — juda chuqur recursion yoki cheksiz call stack
• Memory leak — heap'dagi obyektlarga reference tushmay qolmaguncha GC o'chira olmaydi

Bu mavzuni yaxshi tushunsang, keyingi darslarda:

• Closure
• Scope
• Garbage Collection

ni tushunish osonroq bo'ladi.