TypeScript any, unknown, never, void va object: maxsus turlar

Qisqacha: Bular — maxsus holatlar uchun turlar. Tur any tekshiruvni o'chiradi va xatolarni yashiradi, unknown esa istalgan qiymatni qabul qiladi, lekin ishlatishdan oldin tekshirishni talab qiladi. Funksiya natijasida void — "hech narsa qaytarmaydi", never — "hech qachon qaytmaydi". Obyektlar uchun object — primitiv bo'lmagan qiymat, {} esa null va undefined dan boshqa hamma narsa.

Bu darsda

• any nega xavfli va u kodga qayerdan kirib kelishini bilasiz.
• unknown bilan tashqi ma'lumotni xavfsiz qabul qilasiz va catch dagi xatoni to'g'ri o'qiysiz.
• void qachon chiqishini va uning natijasini nega ishlatib bo'lmasligini tushunasiz.
• never — "bo'lishi mumkin bo'lmagan qiymat" turini taniysiz.
• object, {} va Object ni farqlaysiz va to'g'risini tanlaysiz.

Oldin bilishingiz kerak: Union va literal turlar, Tur annotatsiyasi va tur chiqarish, try / catch / finally.

1. Nega bu kerak?

O'tgan darslarda bir tuzoqni bir necha marta ko'rdik: JSON.parse natijasi istalgan turga jim mos keladi, keyin ishlash paytida TypeError. Sababi bitta so'zda — JSON.parse ning natija turi any.

Bugun shu any va uning "qarindoshlari" bilan tanishamiz. Ular oddiy turlardan (string, MenuItem) farq qiladi: aniq qiymatlarni emas, maxsus holatlarni bildiradi.

2. any: tekshiruvni o'chirish

2.1 Hamma narsaga ruxsat

any turidagi qiymat bilan TypeScript hech narsani tekshirmaydi:

const order: any = JSON.parse('{"dish":"Osh"}');
const price = order.price;
console.log(price.toFixed(0));

tsc — xatosiz. Node esa:

TypeError: Cannot read properties of undefined (reading 'toFixed')

order.price — yo'q xususiyat, lekin TypeScript indamadi. price.toFixed — undefined ning metodi, yana indamadi. any bilan TypeScript oddiy JavaScript'ga aylanadi.

2.2 any yuqumli

Ikkinchi qatorga qarang: const price = order.price. Hover nima ko'rsatadi? const price: any. any ning xususiyati ham any, uning natijasi ham any. Bir joydagi any zanjir bo'ylab tarqalib, butun kodni tekshiruvsiz qoldiradi. Kasallik kabi yuqadi — shuning uchun uni "yuqumli" deyishadi.

tsc --declaration ko'rsatgan turlar:

2.3 any qayerdan keladi

• O'zingiz yozsangiz: let x: any. ESLint'da (typescript-eslint) bunga qarshi no-explicit-any qoidasi bor — vazifalar da u type va interface qadamidan beri yoqilgan.
• Yashirin (implicit): parametr turini yozmasangiz. strict buni TS7006 bilan to'xtatadi (Tur annotatsiyasi darsida ko'rgansiz).
• Kutubxonadan: JSON.parse() — any, fetch javobidagi response.json() — Promise<any>. Bu eng xavfli yo'l, chunki siz hech narsa yozmagansiz.

2.4 any qachon kerak?

Kamdan-kam: JavaScript'dan TypeScript'ga ko'chishning birinchi kunlarida yoki turi umuman yozilmagan eski kutubxonada. Bunday joyda ham u vaqtinchalik va izoh bilan qo'yiladi. Deyarli har doim to'g'ri tanlov — unknown.

3. unknown: noma'lum, avval tekshir

3.1 Qabul qiladi, lekin ishlatishga bermaydi

unknown ga ham istalgan qiymatni berish mumkin. Farqi — undan keyin:

const raw: unknown = JSON.parse('{"price":35000}');
console.log(raw.price);

Kompilyator:

TS18046: 'raw' is of type 'unknown'.

Tarjimasi: "raw — unknown turida". Qisqa xabar, lekin ma'nosi aniq: "bu nima ekanini bilmayman, avval tekshir". JSDoc darsida shu xabarni @type {unknown} bilan ko'rgan edingiz.

unknown ni boshqa turga ham berib bo'lmaydi:

const saved: unknown = JSON.parse("35000");
const price: number = saved;

Kompilyator:

TS2322: Type 'unknown' is not assignable to type 'number'.

any da bu qator jim o'tardi. unknown esa "son ekanini isbotla" deydi.

3.2 Tekshirgandan keyin — ruxsat

Union darsidagi typeof tekshiruvi unknown bilan ham ishlaydi:

function describe(value: unknown): string {
  if (typeof value === "number") {
    return `son: ${value.toFixed(0)}`;
  }
  if (typeof value === "string") {
    return `satr: ${value.toUpperCase()}`;
  }
  return "boshqa narsa";
}

console.log(describe(35000)); // son: 35000
console.log(describe("osh")); // satr: OSH
console.log(describe(null)); // boshqa narsa

Har if ichida TypeScript value ni toraytirdi: avval number, keyin string. Tekshiruvsiz joyda esa u unknown bo'lib qoladi. Obyektni tekshirish ("price" in value, o'z tekshiruv funksiyalari) — Narrowing va Custom type guard darslarida.

3.3 catch dagi xato — unknown

throw bilan istalgan narsani tashlash mumkin: Error ni ham, satrni ham, sonni ham (Xato turlari). Shuning uchun strict rejimda catch dagi o'zgaruvchi — unknown:

try {
  JSON.parse("{");
} catch (error) {
  console.log(error.message);
}

Kompilyator:

TS18046: 'error' is of type 'unknown'.

TypeScript aytyapti: «error ning turi — unknown», ya'ni "ichida nima borligini bilmayman". unknown qiymatning xususiyatini (error.message) tekshirmasdan o'qib bo'lmaydi.

Tuzatish — instanceof Error bilan tekshirish:

try {
  JSON.parse("{");
} catch (error) {
  const text = error instanceof Error ? error.message : String(error);
  console.log(text);
}

Konsolda:

Expected property name or '}' in JSON at position 1 (line 1 column 2)

error instanceof Error dan keyin error — Error, uning message i bor. Boshqa narsa tashlangan bo'lsa — String(error) uni matnga aylantiradi. Bu qoidaning nomi — useUnknownInCatchVariables ("catch o'zgaruvchilarida unknown"), u strict ning bir qismi. vazifalar dagi saqlash moduli null va undefined qadamida aynan shu usul bilan xatoNomi(xato: unknown) yordamchisini oladi.

3.4 any va unknown — yonma-yon

Qoida: tashqaridan kelgan har qanday qiymat — JSON.parse, server javobi, localStorage, catch — unknown deb qabul qilinadi va ishlatishdan oldin tekshiriladi.

Tekshirib ko'ring: const x: unknown = "Osh"; console.log(x.length); — tsc nima deydi? x ni any qilsak-chi?

4. void: hech narsa qaytarmaydi

4.1 Natijasiz funksiya

function logLine(text: string) {
  console.log(`[kassa] ${text}`);
}

logLine("Osh x2"); // [kassa] Osh x2

Hover: function logLine(text: string): void. void ("bo'shliq") — "bu funksiya qiymat qaytarmaydi". return yo'q yoki return; bo'sh. Ishlash paytida bunday funksiyaning natijasi undefined (return va erta qaytish).

4.2 void natijani ishlatib bo'lmaydi

function logLine(text: string): void {
  console.log(text);
}

const result = logLine("Osh");
console.log(result.length);
if (logLine("Manti")) {
  console.log("yozildi");
}

Kompilyator:

TS2339: Property 'length' does not exist on type 'void'.
TS1345: An expression of type 'void' cannot be tested for truthiness.

