TypeScript'da Qisman Xulosa Chiqarish: To'liq bo'lmagan Tiplarni Hal qilishni Tushunish

TypeScript'ning tiplar tizimi mustahkam va qo'llab-quvvatlanadigan ilovalar yaratish uchun kuchli vositadir. Uning asosiy xususiyatlaridan biri bu tip xulosasi bo'lib, u kompilyatorga o'zgaruvchilar va ifodalarning tiplarini avtomatik ravishda aniqlash imkonini beradi va aniq tip annotatsiyalariga bo'lgan ehtiyojni kamaytiradi. Biroq, TypeScript'ning tip xulosasi har doim ham mukammal emas. Ba'zan u "qisman xulosa chiqarish" deb nomlanuvchi holatga olib kelishi mumkin, bunda ba'zi tip argumentlari xulosa qilinadi, boshqalari esa noma'lum bo'lib qoladi, natijada tipni aniqlash to'liq bo'lmaydi. Bu turli yo'llar bilan namoyon bo'lishi mumkin va TypeScript'ning xulosa chiqarish algoritmi qanday ishlashini chuqurroq tushunishni talab qiladi.

Qisman Tip Xulosasi nima?

Qisman tip xulosasi TypeScript umumiy funksiya yoki tip uchun tip argumentlarining barchasini emas, balki ba'zilarini xulosa qila olganda yuzaga keladi. Bu ko'pincha murakkab umumiy tiplar, shartli tiplar bilan ishlaganda yoki tip ma'lumotlari kompilyator uchun darhol mavjud bo'lmaganda sodir bo'ladi. Xulosa qilinmagan tip argumentlari odatda yashirin `any` tipi sifatida qoldiriladi yoki standart tip parametri orqali aniqlangan bo'lsa, undan aniqroq zaxira tip sifatida qoldiriladi.

Keling, buni oddiy misol bilan ko'rib chiqaylik:

            
function createPair<T, U>(first: T, second: U): [T, U] {
  return [first, second];
}

const pair1 = createPair(1, "hello"); // [number, string] sifatida xulosa qilindi
const pair2 = createPair<number>(1, "hello"); // U string sifatida xulosa qilindi, T esa aniq number
const pair3 = createPair(1, {}); // [number, {}] sifatida xulosa qilindi

            

              
                Copy
              
            
          

Birinchi misolda, `createPair(1, "hello")`, TypeScript `T` ni `number` va `U` ni `string` sifatida xulosa qiladi, chunki u funksiya argumentlaridan yetarli ma'lumotga ega. Ikkinchi misolda, `createPair<number>(1, "hello")`, biz `T` uchun tipni aniq ko'rsatamiz va TypeScript ikkinchi argument asosida `U` ni xulosa qiladi. Uchinchi misol, aniq tiplashtirishsiz obyekt literallari `{}` sifatida qanday xulosa qilinishini ko'rsatadi.

Kompilyator barcha kerakli tip argumentlarini aniqlay olmaganda, qisman xulosa chiqarish yanada muammoli bo'lib, potentsial xavfli yoki kutilmagan xatti-harakatlarga olib kelishi mumkin. Bu, ayniqsa, murakkabroq umumiy tiplar va shartli tiplar bilan ishlaganda to'g'ri keladi.

Qisman Xulosa Chiqarish Yuzaga Keladigan Holatlar

Quyida siz qisman tip xulosasiga duch kelishingiz mumkin bo'lgan ba'zi keng tarqalgan vaziyatlar keltirilgan:

1. Murakkab Umumiy Tiplar

Chuqur joylashtirilgan yoki murakkab umumiy tiplar bilan ishlaganda, TypeScript barcha tip argumentlarini to'g'ri xulosa qilishda qiynalishi mumkin. Bu, ayniqsa, tip argumentlari o'rtasida bog'liqliklar mavjud bo'lganda to'g'ri keladi.

            
interface Result<T, E> {
  success: boolean;
  data?: T;
  error?: E;
}

function processResult<T, E>(result: Result<T, E>): T | E {
  if (result.success) {
    return result.data!;
  } else {
    return result.error!;
  }
}

const successResult: Result<string, Error> = { success: true, data: "Data" };
const errorResult: Result<string, Error> = { success: false, error: new Error("Something went wrong") };

const data = processResult(successResult); // string | Error sifatida xulosa qilindi
const error = processResult(errorResult);   // string | Error sifatida xulosa qilindi

            

              
                Copy
              
            
          

