TypeScript Xaritalangan Turlari: Ob'ektni Transformatsiya Qilish va Xususiyatlarni O'zgartirishni O'zlashtirish

Dasturiy ta'minotni ishlab chiqishning doimiy rivojlanib borayotgan landshaftida mustahkam tur tizimlari texnik xizmat ko'rsatishga yaroqli, kengaytiriladigan va ishonchli ilovalarni yaratish uchun juda muhimdir. TypeScript, o'zining kuchli tur xulosalari va ilg'or xususiyatlari bilan butun dunyo bo'ylab dasturchilar uchun ajralmas vositaga aylandi. Uning eng kuchli imkoniyatlari orasida mavjud ob'ekt turlarini yangilariga aylantirishga imkon beradigan murakkab mexanizm bo'lgan Xaritalangan Turlar mavjud. Ushbu blog posti TypeScript Xaritalangan Turlari dunyosiga chuqur kirib boradi, ularning asosiy tushunchalarini, amaliy ilovalarini va ular dasturchilarga ob'ekt transformatsiyasi va xususiyatlarni o'zgartirishni qanday qilib oqlangan tarzda hal qilishga imkon berishini o'rganadi.

Xaritalangan Turlarning Asosiy Tushunchasini Tushunish

O'z mohiyatiga ko'ra, Xaritalangan Tur - bu mavjud tur xususiyatlari bo'ylab takrorlash orqali yangi turlarni yaratish usuli. Buni turlar uchun loop deb o'ylang. Asl turdagi har bir xususiyat uchun siz uning kalitiga, qiymatiga yoki ikkalasiga ham o'zgartirish kiritishingiz mumkin. Bu qo'lda takrorlamasdan, mavjudlar asosida yangi tur ta'riflarini yaratish uchun ulkan imkoniyatlar yaratadi.

Xaritalangan Tur uchun asosiy sintaksis { [P in K]: T } tuzilishini o'z ichiga oladi, bu erda:

• P: Takrorlanayotgan xususiyat nomini bildiradi.
• in K: Bu muhim qism bo'lib, P K turidan har bir kalitni (odatda string literallar birikmasi yoki keyof turi) oladi.
• T: Yangi turdagi P xususiyati uchun qiymat turini belgilaydi.

Keling, oddiy misoldan boshlaylik. Tasavvur qiling, sizda foydalanuvchi ma'lumotlarini ifodalovchi ob'ekt bor va siz barcha xususiyatlar ixtiyoriy bo'lgan yangi tur yaratmoqchisiz. Bu, masalan, konfiguratsiya ob'ektlarini yaratishda yoki qisman yangilanishlarni amalga oshirishda keng tarqalgan ssenariy.

1-misol: Barcha Xususiyatlarni Ixtiyoriy Qilish

Ushbu asosiy turni ko'rib chiqing:

            
type User = {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
};

            

              
                Copy
              
            
          

Biz Xaritalangan Tur yordamida barcha xususiyatlar ixtiyoriy bo'lgan yangi OptionalUser turini yaratishimiz mumkin:

            
type OptionalUser = {
  [P in keyof User]?: User[P];
};

            

              
                Copy
              
            
          

Keling, buni tahlil qilaylik:

• keyof User: Bu User turidagi kalitlar birikmasini hosil qiladi (masalan, 'id' | 'name' | 'email' | 'isActive').
• P in keyof User: Bu birikmadagi har bir kalit bo'ylab takrorlanadi.
• ?: Bu xususiyatni ixtiyoriy qiladigan modifikator.
• User[P]: Bu qidiruv turi. Har bir P kaliti uchun u asl User turidan mos keladigan qiymat turini oladi.

Natijada OptionalUser turi quyidagicha ko'rinadi:

            
{
  id?: number;
  name?: string;
  email?: string;
  isActive?: boolean;
}

            

              
                Copy
              
            
          

Bu juda kuchli. Har bir xususiyatni qo'lda ? bilan qayta ta'riflash o'rniga, biz turini dinamik ravishda yaratdik. Bu printsipni boshqa ko'plab yordamchi turlarni yaratish uchun kengaytirish mumkin.

Xaritalangan Turlardagi Umumiy Xususiyat Modifikatorlari

