TypeScript any, unknown va never tiplari

Serverdan kelgan ma’lumot tipi oldindan noma’lum. Bunday qiymatni qanday e’lon qilish kerak?

Eng oson yo’l — any. U ishlaydi, lekin TypeScript’ni butunlay o’chirib qo’yadi. Bu darsda nega shunday bo’lishini va to’g’ri yechim nima ekanini ko’ramiz.

any — tekshiruvni o’chiradi

let risky: any = "salom";

console.log(risky.toFixed(2));

Bu kod kompilyatsiyadan muammosiz o’tadi. Xato yo’q, ogohlantirish yo’q.

Ishga tushirilganda esa:

TypeError: risky.toFixed is not a function

Mana muammo: any ishlatilgan joyda TypeScript’dan hech qanday foyda qolmaydi. Siz tiplar uchun kod yozdingiz, lekin himoya olmadingiz.

any yuqumli

Eng yomon jihati: any o’zi bilan tegib o’tgan joyni ham “yuqtiradi”.

const data: any = JSON.parse("{}");
const name = data.user.name;      // name ham any
const length = name.length;       // bu ham any

name va length ham any bo’lib qoldi. Ya’ni bitta any kod bo’ylab tarqalib, butun zanjirdan himoyani olib tashlaydi.

Shuning uchun any yozishdan oldin har doim to’xtab o’ylang: bu yerda haqiqatan tip noma’lummi, yoki uni yozishga erinyapmanmi?

unknown — xavfsiz muqobil

unknown ham har qanday qiymatni qabul qiladi, lekin uni ishlatishga ruxsat bermaydi:

const value: unknown = "Salom";
console.log(value.length);

example.ts(2,13): error TS18046: 'value' is of type 'unknown'.

Farqni jadvalda ko’ring:

Amal	`any`	`unknown`
Har qanday qiymat berish	✅	✅
Tekshiruvsiz ishlatish	✅ (xavfli)	❌
Tekshiruvdan keyin ishlatish	✅	✅

unknown “bilmayman” deyishning halol usuli. any esa “tekshirma” degani.

unknown bilan qanday ishlash

Tekshiruvdan keyin TypeScript ruxsat beradi:

function parseJson(raw: string): unknown {
  return JSON.parse(raw);
}

const data = parseJson('{"name":"Aziz"}');

if (typeof data === "object" && data !== null && "name" in data) {
  console.log("Nom topildi:", data.name);
} else {
  console.log("Kutilgan shakl emas");
}

Nom topildi: Aziz

Tekshiruv uch bosqichli va har biri zarur:

typeof data === "object" — obyektmi?
data !== null — typeof null ham "object" beradi, shuning uchun alohida tekshiriladi;
"name" in data — kerakli maydon bormi?

Ma’lumot turlari darsidagi typeof null === "object" xususiyati aynan shu yerda ahamiyatga ega bo’ladi.

JSON.parse doim ishonchsiz

const data = JSON.parse('{"age": "yigirma"}');

JSON.parse any qaytaradi. Ya’ni serverdan kelgan har qanday ma’lumot, agar tekshirilmasa, tiplar himoyasidan chetda qoladi.

Tiplar ishlash paytida tekshirilmaydi

Bu TypeScript’ning eng muhim chegarasi.

type User = { name: string; age: number };
const user = JSON.parse('{"name":"Aziz","age":"yigirma"}') as User;
console.log(user.age * 2);

Bu kod kompilyatsiyadan o’tadi va NaN chiqaradi. Sabab: as User yozuvi TypeScript’ga “ishon, bu User” deyishdan boshqa hech narsa qilmaydi. U ma’lumotni tekshirmaydi.

Tiplar faqat yozish paytida ishlaydi. Tashqaridan kelgan ma’lumotni haqiqatan tekshirish uchun kod yozish kerak — yoki shu ish bilan shug’ullanadigan kutubxona.

Fetch darsidagi har bir javob shu toifaga kiradi.

never — hech qachon qaytmaydigan

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

Bu funksiya hech qachon qiymat qaytarmaydi: u har doim xato tashlaydi.

never ni void bilan aralashtirmang:

Tip	Ma’nosi
`void`	Funksiya tugaydi, lekin qiymat qaytarmaydi
`never`	Funksiya umuman tugamaydi

never barcha variantlar tugaganini bildiradi

never ning eng foydali ishlatilishi — union to’liq qayta ishlanganini tekshirish:

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

function handle(value: string | number): string {
  if (typeof value === "string") return value;
  if (typeof value === "number") return value.toFixed(1);
  return fail("Kutilmagan tip");
}

console.log(handle("salom"), handle(3.14159));

salom 3.1

Oxirgi return ga hech qachon yetib borilmaydi: string va number tekshirilgach, boshqa variant qolmadi. Shu joyda value ning tipi never bo’ladi.

Foydasi keyin ko’rinadi. Union’ga yangi variant qo’shsangiz — masalan boolean — TypeScript oxirgi qatorda xato beradi va yangi holatni qayta ishlashni unutmasligingizni ta’minlaydi.

catch bloki va unknown

strict rejimida catch dagi qiymat tipi noma’lum:

try {
  fail("Xato yuz berdi");
} catch (error) {
  if (error instanceof Error) {
    console.log("Ushlandi:", error.message);
  }
}

Ushlandi: Xato yuz berdi

Sabab mantiqiy: JavaScript’da throw bilan har qanday qiymatni tashlash mumkin — matn ham, son ham. Shuning uchun error.message ni to’g’ridan-to’g’ri o’qib bo’lmaydi.

instanceof Error tekshiruvi xatolar darsidagi naqshni TypeScript’da majburiy qiladi.

Qachon any ishlatish mumkin

Deyarli hech qachon. Lekin ikki holat bor:

Eski JavaScript kodini bosqichma-bosqich ko’chirayotganda — vaqtincha, izoh bilan;
Tip tavsifi yo’q kutubxona bilan ishlaganda — o’rab, faqat chegarada.

Ikkala holatda ham any vaqtinchalik bo’lishi kerak.

noImplicitAny ni yoqing

strict: true ichida noImplicitAny allaqachon yoqilgan. U tip yozilmagan parametrni ushlaydi:

function double(value) {
  return value * 2;
}

error TS7006: Parameter 'value' implicitly has an 'any' type.

Bu ogohlantirish qimmatli: u any ning tasodifan paydo bo’lishini to’xtatadi. Ataylab yozilgan any ko’rinadi, tasodifiysi esa ko’rinmaydi — shuning uchun ikkinchisi xavfliroq.

Amaliy mashq

any tipidagi o’zgaruvchiga matn berib, unda toFixed() chaqiring va kompilyatsiya o’tishini, ishga tushirishda xato chiqishini solishtiring;
Xuddi shu kodni unknown bilan yozib, TS18046 xatosini o’qing;
unknown qiymatini typeof bilan tekshirib, so’ng ishlatib ko’ring;
JSON.parse natijasini as bilan noto’g’ri tipga majburlab, natijada NaN olinishini kuzating;
never qaytaradigan funksiya yozib, uni union tekshiruvining oxirgi shoxida ishlating;
Tip yozilmagan parametrli funksiya yozib, TS7006 ogohlantirishini chaqiring.

4-qadam eng muhimi: u tiplar ishlash paytida tekshirilmasligini — TypeScript’ning asosiy chegarasini — amalda ko’rsatadi.

Qisqacha xulosa

any tekshiruvni o’chiradi va tegib o’tgan qiymatlarga tarqaladi.
unknown ham har qanday qiymatni oladi, lekin uni ishlatishdan oldin tekshirishni talab qiladi.
Noma’lum ma’lumot uchun doim unknown tanlanadi, any emas.
as yozuvi ma’lumotni tekshirmaydi — u faqat TypeScript’ga “ishon” deydi.
Tiplar ishlash paytida yo’q: tashqaridan kelgan ma’lumot qo’lda tekshiriladi.
never — qiymat qaytarmaydigan funksiya va barcha variantlar tugagan joy tipi.
strict rejimida catch dagi qiymat unknown bo’ladi va instanceof bilan tekshiriladi.

Keyingi darsda generiklar — tipni parametr sifatida uzatish.