Generik Cheklovlar Kengaytirilgan: Keyof Operator vs. Index Access Types Tushuntirilgan

Dasturiy ta'minotni ishlab chiqishning keng va doimo rivojlanib borayotgan landshaftida TypeScript mustahkam, keng qamrovli va parvarish qilinadigan ilovalarni yaratish uchun muhim vosita sifatida paydo bo'ldi. Uning statik turlanish imkoniyatlari butun dunyo bo'ylab ishlab chiquvchilarni xatolarni erta aniqlashga, kodni o'qishni yaxshilashga va turli jamoalar va loyihalar bo'ylab hamkorlikni osonlashtirishga imkon beradi. TypeScript kuchining markazida uning murakkab tur tizimi, xususan, generiklari va ilg'or tur manipulyatsiyasi xususiyatlari yotadi. Ko'p ishlab chiquvchilar asosiy generiklar bilan tanish bo'lsalar-da, TypeScriptni haqiqatda o'zlashtirish uchun generik cheklovlari, keyof operatori va Index Access Types kabi ilg'or tushunchalarni chuqur tushunishni talab qiladi.

Ushbu keng qamrovli qo'llanma TypeScript ko'nikmalarini oshirishni istagan ishlab chiquvchilar uchun mo'ljallangan bo'lib, asoslardan tashqariga chiqib, tilning to'liq ifodali kuchidan foydalanishga qaratilgan. Biz keyof operatori va Index Access Typesning nüanslarini o'rganib chiqib, ularning individual kuchlarini o'rganib, har birini qachon ishlatishni tushunib, va eng muhimi, ularni juda moslashuvchan va tur-xavfsiz kod yaratish uchun qanday birlashtirishni kashf etamiz. Siz global korporativ ilovani, ochiq manbali kutubxonani yaratayotgan bo'lsangiz ham, yoki ko'p madaniyatli dasturiy loyihaga hissa qo'shayotgan bo'lsangiz ham, yuqori sifatli TypeScript yozish uchun ushbu ilg'or usullar ajralmas hisoblanadi.

Keling, haqiqatdan ham ilg'or generik cheklovlar sirlarini ochib, sizning TypeScript dasturingizni kuchaytiramiz!

Asos: TypeScript Generiklarini Tushunish

keyof va Index Access Typesning o'ziga xos jihatlariga sho'ng'ishdan oldin, generiklar tushunchasini mustahkam o'zlashtirish va nima uchun ular zamonaviy dasturiy ta'minotni ishlab chiqishda juda muhim ekanligini tushunish zarur. Generiklar sizga komponentlarni ma'lum bir tur bilan cheklanmasdan, turli xil ma'lumot turlari bilan ishlashga imkon beradigan komponentlarni yozishga imkon beradi. Bu ulkan moslashuvchanlik va qayta ishlatish qobiliyatini ta'minlaydi, ular bugungi tezkor dasturiy rivojlanish muhitlarida, ayniqsa global miqyosda turli xil ma'lumotlar tuzilmalari va biznes mantig'ini qondirishda muhimdir.

Asosiy Generiklar: Moslashuvchan Asos

Tasavvur qiling-a, sizga massivning birinchi elementini qaytaradigan funktsiya kerak. Generiklar bo'lmasa, siz uni shunday yozishingiz mumkin:

            
function getFirstElement(arr: any[]): any {
  if (arr.length === 0) {
    return undefined;
  }
  return arr[0];
}

// Raqamlar bilan foydalanish
const numbers = [1, 2, 3];
const firstNumber = getFirstElement(numbers); // type: any

// Satrlar bilan foydalanish
const names = ['Alice', 'Bob'];
const firstName = getFirstElement(names);   // type: any

// Muammo: Biz turli xil ma'lumotlardan mahrum bo'lamiz!
const lengthOfFirstName = (firstName as string).length; // turga aylantirish talab qilinadi

            

              
                Copy
              
            
          

Bu yerdagi muammo shundaki, any tur xavfsizligini butunlay yo'q qiladi. Generiklar argument turini ushlab olib, uni qaytarish turi sifatida ishlatishga imkon berish orqali buni hal qiladi:

            
function getFirstElement<T>(arr: T[]): T {
  if (arr.length === 0) {
    // Qat'iy sozlamalarga qarab, siz T | undefined ni qaytarishingiz kerak bo'lishi mumkin
    // Oddiylik uchun, bo'sh bo'lmagan massivlarni taxmin qilamiz yoki undefined ni aniq ishlaymiz.
    // Yana bir mustahkam imzo T[] => T | undefined bo'lishi mumkin.
    return undefined as any; // Yoki yanada ehtiyotkorlik bilan ishlang
  }
  return arr[0];
}

const numbers = [1, 2, 3];
const firstNumber = getFirstElement(numbers); // type: number

const names = ['Alice', 'Bob'];
const firstName = getFirstElement(names);   // type: string

// Tur xavfsizligi saqlanadi!
const lengthOfFirstName = firstName.length; // Turga aylantirish talab qilinmaydi, TypeScript buni string ekanligini biladi

            

              
                Copy
              
            
          

Bu yerda <T> tur o'zgaruvchisi T ni e'lon qiladi. Siz getFirstElement ni raqamlar massivi bilan chaqirganingizda, T number ga aylanadi. Siz uni satrlar bilan chaqirganingizda, T string ga aylanadi. Bu generiklar: tur aniqlash va xavfsizlikni yo'qotmasdan qayta ishlatish qobiliyatining asosiy kuchi.

extends bilan Generik Cheklovlar

Generiklar ulkan moslashuvchanlikni ta'minlasa-da, ba'zan generik komponent bilan ishlatilishi mumkin bo'lgan turlarni cheklash kerak bo'ladi. Misol uchun, agar sizning funktsiyangiz ma'lum bir mulkka yoki metodga ega bo'lishi uchun generik tur T ni kutsa nima bo'ladi? Bu yerda generik cheklovlari extends kalit so'zini ishlatib paydo bo'ladi.

Biror elementning ID-sini qayd qiluvchi funktsiyani ko'rib chiqing. Barcha turlarda id mulki mavjud emas. Biz T ni har doim number (yoki talablarga qarab string) tipidagi id mulkiga ega bo'lishini ta'minlash uchun cheklashimiz kerak.

            
interface HasId {
  id: number;
}

function logId<T extends HasId>(item: T): void {
  console.log(`ID: ${item.id}`);
}

// To'g'ri ishlaydi
logId({ id: 1, name: 'Product A' }); // ID: 1
logId({ id: 2, quantity: 10 });    // ID: 2

// Xatolik: Argument of type '{ name: string; }' is not assignable to parameter of type 'HasId'.
// Property 'id' is missing in type '{ name: string; }' but required in type 'HasId'.
// logId({ name: 'Product B' }); 

            

              
                Copy
              
            
          

<T extends HasId> dan foydalanish orqali biz TypeScriptga T HasId ga tayinlanishi kerakligini aytamiz. Bu logId ga o'tkazilgan har qanday ob'ektda id: number mulki mavjud bo'lishini ta'minlaydi, bu tur xavfsizligini ta'minlaydi va ish vaqti xatolarini oldini oladi. Generiklar va cheklovlar haqidagi ushbu asosiy tushuncha biz yanada murakkab tur manipulyatsiyalariga kirishganimizda muhimdir.

Chuqurlashib Kirish: keyof Operator