• Ixtiyoriylik: ? modifikatorini qo'shish yoki olib tashlash.
• Faqat o'qish: readonly modifikatorini qo'shish yoki olib tashlash.
• Nullik/Null bo'lmaslik: | null yoki | undefined qo'shish yoki olib tashlash.

2-misol: Turning Faqat O'qish Versiyasini Yaratish

Xususiyatlarni ixtiyoriy qilishga o'xshab, biz ReadonlyUser turini yaratishimiz mumkin:

            
type ReadonlyUser = {
  readonly [P in keyof User]: User[P];
};

            

              
                Copy
              
            
          

Bu quyidagilarni hosil qiladi:

            
{
  readonly id: number;
  readonly name: string;
  readonly email: string;
  readonly isActive: boolean;
}

            

              
                Copy
              
            
          

Bu ma'lumotlar tuzilmalari bir marta yaratilgandan so'ng, o'zgartirilmasligini ta'minlash uchun juda foydali, bu esa mustahkam, bashorat qilinadigan tizimlarni yaratish uchun asosiy printsipdir, ayniqsa, bir vaqtning o'zida ishlaydigan muhitlarda yoki ko'plab xalqaro rivojlanish jamoalari tomonidan qabul qilingan funktsional dasturlash paradigmalarida mashhur bo'lgan o'zgarmas ma'lumotlar naqshlari bilan ishlashda.

3-misol: Ixtiyoriylik va Faqat O'qishni Birlashtirish

Biz modifikatorlarni birlashtira olamiz. Misol uchun, xususiyatlar ham ixtiyoriy, ham faqat o'qish mumkin bo'lgan tur:

            
type OptionalReadonlyUser = {
  readonly [P in keyof User]?: User[P];
};

            

              
                Copy
              
            
          

Bu quyidagiga olib keladi:

            
{
  readonly id?: number;
  readonly name?: string;
  readonly email?: string;
  readonly isActive?: boolean;
}

            

              
                Copy
              
            
          

Xaritalangan Turlar bilan Modifikatorlarni Olbol Tashlash

Agar siz modifikatorni olib tashlamoqchi bo'lsangiz nima bo'ladi? TypeScript Xaritalangan Turlar ichida -? va -readonly sintaksisidan foydalanishga imkon beradi. Bu, ayniqsa, mavjud yordamchi turlar yoki murakkab tur kompozitsiyalari bilan ishlashda juda kuchli.

Deylik, sizda Partial<T> turi bor (bu o'rnatilgan va barcha xususiyatlarni ixtiyoriy qiladi) va siz Partial<T> bilan bir xil tur yaratmoqchisiz, lekin barcha xususiyatlar yana majburiy qilingan.

            
type Mandatory<T> = {
  -?: T extends object ? T[keyof T] : never;
};

type FullyPopulatedUser = Mandatory<Partial<User>>;

            

              
                Copy
              
            
          

Bu qarama-qarshi tuyuladi. Keling, buni tahlil qilaylik:

Partial<User> bizning OptionalUser ga teng. Endi biz uning xususiyatlarini majburiy qilishni xohlaymiz. -? sintaksisi ixtiyoriy modifikatorni olib tashlaydi.

Bunga erishishning to'g'ridan-to'g'ri usuli, avval Partial ga tayanmasdan, shunchaki asl turni olish va agar u ixtiyoriy bo'lsa, uni majburiy qilishdir:

            
type MakeMandatory<T> = {
  -?: T;
};

type MandatoryUser = MakeMandatory<OptionalUser>;

            

              
                Copy
              
            
          

Bu OptionalUser ni asl User tur tuzilishiga to'g'ri qaytaradi (barcha xususiyatlar mavjud va talab qilinadi).

Xuddi shunday, readonly modifikatorini olib tashlash uchun:

            
type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
};

type MutableUser = Mutable<ReadonlyUser>;

            

              
                Copy
              
            
          

MutableUser asl User turiga teng bo'ladi, lekin uning xususiyatlari faqat o'qish mumkin bo'lmaydi.

Nullik va Belgilanmaslik