Bu misolda, `processResult` funksiyasi umumiy `T` va `E` tiplariga ega bo'lgan `Result` tipini qabul qiladi. TypeScript bu tiplarni `successResult` va `errorResult` o'zgaruvchilari asosida xulosa qiladi. Biroq, agar siz `processResult` ni to'g'ridan-to'g'ri obyekt literali bilan chaqirsangiz, TypeScript tiplarni unchalik aniq xulosa qila olmasligi mumkin. Argument asosida qaytariladigan tipni aniqlash uchun generiklardan foydalanadigan boshqa funksiya ta'rifini ko'rib chiqing.

            
function extractValue<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const myObject = { name: "Alice", age: 30 };

const nameValue = extractValue(myObject, "name"); // string sifatida xulosa qilindi
const ageValue = extractValue(myObject, "age");   // number sifatida xulosa qilindi

// Dinamik yaratilgan tip bilan potensial qisman xulosa chiqarishni ko'rsatuvchi misol
type DynamicObject = { [key: string]: any };

function processDynamic<T extends DynamicObject, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const dynamicObj:DynamicObject = {a: 1, b: "hello"};
const result = processDynamic(dynamicObj, "a"); //natija "any" sifatida xulosa qilinadi, chunki DynamicObject standart holatda "any" ga teng

            

              
                Copy
              
            
          

Bu yerda, agar biz `DynamicObject` dan aniqroq tip bermasak, xulosa `any` ga qaytadi.

2. Shartli Tiplar

Shartli tiplar shartga bog'liq bo'lgan tiplarni aniqlashga imkon beradi. Ular kuchli bo'lsa-da, ayniqsa shart umumiy tiplarni o'z ichiga olganda, xulosa chiqarishda qiyinchiliklarga olib kelishi mumkin.

            
type IsString<T> = T extends string ? true : false;

function processValue<T>(value: T): IsString<T> {
  // Bu funksiya aslida ish vaqtida hech qanday foydali ish bajarmaydi,
  // u shunchaki tip xulosasini ko'rsatish uchun.
  return (typeof value === 'string') as IsString<T>;
}

const stringValue = processValue("hello"); // IsString<string> (true ga aylanadi) sifatida xulosa qilindi
const numberValue = processValue(123);     // IsString<number> (false ga aylanadi) sifatida xulosa qilindi

// Funksiya ta'rifi xulosa chiqarishga imkon bermaydigan misol
function processValueNoInfer<T>(value: T): T extends string ? true : false {
  return (typeof value === 'string') as T extends string ? true : false;
}

const stringValueNoInfer = processValueNoInfer("hello"); // boolean sifatida xulosa qilindi, chunki qaytariladigan tip bog'liq tip emas

            

              
                Copy
              
            
          

Birinchi misollar to'plamida, TypeScript umumiy `IsString<T>` qaytariladigan tipidan foydalanish tufayli kirish qiymatiga asoslanib qaytariladigan tipni to'g'ri xulosa qiladi. Ikkinchi to'plamda shartli tip to'g'ridan-to'g'ri yozilgan, shuning uchun kompilyator kirish va shartli tip o'rtasidagi bog'liqlikni saqlamaydi. Bu kutubxonalardagi murakkab yordamchi tiplardan foydalanganda sodir bo'lishi mumkin.

3. Standart Tip Parametrlari va `any`

Agar umumiy tip parametrida standart tip mavjud bo'lsa (masalan, `<T = any>`), va TypeScript aniqroq tipni xulosa qila olmasa, u standart tipga qaytadi. Bu ba'zan to'liq bo'lmagan xulosa bilan bog'liq muammolarni yashirishi mumkin, chunki kompilyator xato chiqarmaydi, lekin natijaviy tip juda keng bo'lishi mumkin (masalan, `any`). Ayniqsa, standart holatda `any` bo'lgan standart tip parametrlaridan ehtiyot bo'lish muhim, chunki bu kodingizning o'sha qismi uchun tip tekshiruvini samarali ravishda o'chirib qo'yadi.

            
function logValue<T = any>(value: T): void {
  console.log(value);
}

logValue(123);        // T "any", shuning uchun tip tekshiruvi yo'q
logValue("hello");    // T "any"
logValue({ a: 1 });   // T "any"


function logValueTyped<T = string>(value: T): void {
  console.log(value);
}

logValueTyped(123); // Xato: 'number' turidagi argument 'string | undefined' turidagi parametrga tayinlanishi mumkin emas.



            

              
                Copy
              
            
          

Birinchi misolda, standart tip parametri `T = any` har qanday tipni kompilyatordan shikoyatsiz `logValue` ga o'tkazish mumkinligini anglatadi. Bu potentsial xavfli, chunki u tip tekshiruvini chetlab o'tadi. Ikkinchi misolda, `T = string` yaxshiroq standart hisoblanadi, chunki `logValueTyped` ga string bo'lmagan qiymatni o'tkazganingizda tip xatolarini keltirib chiqaradi.