keyof operatori TypeScriptdagi kuchli vositadir, u har qanday turdagi barcha ommaviy mulk nomlarini (kalitlarini) string literal union tipiga chiqarishga imkon beradi. Buni ob'ektga xos mulkni kirish uchun barcha mumkin bo'lgan kalitlar ro'yxatini yaratish deb o'ylab ko'ring. Bu, ayniqsa, ma'lumotlarni qayta ishlash, konfiguratsiya va turli global ilovalar bo'ylab UI dasturlashda keng tarqalgan talab bo'lgan ob'ekt mulklarida ishlaydigan juda moslashuvchan, ammo tur-xavfsiz funktsiyalarni yaratish uchun juda foydali.

keyof Nima Ishlaydi

Oddiy qilib aytganda, T ob'ekt turi uchun, keyof T T mulklarining nomlarini ifodalovchi string literal turlarning ittifoqini hosil qiladi. Bu "Ushbu turdagi ob'ektga mulklarga kirish uchun qanday kalitlarni ishlatishim mumkin?" degan savolga o'xshaydi.

Sintaksis va Asosiy Foydalanish

Sintaksis oddiy: keyof TypeName.

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

type UserKeys = keyof User; // Type 'id' | 'name' | 'email' | 'age' dir

const userKey: UserKeys = 'name'; // To'g'ri
// const invalidKey: UserKeys = 'address'; // Xatolik: Type '"address"' is not assignable to type 'UserKeys'.

class Product {
  public productId: string;
  private _cost: number;
  protected _warehouseId: string;

  constructor(id: string, cost: number) {
    this.productId = id;
    this._cost = cost;
    this._warehouseId = 'default';
  }

  public getCost(): number {
    return this._cost;
  }
}

type ProductKeys = keyof Product; // Type 'productId' | 'getCost' dir
// Eslatma: Class uchun private va protected a'zolar keyof ga kiritilmaydi,
// chunki ular ommaviy ravishda kirish mumkin emas.

            

              
                Copy
              
            
          

Ko'rib turganingizdek, keyof ommaviy ravishda kirish mumkin bo'lgan barcha mulk nomlarini, shu jumladan metodlarni (funksiya qiymatlarini saqlaydigan mulklar), lekin private va protected a'zolarni istisno qiladi. Ushbu xatti-harakat uning maqsadiga mos keladi: mulkka kirish uchun yaroqli kalitlarni aniqlash.

Generik Cheklovlardagi keyof

keyof ning haqiqiy kuchi generik cheklovlar bilan birlashtirilganda yorqinlashadi. Ushbu kombinatsiya sizga har qanday ob'ekt bilan ishlaydigan, lekin faqat o'sha ob'ektda mavjud bo'lgan mulklar bilan ishlaydigan funktsiyalarni yozishga imkon beradi, bu esa kompilyatsiya vaqtida tur xavfsizligini ta'minlaydi.

Ob'ektning mulk qiymatini xavfsiz olish uchun odatiy holni ko'rib chiqing.

1-misol: getProperty funksiyasini yaratish

keyof bo'lmasa, siz any yoki kamroq xavfsiz yondashuvga murojaat qilishingiz mumkin edi:

            
function getPropertyUnsafe(obj: any, key: string): any {
  return obj[key];
}

const myUser = { id: 1, name: 'Charlie' };
const userName = getPropertyUnsafe(myUser, 'name');  // 'Charlie' ni qaytaradi, lekin turi any
const userAddress = getPropertyUnsafe(myUser, 'address'); // undefined ni qaytaradi, kompilyatsiya vaqtida xatolik yo'q

            

              
                Copy
              
            
          

Endi, ushbu funktsiyani mustahkam va tur-xavfsiz qilish uchun keyof ni kiritaylik:

            
/**
 * Ob'ektdan mulkni xavfsiz oladi.
 * @template T Ob'ekt turi.
 * @template K K turi, T ning kaliti bo'lishiga cheklangan.
 * @param obj Tekshiriladigan ob'ekt.
 * @param key Olinadigan kalit (mulkiy nom).
 * @returns Berilgan kalitdagi mulk qiymati.
 */
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

interface Employee {
  employeeId: number;
  firstName: string;
  lastName: string;
  department: string;
}

const employee: Employee = {
  employeeId: 101,
  firstName: 'Anna',
  lastName: 'Johnson',
  department: 'Engineering'
};

// To'g'ri foydalanish:
const empFirstName = getProperty(employee, 'firstName'); // type: string, value: 'Anna'
console.log(`Employee First Name: ${empFirstName}`);

const empId = getProperty(employee, 'employeeId');     // type: number, value: 101
console.log(`Employee ID: ${empId}`);

// Noto'g'ri foydalanish (kompilyatsiya vaqtida xatolik):
// Argument of type '"salary"' is not assignable to parameter of type '"employeeId" | "firstName" | "lastName" | "department"'.
// const empSalary = getProperty(employee, 'salary'); 

interface Configuration {
  locale: 'en-US' | 'es-ES' | 'fr-FR';
  theme: 'light' | 'dark';
  maxItemsPerPage: number;
}

const appConfig: Configuration = {
  locale: 'en-US',
  theme: 'dark',
  maxItemsPerPage: 20
};

const currentTheme = getProperty(appConfig, 'theme'); // type: 'light' | 'dark', value: 'dark'
console.log(`Current Theme: ${currentTheme}`);

            

              
                Copy
              
            
          

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] ni qarab chiqamiz:

• <T>: Ob'ekt uchun generik tur parametri T ni e'lon qiladi.
• <K extends keyof T>: Kalit uchun generik tur parametri K ni e'lon qiladi. Bu muhim qism. U K ni T ning kalitlarini ifodalovchi string literal turlaridan biri bo'lishiga cheklaydi. Agar T Employee bo'lsa, unda K 'employeeId' | 'firstName' | 'lastName' | 'department' bo'lishi kerak.
• (obj: T, key: K): Funktsiya parametrlari. obj T turiga, key esa K turiga ega.
• : T[K]: Bu Index Access Type (keyinchalik batafsil ko'rib chiqamiz), bu yerda qaytarish turini belgilash uchun ishlatiladi. Bu "ob'ekt turi T ichidagi K kalitidagi mulk turi" degan ma'noni anglatadi. Agar T Employee bo'lsa va K 'firstName' bo'lsa, unda T[K] string ga aylanadi. Agar K 'employeeId' bo'lsa, u number ga aylanadi.

keyof Cheklovlarining Afzalliklari

• Kompilyatsiya vaqtida xavfsizlik: Mavjud bo'lmagan mulklarga kirishni oldini oladi, ish vaqti xatolarini kamaytiradi.
• Yaxshilangan Dasturchi Tajribasi: Funktsiyani chaqirayotganda kalitlar uchun aqlli avtomatik to'ldirish takliflarini taqdim etadi.
• Kengaytirilgan O'qish Qobiliyati: Tur imzo-sig'rafi kalit ob'ektga tegishli ekanligini aniq bildiradi.
• Mustahkam Refaktoring: Agar siz Employee dagi mulkni qayta nomlasangiz, TypeScript eski kalitdan foydalanadigan getProperty chaqiruvlarini darhol bildiradi.

Ilg'or keyof Ssenariylari

Kalitlar bo'ylab Iteratsiya

keyof operatorining o'zi turli operator bo'lsa-da, u ko'pincha ob'ekt kalitlari bo'ylab iteratsiya qiluvchi funktsiyalarni qanday loyihalash mumkinligini bildiradi, foydalanilayotgan kalitlarning har doim yaroqli bo'lishini ta'minlaydi.

            
function logAllProperties<T extends object>(obj: T): void {
  // Bu yerda, Object.keys string[] ni qaytaradi, keyof T emas, shuning uchun biz ko'pincha tasdiqlashlar
  // yoki ehtiyot bo'lishimiz kerak. Biroq, keyof T bizning tur xavfsizligi uchun fikrlashimizni yo'naltiradi.
  (Object.keys(obj) as Array<keyof T>).forEach(key => {
    // Biz 'key' 'obj' uchun yaroqli kalit ekanligini bilamiz
    console.log(`${String(key)}: ${obj[key]}`);
  });
}

interface MenuItem {
  id: string;
  label: string;
  price: number;
  available: boolean;
}

const coffee: MenuItem = {
  id: 'cappuccino',
  label: 'Cappuccino',
  price: 4.50,
  available: true
};

logAllProperties(coffee);
// Chiqarish:
// id: cappuccino
// label: Cappuccino
// price: 4.5
// available: true

            

              
                Copy
              
            
          

Ushbu misolda, keyof T kompilyatsiya vaqtida TypeScript tizimi mumkin bo'lgan JavaScript runtime-idan qanchalik kam turga ega ekanligini hisobga olgan holda, to'liq tur-xavfsiz dunyoda Object.keys qaytarishi kerak bo'lgan narsalar uchun tushunchaviy yo'naltiruvchi printsip sifatida ishlaydi. Tez-tez tur tasdiqlash as Array<keyof T> talab qilinadi.

keyof Ittifoq Turlari bilan

Agar siz ittifoq turiga keyof ni qo'llasangiz, u ittifoqdagi barcha turlardan kalitlarning kesishmasini qaytaradi. Bu degani, u faqat ittifoqning *barcha* a'zolari uchun umumiy bo'lgan kalitlarni o'z ichiga oladi.

            
interface Apple {
  color: string;
  sweetness: number;
}

interface Orange {
  color: string;
  citrus: boolean;
}

type Fruit = Apple | Orange;

type FruitKeys = keyof Fruit; // Type 'color' dir
// 'sweetness' faqat Apple da, 'citrus' faqat Orange da.
// 'color' ikkalasida ham umumiy.

            

              
                Copy
              
            
          

Ushbu xatti-harakatni yodda tutish muhimdir, chunki u FruitKeys dan olingan har qanday kalit har doim Fruit turidagi *har qanday* ob'ektda (Apple yoki Orange bo'lishidan qat'iy nazar) yaroqli mulk bo'lishini ta'minlaydi. Bu polimorfik ma'lumotlar tuzilmalari bilan ishlayotganda ish vaqti xatolarini oldini oladi.

keyof bilan typeof

Konfiguratsiya ob'ektlari yoki konstantalar bilan ishlashda, ayniqsa foydali bo'lgan, qiymatdan to'g'ridan-to'g'ri uning qiymatidan ob'ekt turining kalitlarini chiqarish uchun keyof ni typeof bilan birga ishlatishingiz mumkin.

            
const APP_SETTINGS = {
  API_URL: 'https://api.example.com',
  TIMEOUT_MS: 5000,
  DEBUG_MODE: false
};

type AppSettingKeys = keyof typeof APP_SETTINGS; // Type 'API_URL' | 'TIMEOUT_MS' | 'DEBUG_MODE' dir

function getAppSetting<K extends AppSettingKeys>(key: K): (typeof APP_SETTINGS)[K] {
  return APP_SETTINGS[key];
}

const apiUrl = getAppSetting('API_URL'); // type: string
const debugMode = getAppSetting('DEBUG_MODE'); // type: boolean
// const invalidSetting = getAppSetting('LOG_LEVEL'); // Xatolik

            

              
                Copy
              
            
          

Ushbu naqsh global konfiguratsiya ob'ektlari bilan ishlayotganda tur xavfsizligini ta'minlash uchun juda samarali bo'lib, turli modullar va jamoalar bo'ylab bir xillikni ta'minlaydi, ayniqsa turli xil hissa qo'shuvchilarga ega bo'lgan katta loyihalarda qimmatlidir.

Index Access Typesni Ochish (Lookup Types)

keyof mulklar nomlarini bersa, Index Access Type (Lookup Type deb ham ataladi) ma'lum bir mulkning turini boshqa turdan chiqarishga imkon beradi. Bu "Ushbu ob'ekt turi ichidagi ma'lum bir kalitdagi qiymat turi nima?" degan savolga o'xshaydi. Ushbu imkoniyat mavjud turlardan olingan turlarni yaratish uchun asosiy hisoblanadi, bu esa tur ta'riflarida qayta ishlatish va takrorlanishni kamaytiradi.

Index Access Types Nima Ishlaydi

Index Access Type tur darajasida qavslardan (JavaScriptda mulklarga kirish kabi) foydalanadi, bu esa mulk kalitiga bog'langan turini qidirib topadi. Bu turlarni turlarning tuzilishiga asoslanib dinamik ravishda yaratish uchun juda muhimdir.

Sintaksis va Asosiy Foydalanish

Sintaksis TypeName[KeyType] bo'lib, bu yerda KeyType odatda TypeName ning yaroqli kalitlariga mos keladigan string literal turi yoki string literal turlarning ittifoqidir.

            
interface ProductInfo {
  name: string;
  price: number;
  category: 'Electronics' | 'Apparel' | 'Books';
  details: { weight: string; dimensions: string };
}

type ProductNameType = ProductInfo['name'];     // Type 'string' dir
type ProductPriceType = ProductInfo['price'];    // Type 'number' dir
type ProductCategoryType = ProductInfo['category']; // Type 'Electronics' | 'Apparel' | 'Books' dir
type ProductDetailsType = ProductInfo['details'];  // Type '{ weight: string; dimensions: string; }' dir

// Kalitlar ittifoqidan ham foydalanish mumkin:
type NameAndPrice = ProductInfo['name' | 'price']; // Type 'string' | 'number' dir

// Agar kalit mavjud bo'lmasa, bu kompilyatsiya vaqtida xatolik:
// type InvalidType = ProductInfo['nonExistentKey']; // Xatolik: Property 'nonExistentKey' does not exist on type 'ProductInfo'.

            

              
                Copy
              
            
          

Bu Index Access Types ning o'ziga xos mulk turini, yoki bir nechta mulklar uchun turlar ittifoqini mavjud interfeysdan yoki tur aliasidan qanday aniq chiqarish imkonini berishini ko'rsatadi. Bu, ayniqsa, katta, ko'p qismli ilovaning turli qismlari bir xil ta'riflarga rioya qilishini ta'minlash uchun juda qimmatlidir, ayniqsa ilovaning ba'zi qismlari turli jamoalar yoki turli geografik joylarda ishlab chiqilishi mumkin.

Generik Kontekstlardagi Index Access Types

keyof kabi, Index Access Types generik ta'riflar ichida ishlatilganda sezilarli kuchga ega bo'ladi. Ular sizga generik funktsiya yoki yordamchi turning qaytarish turi yoki parametr turini kirish generik turi va kalitiga asoslanib dinamik ravishda aniqlashga imkon beradi.

2-misol: Index Access ni Qaytarish Turida Qayta Ko'rib Chiqilgan getProperty Funktsiyasi

Biz buni allaqachon getProperty funktsiyamiz bilan ko'rgan edik, lekin uni takrorlaylik va T[K] ning rolini ta'kidlaylik:

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

interface Customer {
  id: string;
  firstName: string;
  lastName: string;
  preferences: { email: boolean; sms: boolean };
}

const customer: Customer = {
  id: 'cust-123',
  firstName: 'Maria',
  lastName: 'Gonzales',
  preferences: { email: true, sms: false }
};

const customerFirstName = getProperty(customer, 'firstName'); // Type: string, Value: 'Maria'
const customerPreferences = getProperty(customer, 'preferences'); // Type: { email: boolean; sms: boolean; }, Value: { email: true, sms: false }

// Ichki mulklarga kirish ham mumkin, lekin getProperty funktsiyasi
// faqat yuqori darajali kalitlar uchun ishlaydi. Ichki kirish uchun, murakkabroq generik kerak bo'ladi.
// Masalan, customer.preferences.email olish uchun, siz chaqiruvlarni bir-biriga bog'lashingiz yoki boshqa yordamchi dasturdan foydalanishingiz kerak.
// const customerEmailPref = getProperty(customer.preferences, 'email'); // Type: boolean, Value: true

            

              
                Copy
              
            
          

Bu yerda, T[K] eng muhimi. U getProperty ning qaytarish turi T ob'ektidagi K kalitidagi mulkning turi bo'lishi kerakligini TypeScriptga aytadi. Bu funktsiyani shu qadar tur-xavfsiz va ko'p qirrali qiladi, uning qaytarish turini berilgan aniq kalitga asoslanib moslashtiradi.

Belgilangan mulk turini chiqarish

Index Access Types faqat funktsiya qaytarish turlari uchun emas. Ular mavjud turlarning qismlaridan olingan yangi turlarni aniqlash uchun juda qimmatlidir. Bu, faqat ma'lum bir mulklarni o'z ichiga olgan yangi ob'ekt yaratish kerak bo'lganda, yoki katta ma'lumot modelidan faqat kichik bir qismini ko'rsatadigan UI komponenti uchun tur aniqlashda keng tarqalgan.

            
interface FinancialReport {
  reportId: string;
  dateGenerated: Date;
  totalRevenue: number;
  expenses: number;
  profit: number;
  currency: 'USD' | 'EUR' | 'JPY';
}

type EssentialReportInfo = {
  reportId: FinancialReport['reportId'];
  date: FinancialReport['dateGenerated'];
  currency: FinancialReport['currency'];
};

const summary: EssentialReportInfo = {
  reportId: 'FR-2023-Q4',
  date: new Date(),
  currency: 'EUR' // Bu turga to'g'ri tekshiriladi
};

// Biz tur aliasini ishlatib mulkning qiymati uchun tur ham yaratishimiz mumkin:
type CurrencyType = FinancialReport['currency']; // Type 'USD' | 'EUR' | 'JPY' dir

function formatAmount(amount: number, currency: CurrencyType): string {
  return `${amount.toFixed(2)} ${currency}`;
}

console.log(formatAmount(1234.56, 'USD')); // 1234.56 USD
// console.log(formatAmount(789.00, 'GBP')); // Xatolik: Type '"GBP"' is not assignable to type 'CurrencyType'.

            

              
                Copy
              
            
          

Bu Index Access Types yangi turlarni yaratish yoki parametrning kutilayotgan turini belgilash uchun qanday ishlatilishi mumkinligini ko'rsatadi, bu esa tizimning turli qismlari bir xil ta'riflarga rioya qilishini ta'minlaydi, bu katta, taqsimlangan dasturiy jamoalar uchun muhimdir.

Ilg'or Index Access Type Ssenariylari

Ittifoq Turlari bilan Index Access

Siz Index Access Type sifatida litera turlari ittifoqidan foydalanayotganingizda, TypeScript ittifoqdagi har bir kalitga mos keladigan mulk turlari ittifoqini qaytaradi.

            
interface EventData {
  type: 'click' | 'submit' | 'scroll';
  timestamp: number;
  userId: string;
  target?: HTMLElement;
  value?: string;
}

type EventIdentifiers = EventData['type' | 'userId']; // Type 'click' | 'submit' | 'scroll' | string dir
// 'type' satr litera turlari ittifoqi bo'lganligi va 'userId' satr bo'lganligi sababli,
natijaviy tur 'click' | 'submit' | 'scroll' | string bo'ladi, bu esa string ga soddalashadi.

// Yana bir aniqroq misol uchun tuzatish:
interface Book {
  title: string;
  author: string;
  pages: number;
  isAvailable: boolean;
}

type BookStringOrNumberProps = Book['title' | 'author' | 'pages']; // Type 'string' | 'number' dir
// 'title' string, 'author' string, 'pages' number.
// Bularning ittifoqi string | number.

            

              
                Copy
              
            
          

Bu moslashuvchan ma'lumot interfeyslari yoki umumiy ma'lumotlarni bog'lash mexanizmlari bilan ishlashda foydali bo'lgan "ushbu aniq mulklarning har qandayini" ifodalovchi turlarni yaratishning kuchli usuli hisoblanadi.

Shartli Turlar va Index Access

Index Access Types ko'pincha shartli turlar bilan birlashtirilib, juda dinamik va moslashuvchan tur transformatsiyalarini yaratadi. Shartli turlar sizga shart asosida tur tanlashga imkon beradi.

            
interface Device {
  id: string;
  name: string;
  firmwareVersion: string;
  lastPing: Date;
  isOnline: boolean;
}

// Berilgan ob'ekt turi T dan faqat string turlarini chiqaradigan tur
type StringProperties<T> = {
  [K in keyof T]: T[K] extends string ? K : never;
}[keyof T];

type DeviceStringKeys = StringProperties<Device>; // Type 'id' | 'name' | 'firmwareVersion' dir

// Bu Device ning faqat string mulklarini o'z ichiga olgan yangi tur yaratadi
type DeviceStringsOnly = Pick<Device, DeviceStringKeys>;
/*
Shunga teng:
interface DeviceStringsOnly {
  id: string;
  name: string;
  firmwareVersion: string;
}
*/

const myDeviceStrings: DeviceStringsOnly = {
  id: 'dev-001',
  name: 'Sensor Unit Alpha',
  firmwareVersion: '1.2.3'
};

// myDeviceStrings.isOnline; // Xatolik: Property 'isOnline' does not exist on type 'DeviceStringsOnly'.

            

              
                Copy
              
            
          

Ushbu ilg'or naqsh keyof (K in keyof T ichida) va Index Access Types (T[K]) ning qanday ishlashini murakkab tur filtrlash va transformatsiyasini amalga oshirish uchun shartli turlar (extends string ? K : never) bilan birlashib ko'rsatadi. Bunday ilg'or tur manipulyatsiyasi juda moslashuvchan va ifodali API'lar va yordamchi kutubxonalarni yaratish uchun bebaho hisoblanadi.

keyof Operator vs. Index Access Types: To'g'ridan-to'g'ri Qiyos

Bu nuqtada, siz keyof va Index Access Types ning alohida rollari haqida o'ylayotgan bo'lishingiz mumkin va ularni qachon ishlatish kerakligini tushunmoqchi bo'lishingiz mumkin. Ular ko'pincha birga paydo bo'lsa-da, ularning asosiy maqsadlari har xil, ammo bir-birini to'ldiruvchi.

Nima Qaytarishadi

• keyof T: T ning mulklarining nomlarini ifodalovchi string literal turlarining ittifoqini qaytaradi. U sizga mulklarning "yorliqlari" yoki "identifikatorlarini" beradi.
• T[K] (Index Access Type): T turidagi K kalitiga bog'langan qiymatning turini qaytaradi. U sizga ma'lum bir yorliqda "kontent turini" beradi.

Har birini Qachon Ishlatish Kerak

• keyof ni qachon ishlating:
  • Generik tur parametrini boshqa turdagi yaroqli mulk nomiga cheklash uchun (masalan, K extends keyof T).
  • Belgilangan tur uchun barcha mumkin bo'lgan mulk nomlarini sanab o'tish uchun.
  • Pick, Omit, yoki maxsus xaritalash turlari kabi kalitlar bo'ylab iteratsiya qiluvchi yordamchi turlarni yaratish uchun.
• Index Access Types (T[K]) ni qachon ishlating:
  • Ob'ekt turidan belgilangan mulk turini olish uchun.
  • Ob'ekt va kalitga asoslanib, funktsiyaning qaytarish turini dinamik ravishda aniqlash uchun (masalan, getProperty ning qaytarish turi).
  • Boshqa turlardan aniq mulk turlarini o'z ichiga olgan yangi turlarni yaratish uchun.
  • Tur darajasidagi qidiruvlarni amalga oshirish uchun.

Farq nozik, lekin muhim: keyof *kalitlar* haqida, Index Access Types esa o'sha kalitlardagi *qiymatlar turlari* haqida.

Sinergik Kuchi: keyof va Index Access Typesni Birga Ishlatish

Ushbu tushunchalarning eng kuchli dasturlari ko'pincha ularni birlashtirishni o'z ichiga oladi. Klassik misol bizning getProperty funktsiyamizdir:

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

            

              
                Copy
              
            
          

Sinirjiyani qadrlagan holda, ushbu imzo-sig'rafni yana bir bor qarab chiqamiz:

• <T>: Biz T generik turini ob'ekt uchun kiritamiz. Bu funktsiyani *har qanday* ob'ekt turi bilan ishlashga imkon beradi.
• <K extends keyof T>: Biz ikkinchi generik tur K ni mulk kaliti uchun kiritamiz. extends keyof T cheklovi muhimdir; u funktsiyaga o'tkazilgan key argumenti ob'ektning yaroqli mulk nomi bo'lishi kerakligini ta'minlaydi. Agar bu yerda keyof bo'lmasa, K har qanday satr bo'lishi mumkin, bu esa funktsiyani xavfli qiladi.
• (obj: T, key: K): Funktsiya parametrlari T va K turlaridir.
• : T[K]: Bu Index Access Type. U qaytarish turini dinamik ravishda aniqlaydi. K T ning kaliti bo'lishiga cheklanganligi sababli, T[K] bizga aniq mulkdagi qiymatning turini beradi. Bu qaytarish qiymati uchun kuchli tur aniqlashni ta'minlaydigan narsa. Agar T[K] bo'lmasa, qaytarish turi any yoki kengroq tur bo'lar edi, bu esa aniqlikni yo'qotgan bo'lar edi.

Ushbu naqsh TypeScript generik dasturlashining markaziy o'rnini egallaydi. U sizga juda moslashuvchan (har qanday ob'ekt bilan ishlaydi) va qat'iy tur-xavfsiz (faqat yaroqli kalitlarga ruxsat beradi va aniq qaytarish turlarini aniqlaydi) funktsiyalar va yordamchi turlarni yaratishga imkon beradi.