Siz shuningdek, nullikni nazorat qilishingiz mumkin. Misol uchun, barcha xususiyatlar aniq null bo'lmasligini ta'minlash uchun:

            
type NonNullableValues<T> = {
  [P in keyof T]-?: NonNullable<T[P]>;
};

interface MaybeNull {
  name: string | null;
  age: number | undefined;
}

type DefiniteValues = NonNullableValues<MaybeNull>;
// type DefiniteValues = {
//   name: string;
//   age: number;
// }

            

              
                Copy
              
            
          

Bu erda -? xususiyatlar ixtiyoriy emasligini ta'minlaydi va NonNullable<T[P]> qiymat turidan null va undefined ni olib tashlaydi.

Xususiyat Kalitlarini Transformatsiya Qilish

4-misol: Xususiyat Kalitlariga Prefiks Qo'shish

            
type Prefixed<T, Prefix extends string> = {
  [P in keyof T as `${Prefix}${Capitalize<string & P>}`]: T[P];
};

type OriginalConfig = {
  timeout: number;
  retries: number;
};

type PrefixedConfig = Prefixed<OriginalConfig, 'app'>;
// type PrefixedConfig = {
//   appTimeout: number;
//   appRetries: number;
// }

            

              
                Copy
              
            
          

Keling, kalit transformatsiyasini tahlil qilaylik:

• P in keyof T: Hali ham asl kalitlar bo'ylab takrorlanadi.
• as `${Prefix}${Capitalize<string & P>}`: Bu kalitni qayta xaritalash bandi.
• `${Prefix}${...}`: Bu taqdim etilgan Prefixni o'zgartirilgan xususiyat nomi bilan birlashtirib, yangi kalit nomini yaratish uchun shablon literal turlaridan foydalanadi.
• Capitalize<string & P>: Bu xususiyat nomi P string sifatida qabul qilinishini ta'minlash va keyin katta harf bilan yozish uchun umumiy naqsh. Biz P ni string bilan kesishgan string & P dan foydalanamiz va TypeScript uni string turi sifatida qabul qilishini ta'minlaymiz, bu esa Capitalize uchun zarur.

Ushbu misol sizning xususiyatlarni mavjudlar asosida dinamik ravishda qanday qilib qayta nomlashingiz mumkinligini ko'rsatadi, bu ilovaning turli qatlamlarida izchillikni saqlash yoki o'ziga xos nomlash konventsiyalari bo'lgan tashqi tizimlar bilan integratsiya qilish uchun kuchli texnikadir.

5-misol: Xususiyatlarni Filtrlash

Agar siz faqat ma'lum bir shartni qondiradigan xususiyatlarni kiritmoqchi bo'lsangiz nima bo'ladi? Bunga Xaritalangan Turlarni Shartli Turlar bilan birlashtirib va kalitni qayta xaritalash uchun as bandi bilan erishish mumkin, ko'pincha xususiyatlarni filtrlash uchun.

            
type OnlyStrings<T> = {
  [P in keyof T as T[P] extends string ? P : never]: T[P];
};

interface MixedData {
  name: string;
  age: number;
  city: string;
  isActive: boolean;
}

type StringOnlyData = OnlyStrings<MixedData>;
// type StringOnlyData = {
//   name: string;
//   city: string;
// }

            

              
                Copy
              
            
          

Bu holda:

• T[P] extends string ? P : never: Har bir P xususiyati uchun biz uning qiymat turi (T[P]) string ga tayinlanishi mumkinligini tekshiramiz.
• Agar u string bo'lsa, P kaliti saqlanadi.
• Agar u string bo'lmasa, u never ga xaritalanadi. Kalit never ga xaritalanganda, u natijada olingan ob'ekt turidan samarali ravishda olib tashlanadi.

Ushbu texnika kengroq turlardan aniqroq turlarni yaratish uchun bebaho hisoblanadi, masalan, faqat ma'lum bir turdagi konfiguratsiya sozlamalarini ajratib olish yoki ma'lumotlar maydonlarini ularning mohiyatiga ko'ra ajratish.

6-misol: Kalitlarni Boshqa Shaklga Transformatsiya Qilish