4. Obyekt Literallaridan Xulosa Chiqarish

TypeScript'ning obyekt literallaridan xulosa chiqarishi ba'zan hayratlanarli bo'lishi mumkin. Siz obyekt literalini to'g'ridan-to'g'ri funksiyaga o'tkazganingizda, TypeScript siz kutganingizdan torroq tipni xulosa qilishi yoki umumiy tiplarni to'g'ri xulosa qilmasligi mumkin. Buning sababi, TypeScript obyekt literallaridan tiplarni xulosa qilishda iloji boricha aniq bo'lishga harakat qiladi, ammo bu ba'zan generiklar bilan ishlaganda to'liq bo'lmagan xulosaga olib kelishi mumkin.

            
interface Options<T> {
  value: T;
  label: string;
}

function processOptions<T>(options: Options<T>): void {
  console.log(options.value, options.label);
}

processOptions({ value: 123, label: "Number" }); // T number sifatida xulosa qilindi

// Xususiyatlar initsializatsiya paytida aniqlanmaganda tip to'g'ri xulosa qilinmaydigan misol
function createOptions<T>(): Options<T>{
    return {value: undefined as any, label: ""}; //undefined bilan initsializatsiya qilingani uchun T ni noto'g'ri "never" deb xulosa qiladi
}

let options = createOptions<number>(); //Options<number>, LEKIN qiymat faqat xatosiz undefined sifatida o'rnatilishi mumkin


            

              
                Copy
              
            
          

Birinchi misolda TypeScript `T` ni obyekt literalining `value` xususiyati asosida `number` sifatida xulosa qiladi. Biroq, ikkinchi misolda, `createOptions` ning value xususiyatini initsializatsiya qilish orqali, kompilyator `never` ni xulosa qiladi, chunki `undefined` faqat generikni ko'rsatmasdan `never` ga tayinlanishi mumkin. Shu sababli, createOptions ga qilingan har qanday chaqiruv, hatto siz uni aniq o'tkazsangiz ham, generik sifatida `never` ga ega deb xulosa qilinadi. Noto'g'ri tip xulosasini oldini olish uchun bu holda har doim standart umumiy qiymatlarni aniq belgilang.

5. Qayta chaqiruv funksiyalari va Kontekstual Tiplashtirish

Qayta chaqiruv funksiyalaridan foydalanganda, TypeScript qayta chaqiruv parametrlari va qaytariladigan qiymat tiplarini xulosa qilish uchun kontekstual tiplashtirishga tayanadi. Kontekstual tiplashtirish qayta chaqiruv tipining u ishlatilayotgan kontekst tomonidan aniqlanishini anglatadi. Agar kontekst yetarli ma'lumot bermasa, TypeScript tiplarni to'g'ri xulosa qila olmasligi mumkin, bu esa `any` yoki boshqa istalmagan natijalarga olib keladi. Qayta chaqiruv funksiyangiz imzolarini to'g'ri tiplashtirilayotganiga ishonch hosil qilish uchun ularni diqqat bilan tekshiring.

            
function mapArray<T, U>(arr: T[], callback: (item: T, index: number) => U): U[] {
  const result: U[] = [];
  for (let i = 0; i < arr.length; i++) {
    result.push(callback(arr[i], i));
  }
  return result;
}

const numbers = [1, 2, 3];
const strings = mapArray(numbers, (num, index) => `Number ${num} at index ${index}`); // T - number, U - string

// To'liq bo'lmagan kontekstli misol
function processItem<T>(item: T, callback: (item: T) => void) {
  callback(item);
}

processItem(1, (item) => {
  //agar T qayta chaqiruv doirasidan tashqarida xulosa qilinmasa, "item" "any" sifatida xulosa qilinadi
  console.log(item.toFixed(2)); //Tip xavfsizligi yo'q.
});

processItem<number>(1, (item) => {
    //Umumiy parametrni aniq belgilash orqali uning son ekanligini kafolatlaymiz
    console.log(item.toFixed(2)); //Tip xavfsizligi
});

            

              
                Copy
              
            
          

Birinchi misol elementni `number` va qaytarilgan tipni `string` sifatida to'g'ri xulosa qilish uchun kontekstual tiplashtirishdan foydalanadi. Ikkinchi misolda to'liq bo'lmagan kontekst mavjud, shuning uchun u `any` ga qaytadi.

To'liq bo'lmagan Tipni Hal qilish Usullari