Murakkabroq Yordamchi Turlarni Yaratish

Ko'pgina TypeScriptning o'rnatilgan yordamchi turlari, masalan, Pick<T, K> va Omit<T, K>, ichki ravishda keyof va Index Access Typesni ishlatadi. Pick ning soddalashtirilgan versiyasini qanday implementatsiya qilish mumkinligini ko'rib chiqamiz:

            
/**
 * Type T dan K mulklar to'plamini olib, tur yaratadi.
 * @template T Asl tur.
 * @template K Olinadigan kalitlarning ittifoqi, T ning kalitlari bo'lishi kerak.
 */
type MyPick<T, K extends keyof T> = {
  [P in K]: T[P];
};

interface ServerLog {
  id: string;
  timestamp: Date;
  level: 'info' | 'warn' | 'error';
  message: string;
  sourceIp: string;
  userId?: string;
}

type CriticalLogInfo = MyPick<ServerLog, 'id' | 'timestamp' | 'level' | 'message'>;
/*
Shunga teng:
interface CriticalLogInfo {
  id: string;
  timestamp: Date;
  level: 'info' | 'warn' | 'error';
  message: string;
}
*/

const errorLog: CriticalLogInfo = {
  id: 'log-001',
  timestamp: new Date(),
  level: 'error',
  message: 'Database connection failed'
};