Ikkinchi xabar: "void turidagi ifodani rost-yolg'onga tekshirib bo'lmaydi". if (logLine(...)) — mantiqiy xato: funksiya hech narsa qaytarmaydi, shart esa doim yolg'on bo'lardi. TypeScript buni ham ushladi.

4.3 void va undefined

Ular o'xshash, lekin ma'nosi boshqa. undefined — qiymat: "natija — undefined". void — niyat: "natijaga qaramang". Natija turi string deb yozilgan funksiya qiymat qaytarishi shart:

function dishName(id: number): string {
  if (id === 1) {
    return "Osh";
  }
}

Kompilyator:

TS2366: Function lacks ending return statement and return type does not include 'undefined'.

Tarjimasi: "funksiya oxirida return yo'q, natija turi esa undefined ni o'z ichiga olmaydi". id 1 bo'lmasa, funksiya hech narsa qaytarmaydi. Tuzatish: oxiriga return qo'shing yoki natija turini string | undefined qiling. void ning callback'lardagi nozik qoidasi bor — uni Funksiyalarni tiplash darsida ko'ramiz.

5. never: hech qachon bo'lmaydi

5.1 Doim xato tashlaydigan funksiya

function fail(message: string): never {
  throw new Error(message);
}

function portionPrice(size: string): number {
  if (size === "yarim") return 20000;
  if (size === "to'liq") return 35000;
  return fail(`Noma'lum porsiya: ${size}`);
}

console.log(portionPrice("yarim")); // 20000

never — "hech qachon bo'lmaydigan qiymat" turi. fail hech qachon qaytmaydi: u doim throw qiladi. Uning natijasi bo'lishi mumkin emas — shuning uchun never. return fail(…) qatori portionPrice ning number turiga xalaqit bermaydi: never istalgan turga mos keladi, chunki bunday qiymat hech qachon paydo bo'lmaydi.

5.2 never ga hech narsa berib bo'lmaydi

Teskari yo'nalishda esa hech narsa never ga mos emas:

let impossible: never = "osh";

Kompilyator:

TS2322: Type '"osh"' is not assignable to type 'never'.

TypeScript aytyapti: «"osh" turini never turiga berib bo'lmaydi». never ga hech qanday qiymat sig'maydi.

Bu xabarni Massiv va tuple turlari darsida ko'rgan edik: let names: [] = [] ga push — parametr turi never, chunki bo'sh tuple'ga hech narsa sig'maydi.

5.3 Nima uchun kerak?

never ning asosiy foydasi keyingi darslarda ochiladi:

• To'liqlik tekshiruvi. Union'ning hamma variantini if/switch bilan ko'rib chiqsangiz, oxirida qiymatning turi never bo'ladi — "boshqa variant qolmadi". Yangi variant qo'shilib, uni unutsangiz — tsc xato beradi. Bu Discriminated union va to'liqlik tekshiruvi darsining asosiy g'oyasi.
• Imkonsiz kesishma. string & number — "ham satr, ham son" — bunday qiymat yo'q, natija never (Kengaytirish va kesishma).

5.4 Tuzoq: function va strelka funksiya

const stopArrow = () => {
  throw new Error("to'xta");
};
function stopDeclared() {
  throw new Error("to'xta");
}
console.log(typeof stopArrow); // function
console.log(typeof stopDeclared); // function

tsc --declaration ikki xil natija turi chiqardi: stopArrow: () => never, stopDeclared(): void. Strelka funksiyaning natijasi never deb chiqarildi, function e'loniniki — void. TypeScript tarixiy sabab bilan e'lon qilingan funksiyaga never ni o'zi bermaydi. Qoida: "bu funksiya qaytmaydi" demoqchi bo'lsangiz, : never ni o'zingiz yozing.

Tekshirib ko'ring: function check(age: number): never { if (age < 18) throw new Error("Yosh yetmaydi"); } — tsc nima deydi?

6. object, {} va Object

Bu uch yozuv o'xshab ko'rinadi, lekin boshqa-boshqa narsani bildiradi.