Qisman xulosa chiqarish asabiylashtirishi mumkin bo'lsa-da, uni hal qilish va kodingiz tip-xavfsiz ekanligiga ishonch hosil qilish uchun bir nechta strategiyalardan foydalanishingiz mumkin:

1. Aniq Tip Annotatsiyalari

To'liq bo'lmagan xulosa bilan kurashishning eng oddiy usuli - aniq tip annotatsiyalarini taqdim etishdir. Bu TypeScript'ga siz qanday tiplarni kutayotganingizni aniq aytadi va xulosa chiqarish mexanizmini bekor qiladi. Bu, ayniqsa, kompilyator aniqroq tip kerak bo'lganda `any` ni xulosa qilganda foydalidir.

            
const pair: [number, string] = createPair(1, "hello"); //Aniq tip annotatsiyasi

            

              
                Copy
              
            
          

2. Aniq Tip Argumentlari

Umumiy funksiyalarni chaqirganda, siz burchakli qavslar (`<T, U>`) yordamida tip argumentlarini aniq ko'rsatishingiz mumkin. Bu siz ishlatilayotgan tiplarni nazorat qilishni va TypeScript'ning noto'g'ri tiplarni xulosa qilishini oldini olishni istaganingizda foydalidir.

            
const pair = createPair<number, string>(1, "hello"); //Aniq tip argumentlari

            

              
                Copy
              
            
          

3. Umumiy Tiplarni Refaktoring qilish

Ba'zan, umumiy tiplaringizning tuzilishi xulosa chiqarishni qiyinlashtirishi mumkin. Tiplaringizni soddalashtirish yoki aniqroq qilish uchun refaktoring qilish xulosa chiqarishni yaxshilashi mumkin.

            
//Asl, xulosa qilish qiyin bo'lgan tip
type ComplexType<A, B, C> = {
  a: A;
  b: (a: A) => B;
  c: (b: B) => C;
};

//Refaktoring qilingan, xulosa qilish osonroq tip
interface AType {value: string};
interface BType {data: number};
interface CType {success: boolean};

type SimplerType = {
  a: AType;
  b: (a: AType) => BType;
  c: (b: BType) => CType;
};



            

              
                Copy
              
            
          

4. Tip Tasdiqlaridan foydalanish

Tip tasdiqlari sizga kompilyatorga bir ifodaning tipi haqida undan ko'proq bilishingizni aytishga imkon beradi. Ulardan ehtiyotkorlik bilan foydalaning, chunki noto'g'ri ishlatilsa, ular xatolarni yashirishi mumkin. Biroq, siz tipga ishonchingiz komil bo'lgan va TypeScript uni xulosa qila olmaydigan vaziyatlarda ular foydalidir.

            
const value: any = getValueFromSomewhere(); //getValueFromSomewhere "any" qaytaradi deb faraz qilaylik
const numberValue = value as number; //Tip tasdig'i
console.log(numberValue.toFixed(2)); //Endi kompilyator qiymatni son sifatida qabul qiladi

            

              
                Copy
              
            
          

5. Yordamchi Tiplardan foydalanish

TypeScript tip manipulyatsiyasi va xulosa chiqarishga yordam beradigan bir qator o'rnatilgan yordamchi tiplarni taqdim etadi. `Partial`, `Required`, `Readonly` va `Pick` kabi tiplar mavjud tiplar asosida yangi tiplar yaratish uchun ishlatilishi mumkin, bu esa ko'pincha jarayonda xulosa chiqarishni yaxshilaydi.

            
interface User {
  id: number;
  name: string;
  email?: string;
}

//Barcha xususiyatlarni majburiy qilish
type RequiredUser = Required<User>;

function createUser(user: RequiredUser): void {
  console.log(user.id, user.name, user.email);
}

createUser({ id: 1, name: "John", email: "john@example.com" }); //Xato yo'q

//Xususiyatlarning bir qismini tanlash uchun Pick'dan foydalanish misoli
type NameAndEmail = Pick<User, 'name' | 'email'>;

function displayDetails(details: NameAndEmail){
    console.log(details.name, details.email);
}

displayDetails({name: "Alice", email: "test@test.com"});

            

              
                Copy
              
            
          

6. `any` ga muqobil variantlarni ko'rib chiqish

`any` tez yechim sifatida jozibali bo'lishi mumkin bo'lsa-da, u tip tekshiruvini samarali ravishda o'chirib qo'yadi va ish vaqtida xatolarga olib kelishi mumkin. Iloji boricha `any` dan foydalanishdan qochishga harakat qiling. Buning o'rniga, `unknown` kabi muqobillarni o'rganing, bu sizni qiymatni ishlatishdan oldin tip tekshiruvlarini bajarishga majbur qiladi, yoki aniqroq tip annotatsiyalaridan foydalaning.

            
let unknownValue: unknown = getValueFromSomewhere();

