Uzlaboti ģenēriskie ierobežojumi: Keyof Operator vs. Indeksa piekļuves tipi paskaidroti

Plašajā un nepārtraukti mainīgajā programmatūras izstrādes ainavā TypeScript ir kļuvis par kritiski svarīgu rīku stabilu, mērogojamu un uzturamu lietojumprogrammu veidošanai. Tā statiskās tipizēšanas spējas dod iespēju izstrādātājiem visā pasaulē savlaicīgi atklāt kļūdas, uzlabot koda lasāmību un veicināt sadarbību dažādās komandās un projektos. TypeScript jaudas pamatā ir tā sarežģītā tipu sistēma, jo īpaši tās ģenēriskie tipi un uzlabotās tipu manipulācijas funkcijas. Kamēr daudzi izstrādātāji ir apmierināti ar pamata ģenēriskajiem tipiem, patiesa TypeScript apguve prasa dziļāku izpratni par sarežģītākiem jēdzieniem, piemēram, ģenēriskajiem ierobežojumiem, the keyof operatoru un indeksa piekļuves tipiem.

Šis visaptverošais ceļvedis ir paredzēts izstrādātājiem, kuri vēlas uzlabot savas TypeScript prasmes, pārsniedzot pamatus, lai izmantotu pilnu valodas izteiksmīgo jaudu. Mēs dosimies detalizētā ceļojumā, analizējot keyof operatora un indeksa piekļuves tipu nianses, pētot to individuālās stiprās puses, saprotot, kad katru no tiem izmantot, un, galvenais, atklājot, kā tos apvienot, lai izveidotu neticami elastīgu un tipu drošu kodu. Neatkarīgi no tā, vai veidojat globālu uzņēmuma lietojumprogrammu, atvērtā koda bibliotēku vai sniedzat ieguldījumu starpkultūru attīstības projektā, šīs uzlabotās metodes ir neaizvietojamas augstas kvalitātes TypeScript rakstīšanai.

Atklāsim patiesi uzlabotu ģenērisko ierobežojumu noslēpumus un stiprināsim jūsu TypeScript izstrādi!

Stūrakmens: TypeScript ģenērisko tipu izpratne

Pirms mēs iedziļināmies keyof un indeksa piekļuves tipu specifiskajās niansēs, ir būtiski stingri aptvert ģenērisko tipu koncepciju un to, kāpēc tie ir tik svarīgi mūsdienu programmatūras izstrādē. Ģenēriskie tipi ļauj rakstīt komponentus, kas var strādāt ar dažādiem datu tipiem, nevis būt ierobežotiem ar vienu. Tas nodrošina milzīgu elastību un atkārtotu izmantojamību, kas ir vissvarīgākais mūsdienu straujajā izstrādes vidē, īpaši, ja tiek apkalpotas dažādas datu struktūras un biznesa loģika globālā mērogā.

Pamata ģenēriskie tipi: Elastīgs pamats

Iedomājieties, ka jums ir nepieciešama funkcija, kas atgriež masīva pirmo elementu. Bez ģenēriskajiem tipiem jūs to varētu uzrakstīt šādi:

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

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

// Usage with strings
const names = ['Alice', 'Bob'];
const firstName = getFirstElement(names);   // type: any

// Problem: We lose type information!
const lengthOfFirstName = (firstName as string).length; // Requires type assertion

            

              
                Copy
              
            
          

Problēma ir tāda, ka any pilnībā izdzēš tipu drošību. Ģenēriskie tipi to atrisina, ļaujot tvert argumenta tipu un izmantot to kā atgriešanas tipu:

            
function getFirstElement<T>(arr: T[]): T {
  if (arr.length === 0) {
    // Depending on strict settings, you might need to return T | undefined
    // For simplicity, let's assume non-empty arrays or handle undefined explicitly.
    // A more robust signature might be T[] => T | undefined.
    return undefined as any; // Or handle more carefully
  }
  return arr[0];
}

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

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

// Type safety maintained!
const lengthOfFirstName = firstName.length; // No type assertion needed, TypeScript knows it's a string

            

              
                Copy
              
            
          