Siz shuningdek, kalitlarni butunlay boshqa turdagi kalitlarga aylantirishingiz mumkin, masalan, string kalitlarni raqamlarga aylantirish yoki aksincha, garchi bu to'g'ridan-to'g'ri ob'ekt manipulyatsiyasi uchun kamroq tarqalgan bo'lsa va ko'proq ilg'or tur darajasidagi dasturlash uchun.

String kalitlarni string literallar birikmasiga aylantirishni ko'rib chiqing va keyin undan yangi tur uchun asos sifatida foydalaning. Ob'ektning kalitlarini *ichida* to'g'ridan-to'g'ri Xaritalangan Turda o'zgartirmasa ham, u kalitlarning qanday manipulyatsiya qilinishi mumkinligini ko'rsatadi.

To'g'ridan-to'g'ri kalit transformatsiyasi misoli kalitlarni ularning katta harfli versiyalariga xaritalash bo'lishi mumkin:

            
type UppercaseKeys<T> = {
  [P in keyof T as Uppercase<string & P>]: T[P];
};

type LowercaseData = {
  firstName: string;
  lastName: string;
};

type UppercaseData = UppercaseKeys<LowercaseData>;
// type UppercaseData = {
//   FIRSTNAME: string;
//   LASTNAME: string;
// }

            

              
                Copy
              
            
          

Bu har bir P kalitini uning katta harfli ekvivalentiga aylantirish uchun as bandidan foydalanadi.

Amaliy Ilovalar va Haqiqiy Dunyo Ssenariylari

1. Qayta Ishlatiladigan Yordamchi Turlarni Yaratish

Ko'p umumiy tur transformatsiyalarini qayta ishlatiladigan yordamchi turlarga kiritish mumkin. TypeScript standarti kutubxonasi allaqachon Partial<T>, Readonly<T>, Record<K, T> va Pick<T, K> kabi ajoyib misollarni taqdim etadi. Ishlab chiqish jarayonini soddalashtirish uchun Xaritalangan Turlardan foydalanib o'zingizning shaxsiy yordamchi turlaringizni belgilashingiz mumkin.

Misol uchun, barcha xususiyatlarni asl qiymatni qabul qiladigan va yangi qiymatni qaytaradigan funktsiyalarga xaritalaydigan tur:

            
type Mappers<T> = {
  [P in keyof T]: (value: T[P]) => T[P];
};

interface ProductInfo {
  name: string;
  price: number;
}

type ProductMappers = Mappers<ProductInfo>;
// type ProductMappers = {
//   name: (value: string) => string;
//   price: (value: number) => number;
// }

            

              
                Copy
              
            
          

2. Dinamik Formani Boshqarish va Validatsiya

