Asosiy turlar

Primitiv tip annotatsiyalari

Tipni o‘zgaruvchiga ikki nuqta orqali biriktirasiz. Asosiy holatlarda tip nomi qiymatga mos keladi:

const name: string = "Ada";
const age: number = 36;
const isAdmin: boolean = true;

Amalda odatda bularni tushirib qoldirasiz — TypeScript ularni qiymatdan chiqarib oladi (infer qiladi). Annotatsiyalarni asosan funksiya parametrlariga va inference yetarli bo‘lmagan joylarga yozasiz. Ammo nomlarni bilish foydali: string, number, boolean (barchasi kichik harflarda — bosh harfli String esa boshqa, kamdan-kam ishlatiladigan narsa).

Massivlar

Massivga tip berishning ikki teng usuli bor. Type[] shakli eng keng tarqalgani:

const scores: number[] = [90, 85, 100];
const names: string[] = ["Ada", "Alan"];
 
// the generic form — same meaning
const scores2: Array<number> = [90, 85, 100];

Endi TypeScript har bir element number ekanini biladi, shuning uchun u xatolarni ushlab qoladi:

scores.push("oops");   // Error: string not assignable to number

Type inference amalda

Imkoni bo‘lganda TypeScriptning o‘zi ishni bajarsin:

let count = 5;          // inferred as number
const active = true;    // inferred as boolean
const tags = ["a", "b"]; // inferred as string[]
 
count = "hello";        // Error — count is a number

count number sifatida boshlangani uchun TypeScript uni numberga qat‘iy bog‘laydi va keyingi har qanday string tayinlashni belgilaydi. Bu inference sizni bironta ham annotatsiyasiz himoya qilishidir.

any — qochish yo‘li (undan saqlaning)

any qiymat uchun tip tekshiruvini o‘chirib qo‘yadi. U shunday deydi: "menga ishoning, hamma narsa mumkin":

let data: any = "hello";
data = 42;              // no error
data = { x: 1 };        // no error
data.foo.bar.baz;       // no error — but will crash at runtime!

any TypeScriptning butun maqsadini yo‘qqa chiqaradi. any orqali tegishadigan har bir qiymat o‘z xavfsizligini yo‘qotadi. Undan saqlaning — bu qulaylik emas, oxirgi chora.

unknown — xavfsiz muqobil

Tipni haqiqatan hali bilmaganingizda (API’dan kelgan ma’lumot, foydalanuvchi kiritmasi), any o‘rniga unknowndan foydalaning. unknown ham har qanday qiymatni qabul qiladi, lekin u nima ekanini tekshirmaguningizcha undan foydalanishga ruxsat bermaydi:

let data: unknown = fetchSomething();
 
data.toUpperCase();     // Error — must check first
 
if (typeof data === "string") {
  data.toUpperCase();   // ok — now TS knows it's a string
}

Ana shu majburiy tekshiruv butun gapning mohiyati: unknown sizni xavfsiz saqlaydi, any esa xavfsizlikni uloqtiradi. Amaliy qoida: hech qachon any emas, unknownni afzal ko‘ring va uni toraytiring (narrow).

null va undefined

TypeScript bularni ham kuzatib boradi. Strict rejimi yoqilgan holda (zamonaviy sozlamalarda odatiy holat), string yashirincha null bo‘lolmaydi — buni aniq aytishingiz kerak:

let title: string = null;         // Error in strict mode
let subtitle: string | null = null;  // ok — explicitly allowed

Ana shu string | null — bu union type — u "shulardan biri" degani. Unionlarga keyingi mavzuda chuqurroq kirasiz; hozircha shuni bilib qo‘ying: TypeScript "bo‘sh bo‘lishi mumkin"ligini yashirin qoldirish o‘rniga ko‘rinadigan qiladi.

Intervyu maslahatlari

• Kichik harfli string/number/boolean ishlating; massivlarni number[] (yoki Array<number>) sifatida tiplang.
• Inferenceni afzal ko‘ring — har bir o‘zgaruvchini emas, parametrlarni annotatsiya qiling.
• any nega xavfli ekanini tushuntiring (u tekshiruvni o‘chiradi va tarqaladi).
• Tip haqiqatan noma’lum bo‘lganda unknownga murojaat qiling — u ishlatishdan oldin tekshiruvni majbur qiladi.