Implicit Type Checking

Qaysidir ma'noda bu "Yashirin tip tekshiruvi" deb ham nomlanadi.

TypeScript'ning tip tekshiruvchisi (type checking) oson o'zlashtirish va ishlatish uchun mo'ljallangan. Aslida, u dasturingizdagi ko'p qiymatlarning tiplarini siz aniq belgilamasdan ham avtomatik ravishda aniqlaydi yoki tahmin qiladi. Masalan, quyidagi holatni ko'rib chiqaylik. Biz o'zgaruvchiga string qiymatini belgilaganimizda, TypeScript o'sha o'zgaruvchining tipi string ekanligini aniqlaydi.

let fruitName = "Banana"; // let fruitName: string

Biz ko'pincha o'zgaruvchilarni qiymatlarni saqlaydigan idishlar sifatida tasavvur qilamiz. Agar shunday bo'lsa, TypeScript bizga idish qanday turdagi narsani saqlashi mumkinligini aytish va biz noto'g'ri idishga biror narsani qo'yishga harakat qilsak, bizni ogohlantirish imkonini beradi. Bu yerda bizda "fruitName" deb nomlangan string idishimiz bor. TypeScript uning string ekanligini biladi, chunki biz darhol uning ichiga string qiymat qo'yyapmiz.

Agar biz ushbu o'zgaruvchilardan birini noto'g'ri tipga qayta belgilashga harakat qilsak, TypeScript tip xatosini chiqaradi.

let fruitName = "Banana";

fruitName = 1193; // Type Error: Type 'number' is not assignable to type 'string'

TypeScript bizga numberni string o'zgaruvchisiga belgilay olmasligimizni aytmoqda. Bu xuddi suv idishiga yog' quyishga urinish kabidir - ular shunchaki aralashmaydi.

Bunday type checking barcha primitiv tiplar uchun, masalan number va boolean qiymatlar uchun ham ishlaydi. TypeScript obyekt literallarining tiplarini ham aniqlaydi.

let fruit = {
  name: "Banana",
  color: "yellow",
  sweetness: 80,
  isRipe: true,
};

// let fruit: {
//     name: string;
//     color: string;
//     sweetness: number;
//     isRipe: boolean;
// }

Agar biz obyektning xususiyatlarini o'z o'zgaruvchilariga ajratsak, bu o'zgaruvchilar hali ham to'g'ri tipga ega bo'ladi.

let { name, sweetness } = fruit;

name; // const name: string
sweetness; // const sweetness: number

Massiv literalini yaratganingizda, TypeScript o'sha massivning tipini ham aniqlaydi.

let fruitNames = ["Apple", "Banana"]; // let fruitNames: string[]

TypeScript o'sha tipdagi massivlarni belgilash uchun tipdan keyin ikkita kvadrat qavsni ([]) ishlatadi.

Contextual Type Inference

TypeScript o'zgaruvchilarning tiplarini o'zgaruvchi yaratilgan kontekstga asoslanib ham aniqlashi mumkin. Masalan, ushbu massiv metodini ko'rib chiqaylik.

let fruitNames = ["Apple", "Banana"];

// Bu funksiya ro'yxatimizdagi har ikkinchi elementni katta harflarga o'zgartiradi.
const alternatedFruitNames = fruitNames.map((name, index) => {
  // (parameter) name: string
  // (parameter) index: number
  if (index % 2 === 0) {
    return name.toUpperCase();
  }
  return name;
});

alternatedFruitNames; // const alternatedFruitNames: string[]

TypeScript allaqachon biladiki, biz massivda .map ishlatganimizda, birinchi parametrning tipi massiv elementining tipi bo'ladi, va ikkinchi parametr siklning joriy indeksini ifodalovchi raqam bo'ladi. Bu holda, biz TypeScript'ga o'z tiplarimiz haqida hech narsa aytishimiz shart emas. Chunki u allaqachon biladi.

Biz hatto massivimizni bir tipdan boshqasiga o'zgartirishimiz mumkin va TypeScript bu o'zgarishni tan oladi, masalan, ushbu funksiya string massivini number massiviga o'zgartiradi.

let fruitNames = ["Apple", "Banana"];

const nameLength = fruitNames.map((name) => {
  return name.length;
});

nameLength; // const nameLength: number[]

Agar biz funksiya yaratib, uni massivimizning map funksiyasiga o'tkazsak, TypeScript endi parametr tiplarini aniqlay olmaydi. Buning sababi, funksiya endi .map funksiyasi bilan to'g'ridan-to'g'ri bog'liq emas, shuning uchun TypeScript bizning alternateUppercase funksiyamiz qanday ishlatilishini to'g'ridan-to'g'ri bila olmaydi.

function alternateUppercase(name, index) {
  // (parameter) name: any
  // (parameter) index: any
  if (index % 2 === 0) {
    return name.toUpperCase();
  }
  return name;
}

fruitNames.map(alternatedFruitNames);

TypeScript'ning tip aniqlashi har doim maxsus any tipiga qaytadi. Bu tip har qanday boshqa tipni ifodalaydi va xuddi JavaScript ishlatayotgandek ishlaydi. Bu biror narsaga to'g'ri tip berish qiyin bo'lganda foydali bo'lishi mumkin, lekin biz TypeScript'ning tip tekshiruvchisi bergan kafolatlarni yo'qotamiz. Biz yashirin any lardan qochishni xohlaymiz, shuning uchun konfiguratsiyada noImplicitAny bayrog'ini yoqamiz. Bizning konfiguratsiyamiz bilan biz tip xatosini olardik:

function alternateUppercase(name, index) {
  // (parameter) name: any - Type Error: Parameter 'name' implicitly has an 'any' type.
  // (parameter) index: any - Type Error: Parameter 'index' implicitly has an 'any' type.
  
  // Tip Xatosi: 'name' va 'index' parametrlari yashirin ravishda 'any' tipiga ega.
}

TypeScript bizni ogohlantirmoqdaki, bu funksiya yashirin any tipi tufayli tip xavfsizligini yo'qotgan.

Keyingi maqolalarda biz o'zgaruvchilarimiz va funksiyalarimizga aniq tipni qanday berishni o'rganamiz, shunda biz har doim tip xavfsizligiga ega bo'lamiz.