// errorLog.sourceIp; // Xatolik: Property 'sourceIp' does not exist on type 'CriticalLogInfo'.

            

              
                Copy
              
            
          

MyPick<T, K extends keyof T> ichida:

• K extends keyof T: Biz olmoqchi bo'lgan kalitlar (K) haqiqatan ham asl tur T ning yaroqli kalitlari ekanligini ta'minlaydi.
• [P in K]: Bu xaritalangan tur. U ittifoq turidagi K har bir litera turi P bo'ylab iteratsiya qiladi.
• T[P]: Har bir P kaliti uchun, u Index Access Type dan foydalanib, asl tur T dan mos keladigan mulkning turini oladi.

Ushbu misol, yangi, tur-xavfsiz tuzilmalarni mavjud turlarning aniq qismlarini tanlash va chiqarish orqali yaratish imkonini beradi, bu esa birlashgan kuchni go'zal ko'rsatib beradi. Bunday yordamchi turlar murakkab tizimlar, ayniqsa turli komponentlar (masalan, front-end UI, back-end xizmati, mobil ilova) umumiy ma'lumotlar modelining turli qismlari bilan o'zaro ta'sir qilganda, ma'lumotlar bir xilligini saqlash uchun bebaho hisoblanadi.

Umumiy Tuzoqlarga va Eng Yaxshi Amaliyotlar

Kuchli bo'lishiga qaramay, ilg'or generiklar, keyof va Index Access Types bilan ishlash ba'zan chalkashlik yoki nozik muammolarga olib kelishi mumkin. Bularni bilish, ayniqsa, turli xil kodlash uslublari birlashishi mumkin bo'lgan hamkorlikdagi, xalqaro loyihalarda sezilarli diskretlash vaqtini tejash imkonini beradi.

• keyof any, keyof unknown, va keyof object ni tushunish:
  • keyof any: Ajablanarli darajada, bu string | number | symbol ga aylanadi. Chunki any ramziy yoki raqamli indekslar orqali kirish mumkin bo'lganlarni o'z ichiga olgan har qanday mulkka ega bo'lishi mumkin. any ni ehtiyotkorlik bilan ishlating, chunki u tur tekshiruvini chetlab o'tadi.
  • keyof unknown: Bu never ga aylanadi. unknown eng yuqori tur bo'lganligi sababli, u turi noma'lum bo'lgan qiymatni ifodalaydi. Uni avval toraytirmasdan unknown turiga xavfsiz ravishda hech qanday mulkka kira olmaysiz, shuning uchun hech qanday kalit mavjudligi kafolatlanmagan.
  • keyof object: Bu ham never ga aylanadi. object {} dan kengroq tur bo'lsa-da, u xususan primitiv bo'lmagan turlarga (string, number, boolean kabi) murojaat qiladi. Biroq, u hech qanday mulk mavjudligini kafolatlamaydi. Kafolatlangan kalitlar uchun keyof {} dan foydalaning, u ham `never` ga aylanadi. Biror narsaga ayrim kalitlarga ega ob'ekt uchun uning tuzilishini aniqlang.
  • Eng Yaxshi Amaliyot: Generik cheklovlarda imkon bo'lsa any va unknown dan qoching, agar sizda aniq, yaxshi tushunilgan sabab bo'lmasa. Tur xavfsizligini va vositalarni qo'llab-quvvatlashni maksimal darajada oshirish uchun generiklaringizni interfeyslar yoki litera turlari bilan iloji boricha qattiq cheklang.