Šeit <T> deklarē tipa mainīgo T. Kad izsaucat getFirstElement ar skaitļu masīvu, T kļūst par number. Kad izsaucat to ar virknēm, T kļūst par string. Tas ir ģenērisko tipu fundamentālais spēks: tipu inferencēšana un atkārtota izmantojamība, nezaudējot drošību.

Ģenēriskie ierobežojumi ar extends

Lai gan ģenēriskie tipi piedāvā milzīgu elastību, reizēm ir nepieciešams ierobežot tipus, ko var izmantot ar ģenērisku komponentu. Piemēram, ko darīt, ja jūsu funkcija paredz, ka ģenēriskajam tipam T vienmēr ir jābūt noteiktai īpašībai vai metodei? Šeit talkā nāk ģenēriskie ierobežojumi, izmantojot atslēgvārdu extends.

Apskatīsim funkciju, kas reģistrē elementa ID. Ne visiem tipiem ir id īpašība. Mums ir jāierobežo T, lai nodrošinātu, ka tam vienmēr ir id īpašība ar tipu number (vai string, atkarībā no prasībām).

            
interface HasId {
  id: number;
}

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

// Works correctly
logId({ id: 1, name: 'Product A' }); // ID: 1
logId({ id: 2, quantity: 10 });    // ID: 2

// Error: 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
              
            
          

Izmantojot <T extends HasId>, mēs sakām TypeScript, ka T ir jābūt piešķiramam HasId tipam. Tas nozīmē, ka jebkuram objektam, kas tiek nodots logId, ir jābūt id: number īpašībai, tādējādi nodrošinot tipu drošību un novēršot izpildes laika kļūdas. Šī pamatizpratne par ģenēriskajiem tipiem un ierobežojumiem ir izšķiroša, kad iedziļināmies sarežģītākās tipu manipulācijās.

Dziļa iedziļināšanās: keyof operators

keyof operators ir spēcīgs rīks TypeScript valodā, kas ļauj no konkrēta tipa iegūt visus publiskos īpašību nosaukumus (atslēgas) un pārvērst tos par virkņu literāļu apvienoto tipu. Iedomājieties to kā saraksta ģenerēšanu ar visiem derīgajiem īpašumu piekļuves veidiem objektam. Tas ir neticami noderīgi, lai izveidotu ļoti elastīgas, taču tipu drošas funkcijas, kas darbojas ar objektu īpašībām, kas ir bieža prasība datu apstrādē, konfigurācijā un UI izstrādē dažādās globālās lietojumprogrammās.

Ko dara keyof

Vienkārši sakot, objekta tipam T, keyof T veido virknes literāļu tipu apvienību, kas attēlo T īpašību nosaukumus. Tas ir kā jautāt: "Kādas ir visas iespējamās atslēgas, ko varu izmantot, lai piekļūtu šī tipa objekta īpašībām?"

Sintakse un pamata lietošana

Sintakse ir vienkārša: keyof TypeName.

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

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

const userKey: UserKeys = 'name'; // Valid
// const invalidKey: UserKeys = 'address'; // Error: 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 is 'productId' | 'getCost'
// Note: private and protected members are not included in keyof for classes, 
// as they are not publicly accessible keys.

            

              
                Copy
              
            
          

Kā redzams, keyof pareizi identificē visus publiski pieejamos īpašību nosaukumus, ieskaitot metodes (kas ir īpašības, kurās atrodas funkciju vērtības), bet izslēdz privātos un aizsargātos dalībniekus. Šāda uzvedība atbilst tā mērķim: identificēt derīgas atslēgas īpašību piekļuvei.

keyof ģenēriskajos ierobežojumos

Patiesais keyof spēks atklājas, kad tas tiek apvienots ar ģenēriskajiem ierobežojumiem. Šī kombinācija ļauj rakstīt funkcijas, kas var strādāt ar jebkuru objektu, bet tikai ar tām īpašībām, kas patiešām pastāv šajā objektā, tādējādi nodrošinot tipu drošību kompilēšanas laikā.

Apskatīsim bieži sastopamu scenāriju: utilitārā funkcija, lai droši iegūtu īpašības vērtību no objekta.

1. piemērs: Funkcijas getProperty izveide