if (typeof unknownValue === 'number') {
  console.log(unknownValue.toFixed(2)); //Ishlatishdan oldin tipni tekshirish
}

            

              
                Copy
              
            
          

7. Tip Himoyachilaridan foydalanish

Tip himoyachilari - bu ma'lum bir doira ichida o'zgaruvchining tipini toraytiradigan funksiyalardir. Ular, ayniqsa, birlashma tiplari bilan ishlaganda yoki ish vaqtida tip tekshiruvi o'tkazish kerak bo'lganda foydalidir. TypeScript tip himoyachilarini taniydi va ulardan himoyalangan doira ichidagi o'zgaruvchilarning tiplarini aniqlashtirish uchun foydalanadi.

            
type StringOrNumber = string | number;

function processValueWithTypeGuard(value: StringOrNumber): void {
  if (typeof value === 'string') {
    console.log(value.toUpperCase()); //TypeScript bu yerda qiymatning string ekanligini biladi
  } else {
    console.log(value.toFixed(2));    //TypeScript bu yerda qiymatning son ekanligini biladi
  }
}

            

              
                Copy
              
            
          

Qisman Xulosa Chiqarish Muammolarini Oldini olish bo'yicha Eng Yaxshi Amaliyotlar

Qisman xulosa chiqarish muammolariga duch kelish xavfini kamaytirish uchun quyidagi umumiy eng yaxshi amaliyotlarga amal qiling:

• Tiplaringiz bilan aniq bo'ling: Faqat xulosa chiqarishga tayanmang, ayniqsa murakkab holatlarda. Aniq tip annotatsiyalarini taqdim etish kompilyatorga sizning niyatlaringizni tushunishga yordam beradi va kutilmagan tip xatolarining oldini oladi.
• Umumiy tiplaringizni sodda saqlang: Chuqur joylashtirilgan yoki haddan tashqari murakkab umumiy tiplardan saqlaning, chunki ular xulosa chiqarishni qiyinlashtirishi mumkin. Murakkab tiplarni kichikroq, boshqariladigan qismlarga bo'ling.
• Kodingizni puxta sinovdan o'tkazing: Kodingiz turli tiplar bilan kutilganidek ishlashini tekshirish uchun birlik testlarini yozing. Xulosa chiqarish muammoli bo'lishi mumkin bo'lgan chekka holatlar va stsenariylarga alohida e'tibor bering.
• Qattiq TypeScript konfiguratsiyasidan foydalaning: `tsconfig.json` faylingizda `strictNullChecks`, `noImplicitAny` va `strictFunctionTypes` kabi qattiq rejim opsiyalarini yoqing. Bu opsiyalar sizga potentsial tip xatolarini erta aniqlashga yordam beradi.
• TypeScript'ning xulosa chiqarish qoidalarini tushuning: TypeScript'ning xulosa chiqarish algoritmi qanday ishlashi bilan tanishing. Bu sizga potentsial xulosa chiqarish muammolarini oldindan ko'rishga va kompilyator uchun tushunish osonroq bo'lgan kod yozishga yordam beradi.
• Aniqlik uchun refaktoring qiling: Agar tip xulosasi bilan qiynalayotgan bo'lsangiz, tiplarni aniqroq qilish uchun kodingizni refaktoring qilishni o'ylab ko'ring. Ba'zan, kodingiz tuzilishidagi kichik o'zgarish tip xulosasini sezilarli darajada yaxshilashi mumkin.

Xulosa

Qisman tip xulosasi TypeScript tiplar tizimining nozik, ammo muhim jihatidir. U qanday ishlashini va qaysi holatlarda yuzaga kelishi mumkinligini tushunib, siz yanada mustahkam va qo'llab-quvvatlanadigan kod yozishingiz mumkin. Aniq tip annotatsiyalari, umumiy tiplarni refaktoring qilish va tip himoyachilaridan foydalanish kabi strategiyalarni qo'llash orqali siz to'liq bo'lmagan tipni hal qilishni samarali bartaraf etishingiz va TypeScript kodingiz iloji boricha tip-xavfsiz bo'lishini ta'minlashingiz mumkin. Murakkab umumiy tiplar, shartli tiplar va obyekt literallari bilan ishlaganda potentsial xulosa chiqarish muammolarini yodda tuting. TypeScript tiplar tizimining kuchini qabul qiling va undan ishonchli va kengaytiriladigan ilovalar yaratish uchun foydalaning.