• Majburiy bo'lmagan mulklarni boshqarish:

  Agar siz majburiy bo'lmagan mulkka Index Access Type ni qo'llasangiz, uning turi undefined ni o'z ichiga oladi.

              
  interface Settings {
    appName: string;
    version: string;
    environment?: 'development' | 'production'; // Majburiy bo'lmagan mulk
  }
  
  type AppNameType = Settings['appName']; // string
  type EnvironmentType = Settings['environment']; // 'development' | 'production' | undefined
      
              
  
                
                  Copy
                
              
            

  Bu ish vaqti kodida null-xavfsizlik tekshiruvlari uchun muhimdir. Agar mulk majburiy bo'lmasa, u undefined bo'lishi mumkinligini har doim hisobga oling.

• keyof va Readonly Mulklari:

  keyof readonly mulklarini oddiy mulklar kabi ko'rib chiqadi, chunki u faqat kalitning mavjudligi va nomiga qiziqadi, uning o'zgaruvchanligiga emas.

              
  interface ImmutableData {
    readonly id: string;
    value: number;
  }
  
  type ImmutableKeys = keyof ImmutableData; // 'id' | 'value'
      
              
  
                
                  Copy
                
              
            

• O'qish Qobiliyati va Ta'mirlash Qobiliyati:

  Qanchalik kuchli bo'lmasin, haddan tashqari murakkab generik turlar o'qish qobiliyatiga xalaqit berishi mumkin. Generik tur parametrlariga ma'noli nomlarni bering (masalan, TObject, TKey) va aniq hujjatlarni taqdim eting, ayniqsa yordamchi turlar uchun. Murakkab tur manipulyatsiyalarini kichikroq, boshqariladigan yordamchi turlarga bo'lishni ko'rib chiqing.

Real Hayotiy Qo'llashlar va Global Dolzarblik

keyof va Index Access Types tushunchalari nafaqat akademik mashqlar; ular zamonaviy, tur-xavfsiz ilovalarni yaratish uchun asosiy hisoblanadi, ular vaqt sinovidan o'tadi va turli jamoalar va geografik joylarda kengayadi. Kodni yanada mustahkam, bashorat qilinadigan va tushunishga osonlashtirish qobiliyati global aloqador dasturiy rivojlanish landshaftida bebaho hisoblanadi.

• Frameworklar va Kutubxonalar:

  Ko'pgina mashhur frameworklar va kutubxonalar, ularning kelib chiqishi (masalan, AQShdan React, Xitoydan Vue, AQShdan Angular) qat'iy nazar, o'zlarining asosiy tur ta'riflarida ushbu ilg'or tur xususiyatlaridan keng foydalanadilar. Misol uchun, React komponenti uchun propsni aniqlashda, siz tanlash yoki o'zgartirish uchun mavjud bo'lgan mulklarni cheklash uchun keyof dan foydalanishingiz mumkin. Angular va Vue dagi ma'lumotlarni bog'lash ko'pincha komponentning ma'lumotlar modeliga tegishli bo'lgan mulk nomlarini o'tkazishni ta'minlashga bog'liq, bu keyof cheklovlari uchun mukammal foydalanish holati. Ushbu mexanizmlarni tushunish butun dunyo bo'ylab ishlab chiquvchilarga ushbu ekotizimlarga samarali hissa qo'shish va ularni kengaytirishga yordam beradi.

• Ma'lumotlarni Transformatsiya qilish Pipeline'lari:

  Ko'pgina global bizneslarda ma'lumotlar turli tizimlar orqali oqadi, transformatsiyadan o'tadi. Ushbu transformatsiyalar paytida tur xavfsizligini ta'minlash muhim. Tasavvur qiling-a, turli xalqaro mintaqalardan mijoz buyurtmalarini qayta ishlaydigan ma'lumotlar pipeline'i, har birining biroz farq qiladigan ma'lumot tuzilmalari mavjud. keyof va Index Access Types bilan generiklardan foydalangan holda, siz har bir mintaqaning ma'lumotlar modelida mavjud bo'lgan aniq mulklarga moslashadigan bitta, tur-xavfsiz transformatsiya funktsiyasini yaratishingiz mumkin, bu esa ma'lumot yo'qolishini yoki noto'g'ri talqin qilinishini oldini oladi.

              
  interface OrderUS {
    orderId: string;
    customerName: string;
    totalAmountUSD: number;
  }
  
  interface OrderEU {
    orderId: string;
    clientName: string; // Mijoz uchun boshqa mulk nomi
    totalAmountEUR: number;
  }
  
  // Turli buyurtma turlariga moslashadigan buyurtma ID sini chiqarish uchun umumiy funktsiya.
  // Ushbu funktsiya jurnal yoki agregatsiya xizmatining bir qismi bo'lishi mumkin.
  function getOrderId<T extends { orderId: string }>(order: T): string {
    return order.orderId;
  }
  
  const usOrder: OrderUS = { orderId: 'US-001', customerName: 'John Doe', totalAmountUSD: 100 };
  const euOrder: OrderEU = { orderId: 'EU-002', clientName: 'Jean Dupont', totalAmountEUR: 85 };
  
  console.log(getOrderId(usOrder)); // US-001
  console.log(getOrderId(euOrder)); // EU-002
  
  // Ushbu funktsiya keyof/T[K] dan foydalanib dinamik mulklarni chiqarish uchun yanada kengaytirilishi mumkin
  // function getSpecificAmount<T, K extends keyof T>(order: T, amountKey: K): T[K] {
  //   return order[amountKey];
  // }
  // console.log(getSpecificAmount(usOrder, 'totalAmountUSD'));
  // console.log(getSpecificAmount(euOrder, 'totalAmountEUR'));
      
              
  
                
                  Copy
                
              
            

• API Clientini Generatsiya qilish:

  RESTful API'lar bilan ishlashda, ayniqsa dinamik ravishda rivojlanayotgan sxemalar yoki turli jamoalardagi mikroservislar bilan, ushbu tur xususiyatlari bebaho hisoblanadi. Siz API javoblari tuzilishini aks ettiruvchi mustahkam, tur-xavfsiz API clientlarini yaratishingiz mumkin. Misol uchun, agar API endpointi foydalanuvchi ob'ektini qaytarsa, siz faqat ushbu foydalanuvchi ob'ektidan aniq maydonlarni olishga ruxsat beradigan umumiy funktsiyani aniqlashingiz mumkin, bu esa samaradorlikni oshiradi va ma'lumotlarni ortiqcha olishni kamaytiradi. Bu API'lar global miqyosda turli jamoalar tomonidan ishlab chiqilgan taqdirda ham bir xillikni ta'minlaydi, integratsiya murakkabliklarini kamaytiradi.