Bez keyof jūs varētu ķerties pie any vai mazāk drošas pieejas:

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

const myUser = { id: 1, name: 'Charlie' };
const userName = getPropertyUnsafe(myUser, 'name');  // Returns 'Charlie', but type is any
const userAddress = getPropertyUnsafe(myUser, 'address'); // Returns undefined, no compile-time error

            

              
                Copy
              
            
          

Tagad ieviesīsim keyof, lai padarītu šo funkciju stabilu un tipu drošu:

            
/**
 * Safely retrieves a property from an object.
 * @template T The type of the object.
 * @template K The type of the key, constrained to be a key of T.
 * @param obj The object to query.
 * @param key The key (property name) to retrieve.
 * @returns The value of the property at the given key.
 */
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'
};

// Valid usage:
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}`);

// Invalid usage (compile-time error):
// 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
              
            
          

Sadalīsim function getProperty<T, K extends keyof T>(obj: T, key: K): T[K]:

• <T>: Deklarē ģenērisku tipa parametru T objektam.
• <K extends keyof T>: Deklarē ģenērisku tipa parametru K atslēgai. Šī ir svarīgākā daļa. Tas ierobežo K būt vienam no virknes literāļa tipiem, kas attēlo T atslēgu. Tātad, ja T ir Employee, tad K ir jābūt 'employeeId' | 'firstName' | 'lastName' | 'department'.
• (obj: T, key: K): Funkcijas parametri. obj ir T tips, un key ir K tips.
• : T[K]: Šis ir indeksa piekļuves tips (ko mēs detalizēti aplūkosim nākamajā nodaļā), kas šeit tiek izmantots atgriešanas tipa norādīšanai. Tas nozīmē "īpašības tips ar atslēgu K objekta tipā T". Ja T ir Employee un K ir 'firstName', tad T[K] atrisinās uz string. Ja K ir 'employeeId', tas atrisinās uz number.

keyof ierobežojumu priekšrocības

• Kompilēšanas laika drošība: Novērš piekļuvi neeksistējošām īpašībām, samazinot izpildes laika kļūdas.
• Uzlabota izstrādātāja pieredze: Nodrošina inteliģentus automātiskās pabeigšanas ieteikumus atslēgām, izsaucot funkciju.
• Uzlabota lasāmība: Tipa paraksts skaidri norāda, ka atslēgai ir jāpieder objektam.
• Stabila refaktorizācija: Ja pārdēvējat īpašību Employee, TypeScript nekavējoties atzīmēs getProperty izsaukumus, kas izmanto veco atslēgu.

Uzlaboti keyof scenāriji

Atslēgu iterēšana

Lai gan keyof pats par sevi ir tipa operators, tas bieži vien sniedz informāciju par to, kā varētu veidot funkcijas, kas iterē pa objekta atslēgām, nodrošinot, ka izmantotās atslēgas vienmēr ir derīgas.

            
function logAllProperties<T extends object>(obj: T): void {
  // Here, Object.keys returns string[], not keyof T, so we often need assertions
  // or to be careful. However, keyof T guides our thinking for type safety.
  (Object.keys(obj) as Array<keyof T>).forEach(key => {
    // We know 'key' is a valid key for 'obj'
    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);
// Output:
// id: cappuccino
// label: Cappuccino
// price: 4.5
// available: true

            

              
                Copy
              
            
          

Šajā piemērā keyof T darbojas kā konceptuāls vadošais princips tam, ko Object.keys *vajadzētu* atgriezt ideālā tipu drošā pasaulē. Mums bieži ir nepieciešams tipa apgalvojums as Array<keyof T>, jo Object.keys izpildes laikā ir mazāk tipu apzināts nekā TypeScript kompilēšanas laika tipu sistēma. Tas izceļ mijiedarbību starp izpildes laika JavaScript un kompilēšanas laika TypeScript.

keyof ar apvienotajiem tipiem

Kad lietojat keyof apvienotajam tipam, tas atgriež atslēgu šķēlumu no visiem apvienības tipiem. Tas nozīmē, ka tas ietver tikai tās atslēgas, kas ir kopīgas visiem apvienības locekļiem.

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

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

type Fruit = Apple | Orange;

type FruitKeys = keyof Fruit; // Type is 'color'
// 'sweetness' is only in Apple, 'citrus' is only in Orange.
// 'color' is common to both.

            

              
                Copy
              
            
          

Šī uzvedība ir svarīgi atcerēties, jo tā nodrošina, ka jebkura atslēga, kas izvēlēta no FruitKeys, vienmēr būs derīga īpašība jebkuram Fruit tipa objektam (neatkarīgi no tā, vai tas ir Apple vai Orange). Tas novērš izpildes laika kļūdas, strādājot ar polimorfām datu struktūrām.

keyof ar typeof

Jūs varat izmantot keyof kopā ar typeof, lai iegūtu atslēgas no objekta tipa tieši no tā vērtības, kas ir īpaši noderīgi konfigurācijas objektiem vai konstantēm.

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

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

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'); // Error

            

              
                Copy
              
            
          

Šis modelis ir ļoti efektīvs, lai saglabātu tipu drošību, mijiedarbojoties ar globālajiem konfigurācijas objektiem, nodrošinot konsekvenci dažādos moduļos un komandās, kas ir īpaši vērtīgi liela mēroga projektos ar daudzveidīgiem ieguldītājiem.

Indeksa piekļuves tipu (Lookup Types) atklāšana

Kamēr keyof dod jums īpašību nosaukumus, indeksa piekļuves tips (ko bieži dēvē arī par meklēšanas tipu) ļauj izvilkt konkrētas īpašības tipu no cita tipa. Tas ir kā jautāt: "Kāds ir vērtības tips pie šīs konkrētās atslēgas šajā objekta tipā?" Šī spēja ir fundamentāla, lai veidotu tipus, kas ir atvasināti no esošajiem tipiem, uzlabojot atkārtotu izmantojamību un samazinot liekumu jūsu tipu definīcijās.

Ko dara indeksa piekļuves tipi

Indeksa piekļuves tips izmanto kvadrātiekavu notāciju (tāpat kā īpašību piekļuvei JavaScript valodā) tipu līmenī, lai meklētu tipu, kas saistīts ar īpašības atslēgu. Tas ir būtisks, lai dinamiski veidotu tipus, pamatojoties uz citu tipu struktūru.

Sintakse un pamata lietošana

Sintakse ir TypeName[KeyType], kur KeyType parasti ir virknes literāļa tips vai virknes literāļa tipu apvienība, kas atbilst derīgām TypeName atslēgām.

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

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

// You can also use a union of keys:
type NameAndPrice = ProductInfo['name' | 'price']; // Type is string | number

// If a key doesn't exist, it's a compile-time error:
// type InvalidType = ProductInfo['nonExistentKey']; // Error: Property 'nonExistentKey' does not exist on type 'ProductInfo'.

            

              
                Copy
              
            
          

Tas parāda, kā indeksa piekļuves tipi ļauj precīzi izvilkt konkrētas īpašības tipu vai vairāku īpašību tipu apvienību no esošas saskarnes vai tipa aizstājvārda. Tas ir ļoti vērtīgi, lai nodrošinātu tipu konsekvenci dažādās lielas lietojumprogrammas daļās, īpaši, ja lietojumprogrammas daļas varētu izstrādāt dažādas komandas vai dažādās ģeogrāfiskās vietās.

Indeksa piekļuves tipi ģenēriskajos kontekstos

Tāpat kā keyof, indeksa piekļuves tipi iegūst ievērojamu spēku, ja tos izmanto ģenēriskās definīcijās. Tie ļauj dinamiski noteikt ģenēriskās funkcijas vai utilitārā tipa atgriešanas tipu vai parametru tipu, pamatojoties uz ievades ģenērisko tipu un atslēgu.

2. piemērs: Atkārtoti aplūkota funkcija getProperty ar indeksa piekļuvi atgriešanas tipā

Mēs to jau redzējām darbībā ar mūsu getProperty funkciju, taču atkārtosim un uzsvērsim T[K] lomu:

            
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 }

// You can even access nested properties, but the getProperty function itself 
// only works for top-level keys. For nested access, you'd need a more complex generic.
// For example, to get customer.preferences.email, you'd chain calls or use a different utility.
// const customerEmailPref = getProperty(customer.preferences, 'email'); // Type: boolean, Value: true

            

              
                Copy
              
            
          

Šeit T[K] ir vissvarīgākais. Tas pasaka TypeScript, ka getProperty atgriešanas tipam ir precīzi jābūt īpašības K tipam objektā T. Tas padara funkciju tik tipu drošu un daudzpusīgu, pielāgojot tās atgriešanas tipu, pamatojoties uz norādīto atslēgu.

Konkrētas īpašības tipa izvilkšana

Indeksa piekļuves tipi nav paredzēti tikai funkciju atgriešanas tipiem. Tie ir neticami noderīgi jaunu tipu definēšanai, pamatojoties uz esošo tipu daļām. Tas ir bieži sastopams scenārijos, kad jāizveido jauns objekts, kas satur tikai noteiktas īpašības, vai kad jādefinē tips UI komponentam, kas parāda tikai datu apakškopu no lielāka datu modeļa.

            
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' // This is type-checked correctly
};

// We can also create a type for a property's value using a type alias:
type CurrencyType = FinancialReport['currency']; // Type is 'USD' | 'EUR' | 'JPY'

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')); // Error: Type '"GBP"' is not assignable to type 'CurrencyType'.

            

              
                Copy
              
            
          

Tas parāda, kā indeksa piekļuves tipus var izmantot jaunu tipu konstruēšanai vai parametru paredzamā tipa definēšanai, nodrošinot, ka dažādas jūsu sistēmas daļas ievēro konsekventas definīcijas, kas ir izšķiroši lielām, izkliedētām izstrādes komandām.

Uzlaboti indeksa piekļuves tipu scenāriji

Indeksa piekļuve ar apvienotajiem tipiem

Kad indeksa piekļuves tipā kā atslēgu izmantojat literālo tipu apvienību, TypeScript atgriež īpašību tipu apvienību, kas atbilst katrai atslēgai apvienībā.

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

type EventIdentifiers = EventData['type' | 'userId']; // Type is 'click' | 'submit' | 'scroll' | string
// Because 'type' is a union of string literals, and 'userId' is a string,
// the resulting type is 'click' | 'submit' | 'scroll' | string, which simplifies to string.

// Let's refine for a more illustrative example:
interface Book {
  title: string;
  author: string;
  pages: number;
  isAvailable: boolean;
}

type BookStringOrNumberProps = Book['title' | 'author' | 'pages']; // Type is string | number
// 'title' is string, 'author' is string, 'pages' is number.
// The union of these is string | number.

            

              
                Copy
              
            
          

Tas ir spēcīgs veids, kā veidot tipus, kas attēlo "jebkuru no šīm konkrētajām īpašībām", kas ir noderīgi, strādājot ar elastīgām datu saskarnēm vai ieviešot ģenēriskos datu sasaistes mehānismus.

Nosacītie tipi un indeksa piekļuve

Indeksa piekļuves tipi bieži tiek apvienoti ar nosacītajiem tipiem, lai radītu ļoti dinamiskas un adaptīvas tipu transformācijas. Nosacītie tipi ļauj atlasīt tipu, pamatojoties uz nosacījumu.

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

// Type that extracts only string properties from a given object type T
type StringProperties<T> = {
  [K in keyof T]: T[K] extends string ? K : never;
}[keyof T];

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

// This creates a new type that contains only the string properties of Device
type DeviceStringsOnly = Pick<Device, DeviceStringKeys>;
/*
Equivalent to:
interface DeviceStringsOnly {
  id: string;
  name: string;
  firmwareVersion: string;
}
*/

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

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

            

              
                Copy
              
            
          

Šis uzlabotais modelis parāda, kā keyof (iekš K in keyof T) un indeksa piekļuves tipi (T[K]) cieši sadarbojas ar nosacītajiem tipiem (extends string ? K : never), lai veiktu sarežģītu tipu filtrēšanu un transformāciju. Šāda veida uzlabota tipu manipulācija ir nenovērtējama, veidojot ļoti adaptīvus un izteiksmīgus API un utilitātes bibliotēkas.

keyof operators pret indeksa piekļuves tipiem: Tiešs salīdzinājums

Šajā brīdī jums varētu rasties jautājumi par keyof un indeksa piekļuves tipu atšķirīgajām lomām un to, kad katru no tiem izmantot. Lai gan tie bieži parādās kopā, to fundamentālie mērķi ir atšķirīgi, taču papildina viens otru.

Ko tie atgriež

• keyof T: Atgriež virknes literāļa tipu apvienību, kas attēlo T īpašību nosaukumus. Tas dod jums īpašību "etiķetes" vai "identifikatorus".
• T[K] (Indeksa piekļuves tips): Atgriež vērtības tipu, kas saistīts ar atslēgu K tipā T. Tas dod jums "satura tipu" pie konkrētas etiķetes.

Kad katru izmantot

• Izmantojiet keyof, ja jums nepieciešams:
  • Ierobežot ģenērisku tipa parametru, lai tas būtu derīgs cita tipa īpašības nosaukums (piemēram, K extends keyof T).
  • Uzskaitīt visus iespējamos īpašību nosaukumus konkrētam tipam.
  • Izveidot utilitāros tipus, kas iterē pa atslēgām, piemēram, Pick, Omit vai pielāgotos kartēšanas tipus.
• Izmantojiet indeksa piekļuves tipus (T[K]), ja jums nepieciešams:
  • Iegūt konkrētas īpašības tipu no objekta tipa.
  • Dinamiski noteikt funkcijas atgriešanas tipu, pamatojoties uz objektu un atslēgu (piemēram, getProperty atgriešanas tips).
  • Izveidot jaunus tipus, kas sastāv no specifiskiem īpašību tipiem no citiem tipiem.
  • Veikt tipa līmeņa meklēšanu.

Atšķirība ir smalka, bet izšķiroša: keyof ir par *atslēgām*, savukārt indeksa piekļuves tipi ir par *vērtību tipiem* pie šīm atslēgām.

Sinerģiskais spēks: keyof un indeksa piekļuves tipu izmantošana kopā

Šo jēdzienu jaudīgākās pielietošanas iespējas bieži ietver to apvienošanu. Kanoniskais piemērs ir mūsu getProperty funkcija:

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

            

              
                Copy
              
            
          

Analizēsim šo parakstu vēlreiz, novērtējot sinerģiju:

• <T>: Mēs ieviešam ģenērisko tipu T objektam. Tas ļauj funkcijai darboties ar *jebkuru* objekta tipu.
• <K extends keyof T>: Mēs ieviešam otru ģenērisko tipu K īpašības atslēgai. Atslēgvārds extends keyof T ir vitāli svarīgs; tas nodrošina, ka funkcijai nodotais key arguments ir jābūt derīgam obj īpašības nosaukumam. Ja šeit nav keyof, K varētu būt jebkura virkne, padarot funkciju nedrošu.
• (obj: T, key: K): Funkcijas parametri ir tipi T un K.
• : T[K]: Šis ir indeksa piekļuves tips. Tas dinamiski nosaka atgriešanas tipu. Tā kā K ir ierobežots kā T atslēga, T[K] precīzi dod mums vērtības tipu pie konkrētās īpašības. Tas nodrošina spēcīgu tipu inferenci atgriešanas vērtībai. Bez T[K] atgriešanas tips būtu any vai plašāks tips, zaudējot specifiskumu.

Sarežģītāku utilitātes tipu veidošana

Daudzi no TypeScript iebūvētajiem utilitātes tipiem, piemēram, Pick<T, K> un Omit<T, K>, iekšēji izmanto keyof un indeksa piekļuves tipus. Apskatīsim, kā varētu ieviest vienkāršotu Pick versiju:

            
/**
 * Constructs a type by picking the set of properties K from Type T.
 * @template T The original type.
 * @template K The union of keys to pick, which must be keys of T.
 */
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'>;
/*
Equivalent to:
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; // Error: Property 'sourceIp' does not exist on type 'CriticalLogInfo'.

            

              
                Copy
              
            
          

MyPick<T, K extends keyof T> gadījumā:

• K extends keyof T: Nodrošina, ka atslēgas, kuras vēlamies izvēlēties (K), patiešām ir derīgas sākotnējā tipa T atslēgas.
• [P in K]: Šis ir kartētais tips. Tas iterē pa katru literālo tipu P apvienotajā tipā K.
• T[P]: Katrai atslēgai P tas izmanto indeksa piekļuves tipu, lai iegūtu atbilstošās īpašības tipu no sākotnējā tipa T.

Šis piemērs lieliski ilustrē apvienoto spēku, ļaujot jums izveidot jaunas, tipu drošas struktūras, precīzi atlasot un izvilkot daļas no esošajiem tipiem. Šādi utilitārie tipi ir nenovērtējami datu konsekvences uzturēšanai sarežģītās sistēmās, īpaši, ja dažādi komponenti (piemēram, priekšgala UI, aizmugursistēmas pakalpojums, mobilā lietotne) var mijiedarboties ar dažādām koplietojama datu modeļa apakškopām.

Dinamiska Record tipu veidošana

Utilitātes tips Record<K, T> ir vēl viens jaudīgs iebūvēts tips, kas izveido objekta tipu, kura īpašību atslēgas ir K tips un īpašību vērtības ir T tips. Jūs varat apvienot keyof ar Record, lai dinamiski ģenerētu tipus vārdnīcām vai kartēm, kur atslēgas ir atvasinātas no esoša tipa.

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

// Create a type that maps each permission key to a 'PermissionStatus'
type PermissionStatus = 'granted' | 'denied' | 'pending';

type PermissionsMapping = Record<keyof Permissions, PermissionStatus>;
/*
Equivalent to:
{
  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'; // Error: Property 'delete' does not exist on type 'PermissionsMapping'.

            

              
                Copy
              
            
          

Šis modelis ir ļoti noderīgs, lai ģenerētu meklēšanas tabulas, statusa paneļus vai piekļuves kontroles sarakstus, kur atslēgas ir tieši saistītas ar esošajām datu modeļa īpašībām vai funkcionālajām iespējām.

Tipu kartēšana ar keyof un indeksa piekļuvi

Kartēšanas tipi ļauj transformēt katru esošā tipa īpašību jaunā tipā. Šeit keyof un indeksa piekļuves tipi patiesi izceļas, ļaujot veikt sarežģītas tipu atvasināšanas. Bieži sastopams lietojums ir visu objekta īpašību transformēšana asinhronās operācijās, kas atspoguļo biežu modeli API dizainā vai notikumu vadītās arhitektūrās.

Piemērs: MapToPromises<T>

Izveidosim utilitātes tipu, kas ņem objekta tipu T un transformē to jaunā tipā, kurā katras īpašības vērtība ir iesaiņota Promise.

            
/**
 * Transforms an object type T into a new type where each property's value
 * is wrapped in a Promise.
 * @template T The original object type.
 */
type MapToPromises<T> = {
  [P in keyof T]: Promise<T[P]>;
};

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

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

// Example usage:
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()); // This would be type-safe (string methods available)
}

displayUser();

            

              
                Copy
              
            
          

MapToPromises<T> gadījumā:

• [P in keyof T]: Tas kartē visus īpašību atslēgas P no ievades tipa T. keyof T nodrošina visu īpašību nosaukumu apvienību.
• Promise<T[P]>: Katrai atslēgai P tas ņem sākotnējās īpašības tipu T[P] (izmantojot indeksa piekļuves tipu) un iesaiņo to Promise.

Tas ir spēcīgs demonstrējums tam, kā keyof un indeksa piekļuves tipi sadarbojas, lai definētu sarežģītas tipu transformācijas, ļaujot jums veidot ļoti izteiksmīgus un tipu drošus API asinhronām operācijām, datu kešatmiņai vai jebkuram scenārijam, kurā jums ir jāmaina īpašību tipi konsekventā veidā. Šādas tipu transformācijas ir kritiskas izkliedētajās sistēmās un mikropakalpojumu arhitektūrās, kur datu formām var būt nepieciešams pielāgoties dažādās pakalpojumu robežās.

Secinājums: Tipu drošības un elastības apguve

Mūsu padziļinātā iedziļināšanās keyof un indeksa piekļuves tipos atklāj tos ne tikai kā atsevišķas funkcijas, bet kā papildinošus pīlārus TypeScript uzlabotajā ģenērisko tipu sistēmā. Tie dod iespēju izstrādātājiem visā pasaulē veidot neticami elastīgu, atkārtoti izmantojamu un, pats galvenais, tipu drošu kodu. Sarežģītu lietojumprogrammu, dažādu komandu un globālas sadarbības laikmetā koda kvalitātes un paredzamības nodrošināšana kompilēšanas laikā ir vissvarīgākā. Šie uzlabotie ģenēriskie ierobežojumi ir būtiski rīki šajā centienā.

Izprotot un efektīvi izmantojot keyof, jūs iegūstat spēju precīzi atsaukties uz īpašību nosaukumiem un tos ierobežot, nodrošinot, ka jūsu ģenēriskās funkcijas un tipi darbojas tikai ar objekta derīgajām daļām. Vienlaikus, apgūstot indeksa piekļuves tipus (T[K]), jūs atbloķējat spēju precīzi izvilkt un atvasināt šo īpašību tipus, padarot jūsu tipu definīcijas adaptīvas un ļoti specifiskas.

Sinerģija starp keyof un indeksa piekļuves tipiem, kā tas redzams tādos modeļos kā getProperty funkcija un pielāgotie utilitātes tipi, piemēram, MyPick vai MapToPromises, ir nozīmīgs solis tipu līmeņa programmēšanā. Šīs tehnikas pārsniedz vienkāršu datu aprakstīšanu, ļaujot aktīvi manipulēt un transformēt pašus tipus, kas noved pie robustākas programmatūras arhitektūras un ievērojami uzlabotas izstrādātāja pieredzes.

Praktiski padomi globālajiem izstrādātājiem:

• Pieņemiet ģenēriskos tipus: Sāciet izmantot ģenēriskos tipus pat vienkāršākām funkcijām. Jo agrāk tos ieviesīsit, jo dabiskāki tie kļūs.
• Domājiet ierobežojumos: Ikreiz, kad rakstāt ģenērisku funkciju, jautājiet sev: "Kādām īpašībām vai metodēm T ir jābūt, lai šī funkcija darbotos?" Tas dabiski novedīs pie extends klauzulām un keyof.
• Izmantojiet indeksa piekļuvi: Ja jūsu ģenēriskās funkcijas atgriešanas tips (vai parametra tips) ir atkarīgs no citas ģenēriskā tipa konkrētas īpašības, domājiet par T[K].
• Izpētiet utilitātes tipus: Iepazīstieties ar TypeScript iebūvētajiem utilitātes tipiem (Pick, Omit, Record, Partial, Required) un novērojiet, kā tie izmanto šos jēdzienus. Mēģiniet atjaunot vienkāršotas versijas, lai nostiprinātu izpratni.
• Dokumentējiet savus tipus: Sarežģītiem ģenēriskiem tipiem, īpaši koplietojamās bibliotēkās, sniedziet skaidrus komentārus, kas izskaidro to mērķi un to, kā ģenēriskie parametri tiek ierobežoti un izmantoti. Tas ievērojami veicina starptautisko komandu sadarbību.
• Praktizējieties ar reāliem scenārijiem: Pielietojiet šos jēdzienus saviem ikdienas kodēšanas izaicinājumiem – vai tas būtu elastīgas datu tabulas veidošana, tipu droša konfigurācijas ielādētāja izveide vai atkārtoti izmantojama API klienta projektēšana.

Uzlabotu ģenērisko ierobežojumu apguve ar keyof un indeksa piekļuves tipiem nav tikai par vairāk TypeScript rakstīšanu; tas ir par labāka, drošāka un vieglāk uzturama koda rakstīšanu, kas var pārliecinoši darbināt lietojumprogrammas visās jomās un ģeogrāfiskajās vietās. Turpiniet eksperimentēt, turpiniet mācīties un dodiet spēku saviem globālās izstrādes centieniem ar pilnu TypeScript tipu sistēmas spēku!