6.1 object — primitiv emas

object (kichik harf) — har qanday primitiv bo'lmagan qiymat: obyekt, massiv, funksiya, Date. Son, satr, null — yo'q:

const settings: object = 5;
const menu: object = { name: "Osh" };
console.log(menu.name);

Kompilyator:

TS2322: Type 'number' is not assignable to type 'object'.
TS2339: Property 'name' does not exist on type 'object'.

Ikkinchi xabar muhim: object faqat "bu obyekt" deydi, qanday obyekt ekanini emas. Uning xususiyatlarini o'qib bo'lmaydi. Shuning uchun object kamdan-kam kerak — odatda aniq shakl ({ name: string }) yoziladi.

6.2 {} — "null va undefined dan boshqa hamma narsa"

Bo'sh jingalak qavs — "bo'sh obyekt" emas! Uning ma'nosi: null va undefined dan boshqa istalgan qiymat, sonlar ham:

const a: {} = 5;
const b: {} = "osh";
const c: {} = null;

Kompilyator:

TS2322: Type 'null' is not assignable to type '{}'.

5 va "osh" xatosiz o'tdi. Nega? O'tgan darslardagi qoida: obyekt turi — "kamida shu xususiyatlar bo'lsin". {} hech qanday xususiyat talab qilmaydi — son ham, satr ham "kamida hech narsa"ga ega. Faqat null va undefined da umuman xususiyat yo'q.

6.3 Object — ishlatmang

Object (katta harf) — {} ga juda yaqin, JavaScript'dagi Object konstruktorining turi. String va string farqi kabi: katta harfli o'rovchi tur kundalik kodda kerak emas.

typescript-eslint ning tavsiya etilgan qoidalari {} va Object ni ogohlantirish bilan ushlaydi (no-empty-object-type, no-wrapper-object-types).

7. Turlar ierarxiyasi — bitta rasmda

Barcha turlarni "qaysi biri qaysi biriga sig'adi" bo'yicha joylashtirsak:

flowchart TD
  U["unknown — hamma qiymat sig'adi"] --> E["{} — null/undefined dan boshqasi"]
  U --> N["null, undefined"]
  E --> P["string, number, boolean"]
  E --> O["object"]
  O --> M["MenuItem, number[], Date"]
  P --> L["literal: "faol", 35000"]
  M --> NV["never — hech narsa sig'maydi"]
  L --> NV
  N --> NV

Yuqoridagi tur pastdagilarning hammasini qabul qiladi: unknown ga istalgan qiymat beriladi. Pastga tushgan sari tur torayadi: never ga hech narsa berilmaydi. Rasmda any yo'q: u ham eng yuqorida (hamma narsani qabul qiladi), ham eng pastda (hamma joyga beriladi) — ya'ni tekshiruvdan butunlay chiqib ketadi.

8. Ko'p uchraydigan xatolar

8.1 Xatoni any bilan "yopish"

TS18046 yoki TS2339 chiqdi — : any yozildi, xato yo'qoldi. Xato yo'qolmadi, yashirindi. Tuzatish: unknown va tekshiruv.

8.2 catch (error) da error.message

TS18046: 'error' is of type 'unknown'. Tuzatish: error instanceof Error ? error.message : String(error).

8.3 void natijani tekshirish

if (save()) — save void qaytarsa, TS1345. Tuzatish: funksiya muvaffaqiyatni bildirishi kerak bo'lsa, boolean qaytarsin.

8.4 {} ni "bo'sh obyekt" deb o'ylash

const x: {} = 5 — xatosiz. Tuzatish: obyekt kerak bo'lsa — object yoki aniq shakl.

9. Mashqlar

1-mashq (oson): Qaysi tur?

function ring(): … { console.log("Buyurtma tayyor!"); } natija turi: [:void]. function crash(): … { throw new Error("x"); } — qaytmaydi, natija turi: [:never]. JSON.parse natijasining turi: .