• Xalqaro Xodimlash (i18n) Tizimlari:

  Global auditoriya uchun ilovalarni yaratish mustahkam xalqaro xodimlashni talab qiladi. i18n tizimi ko'pincha tarjima kalitlarini mahalliy satrlar bilan xaritalashni o'z ichiga oladi. keyof dasturchilar faqat o'zlarining tarjima fayllarida aniqlangan yaroqli tarjima kalitlaridan foydalanishlarini ta'minlash uchun ishlatilishi mumkin. Bu ish vaqti xatolariga olib keladigan kalitlardagi yozuv xatolarini oldini oladi, bu esa ish vaqtida tarjima yo'qolishiga olib keladi.

              
  interface TranslationKeys {
    'greeting.hello': string;
    'button.cancel': string;
    'form.error.required': string;
    'currency.format': (amount: number, currency: string) => string;
  }
  
  // Biz yuklangan mahalliy ob'ektga asoslanib dinamik ravishda tarjimalarni yuklashimiz mumkin.
  // Tur tekshiruvi uchun biz umumiy translate funktsiyasini aniqlashimiz mumkin:
  
  function translate<K extends keyof TranslationKeys>(key: K, ...args: any[]): TranslationKeys[K] {
    // Haqiqiy ilovada, bu yuklangan mahalliy ob'ektidan olinadi
    const translations: TranslationKeys = {
      'greeting.hello': 'Hello',
      'button.cancel': 'Cancel',
      'form.error.required': 'This field is required.',
      'currency.format': (amount, currency) => `${amount.toFixed(2)} ${currency}`
    };
  
    const value = translations[key];
    if (typeof value === 'function') {
      return value(...args) as TranslationKeys[K];
    }
    return value as TranslationKeys[K];
  }
  
  const welcomeMessage = translate('greeting.hello'); // Type: string
  console.log(welcomeMessage); // Hello
  
  const cancelButtonText = translate('button.cancel'); // Type: string
  console.log(cancelButtonText); // Cancel
  
  const formattedCurrency = translate('currency.format', 123.45, 'USD'); // Type: string
  console.log(formattedCurrency); // 123.45 USD
  
  // translate('non.existent.key'); // Xatolik: Argument of type '"non.existent.key"' is not assignable to parameter of type 'keyof TranslationKeys'.
      
              
  
                
                  Copy
                
              
            

  Ushbu tur-xavfsiz yondashuv barcha xalqaro xodimlash satrlari bir xil ravishda murojaat qilinishini va tarjima funktsiyalari to'g'ri argumentlar bilan chaqirilishini ta'minlaydi, bu turli lingvistik va madaniy kontekstlarda bir xil foydalanuvchi tajribasini taqdim etish uchun muhimdir.

• Konfiguratsiya Boshqaruvi:

  Katta hajmdagi ilovalar, ayniqsa, turli xil muhitlarda (dasturiy, staging, ishlab chiqarish) yoki geografik mintaqalarda joylashtirilganlar, ko'pincha murakkab konfiguratsiya ob'ektlariga tayanadi. keyof va Index Access Typesni ishlatish sizga konfiguratsiya qiymatlarini olish va tekshirish uchun juda tur-xavfsiz funktsiyalarni yaratishga imkon beradi. Bu konfiguratsiya kalitlari har doim yaroqli ekanligini va qiymatlarning kutilgan turda ekanligini ta'minlaydi, bu esa konfiguratsiya bilan bog'liq sozlash xatolarini oldini oladi va global miqyosda bir xil xatti-harakatni ta'minlaydi.

Ilg'or Tur Manipulyatsiyalari keyof va Index Access Typesdan Foydalangan holda

Asosiy yordamchi funktsiyalardan tashqari, keyof va Index Access Types TypeScriptda ko'pgina ilg'or tur transformatsiyalari uchun asosni tashkil qiladi. Ushbu naqshlar juda generik, qayta ishlatiladigan va o'zini hujjatlashtiruvchi tur ta'riflarini yozish uchun zarurdir, bu esa murakkab, taqsimlangan tizimlarni ishlab chiqishning muhim jihati hisoblanadi.

Pick va Omit Qayta Ko'rib Chiqish

MyPick bilan ko'rganimizdek, ushbu asosiy yordamchi turlar keyof va Index Access Types ning sinergik kuchidan foydalangan holda qurilgan. Ular sizga mavjud turdan mulklarni tanlash yoki istisno qilish orqali yangi turlarni aniqlashga imkon beradi. Tur ta'rifining ushbu modulli yondashuvi, ayniqsa katta, ko'p qirrali ma'lumotlar modellari bilan ishlashda qayta ishlatish va ravshanlikni rag'batlantiradi.

            
interface UserProfile {
  userId: string;
  username: string;
  email: string;
  dateJoined: Date;
  lastLogin: Date;
  isVerified: boolean;
  settings: { theme: 'dark' | 'light'; notifications: boolean };
}

// Asosiy foydalanuvchi ma'lumotlarini ko'rsatish uchun tur yaratish uchun Pick dan foydalaning
type UserSummary = Pick<UserProfile, 'username' | 'email' | 'dateJoined'>;

// Avtomatik yaratilgan maydonlarni istisno qilish, foydalanuvchi yaratish uchun tur yaratish uchun Omit dan foydalaning
type UserCreationPayload = Omit<UserProfile, 'userId' | 'dateJoined' | 'lastLogin' | 'isVerified'>;

/*
UserSummary quyidagicha bo'lar edi:
{
  username: string;
  email: string;
  dateJoined: Date;
}

UserCreationPayload quyidagicha bo'lar edi:
{
  username: string;
  email: string;
  settings: { theme: 'dark' | 'light'; notifications: boolean };
}
*/

const newUser: UserCreationPayload = {
  username: 'new_user_global',
  email: 'new.user@example.com',
  settings: { theme: 'light', notifications: true }
};

// const invalidSummary: UserSummary = newUser; // Xatolik: Property 'dateJoined' is missing in type 'UserCreationPayload'

            

              
                Copy
              
            
          

Dinamik `Record` Turlarini Yaratish

Record<K, T> yordamchi turi, uning mulk kalitlari K turidagi va uning mulk qiymatlari T turidagi ob'ekt turini yaratadigan yana bir kuchli o'rnatilgan turi hisoblanadi. Mavjud turdan olingan kalitlarga ega lug'atlar yoki xaritalar uchun turlarni dinamik ravishda yaratish uchun siz keyof ni Record bilan birlashtira olasiz.

            
interface Permissions {
  read: boolean;
  write: boolean;
  execute: boolean;
  admin: boolean;
}

// Har bir ruxsat kalitini 'PermissionStatus' ga xaritalaydigan tur yarating
type PermissionStatus = 'granted' | 'denied' | 'pending';

type PermissionsMapping = Record<keyof Permissions, PermissionStatus>;
/*
Shunga teng:
{
  read: 'granted' | 'denied' | 'pending';
  write: 'granted' | 'denied' | 'pending';
  execute: 'granted' | 'denied' | 'pending';
  admin: 'granted' | 'denied' | 'pending';
}
*/

const userPermissions: PermissionsMapping = {
  read: 'granted',
  write: 'denied',
  execute: 'pending',
  admin: 'denied'
};

// userPermissions.delete = 'granted'; // Xatolik: Property 'delete' does not exist on type 'PermissionsMapping'.

            

              
                Copy
              
            
          

Ushbu naqsh lug'at jadvallari, status panellari yoki kirish nazorati ro'yxatlarini yaratish uchun juda foydali bo'lib, bu yerda kalitlar mavjud ma'lumotlar modeli mulklariga yoki funktsional qobiliyatlarga bevosita bog'langan.

