# JavaScript prototip va meros zanjiri

> Prototip nima: __proto__ va prototype farqi, prototip zanjiri, Object.create hamda klasslar ortidagi mexanizm va xossa izlash tartibi tushuntirildi.

Manba: https://learncode.uz/javascript/prototip/
Sana: 2026-06-06

[Klasslar](https://learncode.uz/javascript/klasslar) darsida metodlar bir joyda saqlanishini
ko'rgan edik. Endi shu mexanizmning o'ziga qaraymiz — u JavaScript'ni boshqa
tillardan ajratib turadi.

## Xossa qayerdan topiladi

```js
const student = { name: "Aziz" };

console.log(student.name);
console.log(student.toString);
console.log(student.hasOwnProperty("name"));
```

`toString` va `hasOwnProperty` ni biz yozmadik, lekin ular bor. Chunki obyekt
xossani o'zida topa olmasa, **prototipiga** qaraydi.

> **Atama**
>
> **Prototip** — har bir obyekt bog'langan boshqa obyekt. Xossa yoki metod
> obyektning o'zida bo'lmasa, JavaScript uni prototipdan, keyin prototipning
> prototipidan izlaydi — bu **prototip zanjiri**.

## Zanjirni ko'rish

```js
const student = { name: "Aziz" };

const p1 = Object.getPrototypeOf(student);
console.log("1-level:", p1 === Object.prototype);

const p2 = Object.getPrototypeOf(p1);
console.log("2-level:", p2);

console.log("O'ziniki:", Object.keys(student));
```

Zanjir `null` bilan tugaydi — bu izlashning oxiri.

## Massivning zanjiri

```js
const arr = [1, 2, 3];

console.log(Object.getPrototypeOf(arr) === Array.prototype);
console.log(Object.getPrototypeOf(Array.prototype) === Object.prototype);

console.log(arr.map === Array.prototype.map);
```

`map` massivning o'zida emas — `Array.prototype` da. Barcha massivlar shu
bitta funksiyani baham ko'radi.

## Object.create — prototipni qo'lda belgilash

```js
const animal = {
  sound() {
    return this.name + " ovoz chiqardi";
  },
};

const dog = Object.create(animal);
dog.name = "Sherbek";

console.log(dog.sound());
console.log(Object.keys(dog));
console.log(Object.getPrototypeOf(dog) === animal);
```

`dog` da faqat `name` bor, `sound` esa prototipdan olindi.

## Prototipni o'zgartirish — zanjir jonli

```js
const base = { greet() { return "Salom"; } };
const obj = Object.create(base);

console.log(obj.greet());

base.bye = function () { return "Xayr"; };

console.log(obj.bye());
```

`bye` obyekt yaratilgandan **keyin** qo'shildi, lekin baribir ko'rindi —
zanjir nusxa emas, jonli bog'lanish.

## Xossa berish — zanjirga tegmaydi

```js
const base = { value: "asosdan" };
const obj = Object.create(base);

console.log(obj.value);

obj.value = "o'ziniki";

console.log(obj.value);
console.log(base.value);

delete obj.value;
console.log(obj.value);
```

O'zlashtirish har doim **obyektning o'zida** yangi xossa yaratadi. Prototipdagi
qiymat "to'siladi", lekin o'zgarmaydi — o'chirilganda yana ko'rinadi.

## O'ziniki yoki merosmi

```js
const base = { a: 1 };
const obj = Object.create(base);
obj.b = 2;

console.log("a bormi:", "a" in obj);
console.log("a o'zinikimi:", Object.hasOwn(obj, "a"));
console.log("b o'zinikimi:", Object.hasOwn(obj, "b"));

for (const key in obj) {
  console.log("for...in:", key);
}

console.log("Object.keys:", Object.keys(obj));
```

Farq muhim: `in` va `for...in` zanjirni ham ko'radi, `Object.keys` va
`Object.hasOwn` — faqat obyektning o'zini.

## Klass — prototip ustidagi qobiq

Klass yozuvi yangi mexanizm emas, mavjudining qulay shakli:

```js
class Student {
  constructor(name) {
    this.name = name;
  }
  greet() {
    return "Salom, " + this.name;
  }
}

const t = new Student("Aziz");

console.log(Object.keys(t));
console.log(Object.getPrototypeOf(t) === Student.prototype);
console.log(typeof Student.prototype.greet);
console.log(t.greet === Student.prototype.greet);
```

Ko'rinib turibdi: `name` obyektda, `greet` esa `Student.prototype` da.

## Konstruktor funksiya — eski uslub

Klasslardan oldin shunday yozilardi:

```js
function Student(name) {
  this.name = name;
}

Student.prototype.greet = function () {
  return "Salom, " + this.name;
};

const t = new Student("Aziz");
console.log(t.greet());
console.log(t instanceof Student);
```

Natija klass bilan bir xil. Eski kodni o'qishda bu shakl uchraydi.

> **prototype va __proto__ farqi**
>
> Ikki nomni chalkashtirmaslik kerak:
>
> - **`Funksiya.prototype`** — funksiyaning xossasi. `new` bilan yaratilgan
>   obyektlarga prototip sifatida **beriladi**;
> - **`obyekt.__proto__`** (yoki `Object.getPrototypeOf`) — obyektning
>   **haqiqiy** prototipi.
>
> Ya'ni: `t.__proto__ === Student.prototype`.

## Meros zanjiri

```js
class Person {
  breathe() { return "nafas olmoqda"; }
}

class Student extends Person {
  study() { return "o'qimoqda"; }
}

const t = new Student();

console.log(t.study());
console.log(t.breathe());

let level = Object.getPrototypeOf(t);
let n = 1;
while (level) {
  console.log(n + "-level:", level.constructor.name);
  level = Object.getPrototypeOf(level);
  n++;
}
```

Zanjir: `t` → `Student.prototype` → `Person.prototype` → `Object.prototype` →
`null`. [Meros](https://learncode.uz/javascript/meros) shu zanjirni quradi.

## Prototipsiz obyekt

```js
const clean = Object.create(null);
clean.name = "Aziz";

console.log(clean.name);
console.log(clean.toString);
console.log(Object.getPrototypeOf(clean));
```

Zanjirsiz obyekt — sof lug'at. Kalitlar `toString` kabi merosiy nomlar bilan
to'qnashmaydi.

## Amaliy mashq

1. Obyekt yaratib, `Object.getPrototypeOf` bilan zanjirni ko'ring;
2. `Object.create` bilan prototipli obyekt yasang;
3. prototipga metod qo'shib, mavjud obyektda ko'ringanini tasdiqlang;
4. prototipdagi xossani obyektda "to'sib", keyin `delete` qiling;
5. `in`, `Object.hasOwn` va `Object.keys` natijasini solishtiring;
6. klass yozib, metod `prototype` da ekanini tekshiring.

## Qisqacha xulosa

- Har obyekt **prototip** bilan bog'langan; xossa u yerdan izlanadi.
- Zanjir `null` bilan tugaydi.
- `Object.create(base)` prototipni qo'lda belgilaydi.
- O'zlashtirish doim obyektning o'zida yangi xossa yaratadi.
- `in`/`for...in` zanjirni ko'radi; `Object.keys`/`hasOwn` — faqat o'zini.
- **Klass** — prototip mexanizmi ustidagi qulay yozuv.

Keyingi darsda [event loop](https://learncode.uz/javascript/event-loop) — JavaScript navbat
tizimi.