Frontendni ishlab chiqishda, ayniqsa React yoki Angular kabi ramkalar bilan (garchi bu erda misollar sof TypeScript bo'lsa ham), formalarni va ularning validatsiya holatlarini boshqarish keng tarqalgan vazifa. Xaritalangan Turlar har bir forma maydonining validatsiya holatini boshqarishga yordam beradi.

'Toza', 'tegizilgan', 'yaroqli' yoki 'yaroqsiz' bo'lishi mumkin bo'lgan maydonlarga ega formani ko'rib chiqing.

            
type FormFieldState = 'pristine' | 'touched' | 'dirty' | 'valid' | 'invalid';

type FormState<T> = {
  [P in keyof T]: FormFieldState;
};

interface UserForm {
  username: string;
  email: string;
  password: string;
}

type UserFormState = FormState<UserForm>;
// type UserFormState = {
//   username: FormFieldState;
//   email: FormFieldState;
//   password: FormFieldState;
// }

            

              
                Copy
              
            
          

Bu sizga forma ma'lumotlar tuzilishini aks ettiradigan tur yaratishga imkon beradi, lekin buning o'rniga har bir maydonning holatini kuzatib boradi, forma boshqaruv mantiqingiz uchun izchillik va tur xavfsizligini ta'minlaydi. Bu, ayniqsa, turli xil UI/UX talablari murakkab forma holatlariga olib kelishi mumkin bo'lgan xalqaro loyihalar uchun foydalidir.

3. API Javobini Transformatsiya Qilish

API bilan ishlashda javob ma'lumotlari har doim ham ichki domen modellariga to'liq mos kelmasligi mumkin. Xaritalangan Turlar API javoblarini kerakli shaklga transformatsiya qilishda yordam berishi mumkin.

Tasavvur qiling, API javobi kalitlar uchun snake_case dan foydalanadi, lekin sizning ilovangiz camelCase ni afzal ko'radi:

            
// Taxmin qilaylik, bu kiruvchi API javob turi
type ApiUserData = {
  user_id: number;
  first_name: string;
  last_name: string;
};

// Kalitlar uchun snake_case dan camelCase ga aylantirish uchun yordamchi
type ToCamelCase<S extends string>: string = S extends `${infer T}_${infer U}`
  ? `${T}${Capitalize<U>}`
  : S;

type CamelCasedKeys<T> = {
  [P in keyof T as ToCamelCase<string & P>]: T[P];
};

type AppUserData = CamelCasedKeys<ApiUserData>;
// type AppUserData = {
//   userId: number;
//   firstName: string;
//   lastName: string;
// }

            

              
                Copy
              
            
          

Bu string manipulyatsiyasi uchun rekursiv shartli turdan foydalangan holda yanada ilg'or misol. Asosiy xulosa shundaki, Xaritalangan Turlar, boshqa ilg'or TypeScript xususiyatlari bilan birgalikda, murakkab ma'lumotlarni transformatsiya qilishni avtomatlashtirishi, ishlab chiqish vaqtini tejashi va runtime xatoliklari xavfini kamaytirishi mumkin. Bu turli xil backend xizmatlari bilan ishlaydigan global jamoalar uchun juda muhimdir.

4. Enumga o'xshash Tuzilmalarni Yaxshilash

TypeScript da `enum`s bo'lsa-da, ba'zida siz ko'proq moslashuvchanlikni xohlashingiz yoki enums kabi harakat qiladigan ob'ekt literallaridan turlarni olishingiz mumkin.

            
const AppPermissions = {
  READ: 'read',
  WRITE: 'write',
  DELETE: 'delete',
  ADMIN: 'admin',
} as const;

type Permission = typeof AppPermissions[keyof typeof AppPermissions];
// type Permission = 'read' | 'write' | 'delete' | 'admin'

type UserPermissions = {
  [P in Permission]?: boolean;
};

type RolePermissions = {
  [P in Permission]: boolean;
};

const userPerms: UserPermissions = {
  read: true,
};

const adminRole: RolePermissions = {
  read: true,
  write: true,
  delete: true,
  admin: true,
};

            

              
                Copy
              
            
          

Bu erda biz avval barcha mumkin bo'lgan ruxsat stringlarining birikma turini olamiz. Keyin, biz Xaritalangan Turlardan har bir ruxsat kalit bo'lgan turlarni yaratish uchun foydalanamiz, bu bizga foydalanuvchining ushbu ruxsatga ega ekanligini (ixtiyoriy) yoki rolning uni majbur qilganligini (talab qilinadi) belgilashga imkon beradi. Ushbu naqsh butun dunyo bo'ylab avtorizatsiya tizimlarida keng tarqalgan.

Qiyinchiliklar va E'tiborga Olish

• O'qilishi va Murakkabligi: Haddan tashqari murakkab Xaritalangan Turlarni o'qish va tushunish qiyinlashishi mumkin, ayniqsa, ushbu ilg'or xususiyatlar bilan yangi tanish bo'lgan dasturchilar uchun. Har doim aniqlikka intiling va izohlar qo'shishni yoki murakkab transformatsiyalarni buzishni o'ylab ko'ring.
• Ishlash Oqibatlari: TypeScript turini tekshirish kompilyatsiya vaqti bo'lsa-da, juda murakkab tur manipulyatsiyalari nazariy jihatdan kompilyatsiya vaqtini biroz oshirishi mumkin. Ko'pgina ilovalar uchun bu ahamiyatsiz, lekin juda katta kod bazalari yoki yuqori unumdorlikka ega bo'lgan qurilish jarayonlari uchun buni yodda tutish kerak.
• Nosozliklarni Tuzatish: Xaritalangan Tur kutilmagan natijani chiqarganda, nosozliklarni tuzatish ba'zan qiyin bo'lishi mumkin. Turlarning qanday hal qilinishini tushunish uchun TypeScript Playground yoki IDE turini tekshirish xususiyatlaridan foydalanish juda muhimdir.
• `keyof` va Qidiruv Turlarini Tushunish: Xaritalangan Turlardan samarali foydalanish `keyof` va qidiruv turlarini (`T[P]`) mustahkam tushunishga asoslanadi. Jamoangiz ushbu asosiy tushunchalarni yaxshi tushunganligiga ishonch hosil qiling.

Xaritalangan Turlardan Foydalanish Bo'yicha Eng Yaxshi Amaliyotlar

• Oddiy Bilan Boshlang: Murakkab kalitni qayta xaritalash yoki shartli mantiqga sho'ng'ishdan oldin asosiy ixtiyoriylik va faqat o'qish transformatsiyalari bilan boshlang.
• O'rnatilgan Yordamchi Turlardan Foydalaning: TypeScript ning o'rnatilgan yordamchi turlari bilan tanishing, masalan, Partial, Readonly, Record, Pick, Omit va Exclude. Ular ko'pincha umumiy vazifalar uchun etarli va yaxshi sinovdan o'tgan va tushunilgan.
• Qayta Ishlatiladigan Umumiy Turlarni Yarating: Umumiy Xaritalangan Tur naqshlarini umumiy yordamchi turlarga kiriting. Bu izchillikni oshiradi va loyihangiz bo'ylab va global jamoalar uchun boilerplate kodini kamaytiradi.
• Tavsiflovchi Nomlardan Foydalaning: Maqsadi (masalan, Optional<T>, DeepReadonly<T>, PrefixedKeys<T, Prefix>)ni ko'rsatish uchun Xaritalangan Turlaringizga va umumiy parametrlariga aniq nom bering.
• O'qilishga Ustunlik Bering: Agar Xaritalangan Tur juda chalkash bo'lib qolsa, xuddi shu natijaga erishishning oddiyroq usuli bormi yoki qo'shilgan murakkablikka arziydimi, o'ylab ko'ring. Ba'zan, biroz ko'proq so'zli, ammo aniqroq tur ta'rifi afzalroqdir.
• Murakkab Turlarni Hujjatlashtiring: Murakkab Xaritalangan Turlar uchun JSDoc izohlarini qo'shing, ularning funksionalligini tushuntiring, ayniqsa turli xil xalqaro jamoa ichida kodni baham ko'rganda.
• Turlaringizni Sinovdan O'tkazing: Xaritalangan Turlaringiz kutilganidek harakat qilishini tekshirish uchun tur sinovlarini yozing yoki misollardan foydalaning. Bu, ayniqsa, nozik xatolarni ushlash qiyin bo'lishi mumkin bo'lgan murakkab transformatsiyalar uchun muhimdir.

Xulosa

TypeScript Xaritalangan Turlari ilg'or tur manipulyatsiyasining asosidir va dasturchilarga ob'ekt turlarini transformatsiya qilish va moslashtirish uchun beqiyos kuch taklif qiladi. Xususiyatlarni ixtiyoriy, faqat o'qish, ularni qayta nomlash yoki murakkab shartlar asosida filtrlash qilmoqchi bo'lsangiz, Xaritalangan Turlar ma'lumotlar tuzilmalaringizni boshqarishning deklarativ, tur xavfsiz va juda ifodali usulini ta'minlaydi.

Ushbu texnikalarni o'zlashtirish orqali siz kodni qayta ishlatishni sezilarli darajada oshirishingiz, tur xavfsizligini yaxshilashingiz va yanada mustahkam va texnik xizmat ko'rsatishga yaroqli ilovalarni yaratishingiz mumkin. TypeScript ishlab chiqishingizni yaxshilash va global auditoriya uchun yuqori sifatli dasturiy ta'minot echimlarini yaratishga hissa qo'shish uchun Xaritalangan Turlarning kuchini qabul qiling. Turli mintaqalardan kelgan dasturchilar bilan hamkorlik qilganingizda, ushbu ilg'or tur naqshlari kod sifati va izchilligini ta'minlash uchun umumiy til bo'lib xizmat qilishi mumkin, bu tur tizimining qat'iyligi orqali potentsial aloqa bo'shliqlarini bartaraf etadi.