keyof va Index Access dan Foydalangan holda Xaritalash Turlari

Xaritalash turlari mavjud turdagi har bir mulkni yangi turga aylantirishga imkon beradi. Bu yerda keyof va Index Access Types haqiqatan ham yorqinlashadi, murakkab tur derivatsiyalarini ta'minlaydi. Umumiy foydalanish holati har qanday ob'ektning barcha mulklarini asinxron operatsiyalarga aylantirishdir, bu API dizayni yoki hodisa-yo'naltirilgan arxitekturadagi umumiy naqshni ifodalaydi.

Misol: `MapToPromises`

T ob'ekt turini oladigan va har bir mulk qiymati Promise ga o'ralgan yangi turga aylantiradigan yordamchi tur yarataylik.

            
/**
 * Ob'ekt turi T ni har bir mulk qiymati
 * Promise ga o'ralgan yangi turga aylantiradi.
 * @template T Asl ob'ekt turi.
 */
type MapToPromises<T> = {
  [P in keyof T]: Promise<T[P]>;
};

interface UserData {
  id: string;
  username: string;
  email: string;
  age: number;
}

type AsyncUserData = MapToPromises<UserData>;
/*
Shunga teng:
interface AsyncUserData {
  id: Promise<string>;
  username: Promise<string>;
  email: Promise<string>;
  age: Promise<number>;
}
*/

// Foydalanish misoli:
async function fetchUserData(): Promise<AsyncUserData> {
  return {
    id: Promise.resolve('user-abc'),
    username: Promise.resolve('global_dev'),
    email: Promise.resolve('global.dev@example.com'),
    age: Promise.resolve(30)
  };
}

async function displayUser() {
  const data = await fetchUserData();
  const username = await data.username;
  console.log(`Fetched Username: ${username}`); // Fetched Username: global_dev
  
  const email = await data.email;
  // console.log(email.toUpperCase()); // Bu turga xavfsiz bo'lar edi (satr usullari mavjud)
}

displayUser();

            

              
                Copy
              
            
          

MapToPromises<T> ichida:

• [P in keyof T]: Bu kirish turi T dan barcha mulk kalitlari P bo'ylab xaritalaydi. keyof T barcha mulk nomlari ittifoqini beradi.
• Promise<T[P]>: Har bir P kaliti uchun, u asl mulk turi T[P] (Index Access Type dan foydalanib) ni oladi va uni Promise ga o'raydi.

Bu, keyof va Index Access Typesning murakkab tur transformatsiyalarini aniqlashda qanday ishlashini kuchli namoyish etadi, bu esa sizga asinxron operatsiyalar, ma'lumotlar keshini saqlash yoki mulklar turini bir xil tarzda o'zgartirish kerak bo'lgan har qanday stsenariy uchun juda ifodali va tur-xavfsiz API'lar yaratishga imkon beradi. Bunday tur transformatsiyalari taqsimlangan tizimlar va mikroservislar arxitekturasida muhim ahamiyatga ega bo'lib, u yerda ma'lumotlar shakllari turli xizmat chegaralari bo'ylab moslashishi kerak.

Xulosa: Tur Xavfsizligi va Moslashuvchanlikni O'zlashtirish

keyof va Index Access Types haqidagi chuqur o'rganishimiz ularni nafaqat individual xususiyatlar, balki TypeScriptning ilg'or generik tizimining bir-birini to'ldiruvchi ustunlari sifatida ochib beradi. Ular butun dunyo bo'ylab ishlab chiquvchilarga juda moslashuvchan, qayta ishlatiladigan va eng muhimi, tur-xavfsiz kodni yaratish imkonini beradi. Murakkab ilovalar, turli jamoalar va global hamkorlik davrida, kompilyatsiya vaqtida kod sifatini va bashoratliligini ta'minlash muhimdir. Ushbu ilg'or generik cheklovlari ushbu harakatda ajralmas vositalardir.

keyof dan samarali foydalanishni tushunish orqali siz mulk nomlariga aniq murojaat qilish va ularni cheklash qobiliyatini qo'lga kiritasiz, bu esa sizning generik funktsiyalaringiz va turingiz faqat ob'ektning yaroqli qismlarida ishlayotganligini ta'minlaydi. Shu bilan birga, Index Access Types (T[K]) ni o'zlashtirish orqali siz ushbu mulklarning turlarini aniq chiqarish va hosil qilish imkoniyatini ochasiz, bu esa tur ta'riflaringizni moslashuvchan va juda aniq qiladi.

keyof va Index Access Types o'rtasidagi sinergiya, getProperty funktsiyasi va MyPick yoki MapToPromises kabi maxsus yordamchi turlar kabi naqshlarda ko'rsatilganidek, tur darajasidagi dasturlashda sezilarli sakrashni anglatadi. Ushbu usullar sizni faqat ma'lumotlarni tasvirlashdan turib, turlarning o'zlarini faol ravishda manipulyatsiya qilish va aylantirishga olib boradi, bu esa yanada mustahkam dasturiy arxitekturaga va ancha yaxshilangan dasturchi tajribasiga olib keladi.

Global Dasturchilar uchun Amalga Oshiriladigan Tushunchalar:

• Generiklarni Qabul Qiling: Oddiy funktsiyalar uchun ham generiklardan foydalanishni boshlang. Ularni qanchalik erta kiritsangiz, ular shunchalik tabiiy bo'ladi.
• Cheklovlar bilan O'ylang: Har qanday generik funktsiyani yozganingizda, o'zingizdan so'rang: "Bu funktsiyaning ishlashi uchun T qanday mulklarga yoki metodlarga ega bo'lishi kerak?". Bu sizni tabiiy ravishda extends bandlari va keyof ga olib boradi.
• Index Access dan Foydalaning: Agar sizning generik funktsiyangizning qaytarish turi (yoki parametr turi) boshqa generik turdagi aniq mulkka bog'liq bo'lsa, T[K] haqida o'ylang.
• Yordamchi Turlarni O'rganing: TypeScriptning o'rnatilgan yordamchi turlari (Pick, Omit, Record, Partial, Required) bilan tanishing va ular ushbu tushunchalarni qanday ishlatishini kuzating. Ularning soddalashtirilgan versiyalarini qayta yaratishga harakat qiling, bu esa tushunchangizni mustahkamlaydi.
• Turlaringizni Hujjatlang: Murakkab generik turlar, ayniqsa, umumiy kutubxonalarda, ularning maqsadini va generik parametrlar qanday cheklangan va ishlatilganligini tushuntiruvchi aniq sharhlar bering. Bu xalqaro jamoalar hamkorligini sezilarli darajada osonlashtiradi.
• Real Hayotiy Ssenariylar bilan Mashq Qiling: Ushbu tushunchalarni kundalik kodlash muammolaringizga qo'llang – bu moslashuvchan ma'lumotlar paneli yaratish, tur-xavfsiz konfiguratsiya yuklagichini yaratish yoki qayta ishlatiladigan API clientini loyihalash bo'ladimi.

keyof va Index Access Types bilan ilg'or generik cheklovlarni o'zlashtirish nafaqat ko'proq TypeScript yozish haqida; bu yaxshiroq, xavfsizroq va ta'mirlashga osonroq kod yozish haqida bo'lib, u barcha sohalar va geografiyalarda ilovalarni ishonchli quvvatlantirishi mumkin. Sinovdan o'tishni, o'rganishni davom eting va TypeScriptning tur tizimining to'liq kuchi bilan global dasturiy rivojlanishingizni kuchaytiring!