2-mashq (o'rta): any ni unknown ga almashtiring

Funksiya localStorage dan olingan sozlamani o'qiydi. any ni unknown ga almashtiring, chiqqan xatolarni tekshiruv bilan tuzating: servicePercent son bo'lmasa, 10 qaytsin.

function servicePercent(json: string): number {
  const settings: any = JSON.parse(json);
  return settings.service;
}
console.log(servicePercent('{"service":15}')); // 15
console.log(servicePercent('{"servis":15}')); // undefined

Ishora: obyektda xususiyat borligini "service" in settings bilan tekshirish mumkin (in operatori), lekin undan oldin settings obyekt ekanini (typeof … === "object" va !== null) tekshirish kerak.

function servicePercent(json: string): number {
  const settings: unknown = JSON.parse(json);
  if (
    typeof settings === "object" &&
    settings !== null &&
    "service" in settings &&
    typeof settings.service === "number"
  ) {
    return settings.service;
  }
  return 10;
}

console.log(servicePercent('{"service":15}')); // 15
console.log(servicePercent('{"servis":15}')); // 10
console.log(servicePercent("null")); // 10

3-mashq (qiyin): Amaliy tajriba — tashqi qiymatlar

Mashq kurs/mashqlar/15/ da. 08-unknown/safe-parse.ts — birinchi variant any bilan yozilgan va tsc dan xatosiz o'tadi:

// 08-unknown/safe-parse.ts — tashqaridan kelgan qiymatlar
export function toPrice(value: any): number {
  return Number(value.replaceAll(" ", ""));
}

export function errorText(error: any): string {
  return error.message;
}

1. Ikkala any ni unknown ga almashtiring va npx tsc --pretty false ni ishga tushiring.
2. toPrice ni tuzating: son (cheksiz va NaN emas) — o'zi qaytadi; bo'sh bo'lmagan satr — bo'shliqlari olib tashlanib songa aylanadi ("35 000" → 35000); qolgan hamma narsa — TypeError. Ishora: Number.isFinite NaN va cheksizlikni rad etadi (Matn ↔ son va sonni tekshirish).
3. errorText ni tuzating: Error bo'lsa — message, aks holda String(error).
4. readSavedPrice(json: string): number | null qo'shing: JSON'ni unknown ga o'qiydi, toPrice dan o'tkazadi; buzuq JSON yoki narx bo'lmasa — null.
5. 08-unknown/safe-parse.test.ts da testlar: son va bo'shliqli satr; 8 xil yomon qiymat ("", " ", "osh", null, undefined, true, {}, NaN); errorText uchun Error, satr va son; readSavedPrice uchun to'g'ri, buzuq va narx bo'lmagan JSON.

08-unknown/safe-parse.ts(3,17): error TS18046: 'value' is of type 'unknown'.
08-unknown/safe-parse.ts(7,10): error TS18046: 'error' is of type 'unknown'.

// 08-unknown/safe-parse.ts — tashqaridan kelgan qiymatlar
// Narx: son yoki "35 000" kabi satr. Boshqasi — TypeError
export function toPrice(value: unknown): number {
  if (typeof value === "number" && Number.isFinite(value)) {
    return value;
  }
  if (typeof value === "string" && value.trim() !== "") {
    const price = Number(value.replaceAll(" ", ""));
    if (Number.isFinite(price)) {
      return price;
    }
  }
  throw new TypeError(`Narx emas: ${String(value)}`);
}

// catch'dagi qiymat — unknown: throw istalgan narsani tashlaydi
export function errorText(error: unknown): string {
  return error instanceof Error ? error.message : String(error);
}

// localStorage'dagi matn: buzuq bo'lsa — null
export function readSavedPrice(json: string): number | null {
  try {
    const parsed: unknown = JSON.parse(json);
    return toPrice(parsed);
  } catch {
    return null;
  }
}

// 08-unknown/safe-parse.test.ts
import { test } from "node:test";
import assert from "node:assert/strict";
import { toPrice, errorText, readSavedPrice } from "./safe-parse.ts";

test("toPrice: son va bo'shliqli satr", () => {
  assert.equal(toPrice(35000), 35000);
  assert.equal(toPrice("28 000"), 28000);
});

test("toPrice: narx bo'lmagan qiymatlar — TypeError", () => {
  const bad = ["", "  ", "osh", null, undefined, true, {}, NaN];
  for (const value of bad) {
    assert.throws(() => toPrice(value), TypeError);
  }
});

test("errorText: Error va boshqa qiymat", () => {
  assert.equal(errorText(new RangeError("Juda katta")), "Juda katta");
  assert.equal(errorText("oddiy matn"), "oddiy matn");
  assert.equal(errorText(404), "404");
});

test("readSavedPrice: to'g'ri, buzuq JSON va narx emas", () => {
  assert.equal(readSavedPrice('"30 000"'), 30000);
  assert.equal(readSavedPrice("{"), null);
  assert.equal(readSavedPrice('{"price":5000}'), null);
});

✔ toPrice: son va bo'shliqli satr (2.4353ms)
✔ toPrice: narx bo'lmagan qiymatlar — TypeError (1.859ms)
✔ errorText: Error va boshqa qiymat (0.5416ms)
✔ readSavedPrice: to'g'ri, buzuq JSON va narx emas (0.588ms)
ℹ tests 4
ℹ suites 0
ℹ pass 4
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 286.504

git add 15/08-unknown 15/XATOLAR.md
git commit -m "15/08: safe-parse.ts — unknown va catch xatosi"

10. Real ishda

• Kod ko'rib chiqishda any — eng ko'p belgilanadigan joy. Ko'p jamoalarda no-explicit-any — error darajasida, any faqat izoh bilan (// eslint-disable-next-line va sababi) qo'yiladi.
• Server javoblari, localStorage, postMessage, fayl — hammasi unknown sifatida qabul qilinadi va tekshiriladi. Bunday tekshiruvni avtomatlashtiradigan kutubxonalar (Zod) bor — Zod va turni sxemadan chiqarish darsida.
• never — kutubxonalarning ichki turlarida va to'liqlik tekshiruvida keng uchraydi. "Bu yerga hech qachon yetib kelmaslik kerak" degan joyni ifodalaydi.
• Intervyu: "any va unknown farqi?" — eng mashhur TypeScript savollaridan biri. "never nima va qayerda ishlatiladi?", "void va undefined farqi?" — ham tez-tez so'raladi.

Xulosa

• any — tekshiruvni o'chiradi va yuqumli: undan olingan hamma narsa ham any. JSON.parse, response.json() — any manbalari.
• unknown — xavfsiz muqobil: qabul qiladi, lekin tekshiruvsiz ishlatishga bermaydi (TS18046, TS2322). catch dagi xato strict da — unknown.
• void — "qiymat qaytarmaydi"; uning natijasini ishlatib yoki shartda tekshirib bo'lmaydi.
• never — "hech qachon": doim tashlaydigan funksiya, imkonsiz tur. Unga hech narsa berilmaydi, u esa hamma joyga sig'adi.
• object — primitiv emas; {} — null/undefined dan boshqa hammasi; Object — ishlatmang. Odatda aniq shakl yozing.

Keyingi dars: Funksiyalarni tiplash — parametr va natija turlari, ixtiyoriy va rest parametrlar, funksiya va callback turlari hamda void ning nozik qoidasi.

Manbalar

• TypeScript Handbook: "Everyday Types" → any; "More on Functions" → unknown, never, void, object — typescriptlang.org/docs/handbook/2/functions.html#other-types-to-know-about
• TypeScript Release Notes 3.0 (unknown) — typescriptlang.org/docs/handbook/release-notes/typescript-3-0.html
• TSConfig: useUnknownInCatchVariables — typescriptlang.org/tsconfig#useUnknownInCatchVariables
• typescript-eslint: no-explicit-any, no-empty-object-type, no-wrapper-object-types — typescript-eslint.io/rules/