# JavaScript JSON formati (stringify, parse)

> JSON nima: format qoidalari, JSON.stringify va JSON.parse, obyektdan farqi, chiroyli formatlash va keng uchraydigan xatolar. Amaliy misollar bilan.

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

[fetch](https://learncode.uz/javascript/fetch) darsida server javobini `json()` bilan o'qidik.
Endi shu formatning o'ziga qaraymiz: u dasturlar orasida ma'lumot almashishning
eng keng tarqalgan usuli.

## JSON nima

> **Atama**
>
> **JSON** (JavaScript Object Notation) — ma'lumotni **matn** ko'rinishida
> yozish formati. Tarmoq orqali faqat matn uzatiladi, shuning uchun obyekt
> yuborishdan oldin JSON matniga o'giriladi va qabul qilinganda qayta obyektga
> aylantiriladi.

Ko'rinishi JavaScript obyektiga o'xshaydi, lekin bu **matn**:

```json
{
  "ism": "Aziz",
  "yosh": 20,
  "faol": true,
  "guruhlar": ["IT-21", "Web"],
  "manzil": { "shahar": "Toshkent" },
  "telefon": null
}
```

## stringify — obyektdan matnga

```js
const student = {
  name: "Aziz",
  age: 20,
  isActive: true,
};

const text = JSON.stringify(student);

console.log(text);
console.log(typeof text);
console.log(text.length);
```

Natija — bitta qatorli matn. `typeof` buni tasdiqlaydi: endi bu obyekt emas,
`string`.

## parse — matndan obyektga

```js
const text = '{"name":"Aziz","age":20,"isActive":true}';

const student = JSON.parse(text);

console.log(student);
console.log(student.name);
console.log(student.age + 5);
```

Qayta obyektga aylandi — endi xossalarga murojaat qilish va son bilan
amal bajarish mumkin.

## Chiroyli formatlash

Uchinchi argument — chekinish:

```js
const student = {
  name: "Aziz",
  guruhlar: ["IT-21", "Web"],
  address: { city: "Toshkent", tuman: "Chilonzor" },
};

console.log(JSON.stringify(student));

console.log(JSON.stringify(student, null, 2));
```

`2` — ikki probel chekinish. Fayl saqlash yoki xatolarni ko'rishda qulay;
tarmoqqa yuborishda esa qisqa shakl ishlatiladi.

## JSON qoidalari — obyektdan farqi

JSON JavaScript obyektidan **qattiqroq**:

```js
const wrong = "{name: 'Aziz'}";

try {
  JSON.parse(wrong);
} catch (error) {
  console.log("Xato:", error.message);
}

const correct = '{"name": "Aziz"}';
console.log(JSON.parse(correct));
```

Qoidalar:

- Kalitlar **har doim** qo'shtirnoq ichida: `"name"`, `name` emas;
- matnlar faqat **qo'shtirnoq**, bitta tirnoq emas;
- oxirgi elementdan keyin vergul qo'yilmaydi;
- izoh yozib bo'lmaydi.

## Nima yo'qoladi

Hamma qiymat ham JSON'ga sig'maydi:

```js
const obj = {
  text: "present",
  num: 42,
  aniqmas: undefined,
  funksiya: () => "salom",
  date: new Date("2026-01-15"),
  infinite: Infinity,
};

console.log(JSON.stringify(obj, null, 2));
```

Natijada:

- `undefined` va funksiyalar **butunlay tushib qoladi**;
- `Date` matnga aylanadi — `parse` dan keyin `Date` emas, `string` bo'ladi;
- `Infinity` va `NaN` → `null`.

<Callout type="warning" title="Sana bilan ehtiyot">
`JSON.parse` sanani avtomatik tiklamaydi:

```js
const m = JSON.parse('{"date":"2026-01-15T00:00:00.000Z"}');
console.log(typeof m.date);          // "string"
const date = new Date(m.date);       // qo'lda tiklash kerak
```
</Callout>

## Chuqur nusxa olish

[Spread](https://learncode.uz/javascript/es6-sintaksis) faqat bir qavat nusxa oladi. JSON orqali
esa to'liq nusxa olish mumkin:

```js
const original = { name: "Aziz", address: { city: "Toshkent" } };

const shallow = { ...original };
shallow.address.city = "Buxoro";
console.log("Spread'dan keyin:", original.address.city);

const original2 = { name: "Aziz", address: { city: "Toshkent" } };
const deep = JSON.parse(JSON.stringify(original2));
deep.address.city = "Samarqand";
console.log("JSON'dan keyin:", original2.address.city);
```

Bu usul ishlaydi, lekin yuqoridagi cheklovlar bilan. Zamonaviy brauzerlarda
`structuredClone()` yaxshiroq — u `Date` va boshqa turlarni saqlaydi.

## Xatoni ushlash

Tashqaridan kelgan JSON'ni har doim `try/catch` bilan o'qing:

```js
function safeParse(text) {
  try {
    return JSON.parse(text);
  } catch {
    console.log("Noto'g'ri JSON, standart qiymat qaytarildi");
    return null;
  }
}

console.log(safeParse('{"a":1}'));
console.log(safeParse("buzilgan matn"));
```

## Massiv ham JSON bo'ladi

```js
const students = [
  { name: "Aziz", score: 85 },
  { name: "Dilnoza", score: 92 },
];

const text = JSON.stringify(students);
console.log(text);

const mapWith = JSON.parse(text);
console.log(mapWith.map((t) => t.name));
```

API'lar ko'pincha aynan shunday massiv qaytaradi.

## Amaliy mashq

1. Uch xossali obyektni `JSON.stringify` bilan matnga o'giring;
2. natijani `JSON.parse` bilan qayta obyektga aylantiring;
3. `null, 2` bilan chiroyli formatlang;
4. obyektga funksiya va `undefined` qo'shib, ular yo'qolishini ko'ring;
5. buzilgan JSON matnini `try/catch` bilan o'qing;
6. ichma-ich obyektni JSON orqali chuqur nusxalang.

4-qadam formatning asosiy cheklovini ko'rsatadi.

## Qisqacha xulosa

- **JSON** — ma'lumotni matn ko'rinishida yozish formati.
- `JSON.stringify` obyektni matnga, `JSON.parse` matnni obyektga o'giradi.
- Uchinchi argument (`null, 2`) chiroyli formatlaydi.
- Kalitlar va matnlar **qo'shtirnoq** ichida bo'lishi shart.
- `undefined`, funksiya yo'qoladi; `Date` matnga aylanadi.
- Tashqi JSON'ni doim `try/catch` bilan o'qing.

Keyingi darsda [localStorage](https://learncode.uz/javascript/localstorage) — ma'lumotni
brauzerda saqlash.