TypeScript nominālie zīmoli: necaurspīdīgu tipu definīcijas uzlabotai tipu drošībai

TypeScript, lai gan piedāvā statisku tipizēšanu, galvenokārt izmanto strukturālo tipizēšanu. Tas nozīmē, ka tipi tiek uzskatīti par saderīgiem, ja tiem ir vienāda forma, neatkarīgi no to deklarētajiem nosaukumiem. Lai gan šī pieeja ir elastīga, tā dažreiz var novest pie nejaušas tipu aizstāšanas un samazinātas tipu drošības. Nominālā zīmološana, kas pazīstama arī kā necaurspīdīgu tipu definīcijas, piedāvā veidu, kā sasniegt robustāku tipu sistēmu, kas ir tuvāka nominālajai tipizēšanai, izmantojot TypeScript. Šī pieeja izmanto gudras metodes, lai tipiem liktu uzvesties tā, it kā tiem būtu unikāli nosaukumi, novēršot nejaušas kļūdas un nodrošinot koda pareizību.

Strukturālās un nominālās tipizēšanas izpratne

Pirms iedziļināties nominālajā zīmološanā, ir ļoti svarīgi saprast atšķirību starp strukturālo un nominālo tipizēšanu.

Strukturālā tipizēšana

Strukturālajā tipizēšanā divi tipi tiek uzskatīti par saderīgiem, ja tiem ir viena un tā pati struktūra (t.i., vienādas īpašības ar vienādiem tipiem). Apsveriet šo TypeScript piemēru:

interface Kilogram { value: number; }
interface Gram { value: number; }

const kg: Kilogram = { value: 10 };
const g: Gram = { value: 10000 };

// TypeScript to atļauj, jo abiem tipiem ir vienāda struktūra
const kg2: Kilogram = g;

console.log(kg2);

Pat ja `Kilogram` un `Gram` attēlo dažādas mērvienības, TypeScript atļauj piešķirt `Gram` objektu `Kilogram` mainīgajam, jo tiem abiem ir `value` īpašība ar tipu `number`. Tas var novest pie loģiskām kļūdām jūsu kodā.

Nominālā tipizēšana

Turpretim nominālā tipizēšana uzskata, ka divi tipi ir saderīgi tikai tad, ja tiem ir viens un tas pats nosaukums vai ja viens ir skaidri atvasināts no otra. Tādas valodas kā Java un C# galvenokārt izmanto nominālo tipizēšanu. Ja TypeScript izmantotu nominālo tipizēšanu, iepriekšminētais piemērs radītu tipa kļūdu.

Nominālās zīmološanas nepieciešamība TypeScript

TypeScript strukturālā tipizēšana parasti ir izdevīga tās elastības un lietošanas vienkāršības dēļ. Tomēr ir situācijas, kad jums ir nepieciešama stingrāka tipu pārbaude, lai novērstu loģiskas kļūdas. Nominālā zīmološana nodrošina risinājumu, lai to panāktu, nezaudējot TypeScript priekšrocības.

Apsveriet šādus scenārijus:

• Valūtas apstrāde: Atšķirt `USD` un `EUR` summas, lai novērstu nejaušu valūtas sajaukšanu.
• Datu bāzes ID: Nodrošināt, ka `UserID` netiek nejauši izmantots tur, kur ir paredzēts `ProductID`.
• Mērvienības: Atšķirt `Metrus` un `Pēdas`, lai izvairītos no nepareiziem aprēķiniem.
• Droši dati: Atšķirt vienkārša teksta `Parole` un šifrētas `PasswordHash` paroles, lai novērstu jutīgas informācijas nejaušu atklāšanu.

Katrajā no šiem gadījumiem strukturālā tipizēšana var novest pie kļūdām, jo pamatā esošais attēlojums (piemēram, skaitlis vai virkne) ir vienāds abiem tipiem. Nominālā zīmološana palīdz nodrošināt tipu drošību, padarot šos tipus atšķirīgus.

Nominālo zīmolu ieviešana TypeScript

Ir vairāki veidi, kā ieviest nominālo zīmološanu TypeScript. Mēs izpētīsim izplatītu un efektīvu tehniku, izmantojot krustpunktus un unikālus simbolus.

Krustpunktu un unikālu simbolu izmantošana

Šī tehnika ietver unikāla simbola izveidi un tā krustošanu ar bāzes tipu. Unikālais simbols darbojas kā “zīmols”, kas atšķir tipu no citiem ar vienādu struktūru.

// Definē unikālu simbolu Kilogram zīmolam
const kilogramBrand: unique symbol = Symbol();

// Definē Kilogram tipu, kas ir apzīmēts ar unikālu simbolu
type Kilogram = number & { readonly [kilogramBrand]: true };

// Definē unikālu simbolu Gram zīmolam
const gramBrand: unique symbol = Symbol();

// Definē Gram tipu, kas ir apzīmēts ar unikālu simbolu
type Gram = number & { readonly [gramBrand]: true };

// Palīgfunkcija Kilogram vērtību izveidei
const Kilogram = (value: number) => value as Kilogram;

// Palīgfunkcija Gram vērtību izveidei
const Gram = (value: number) => value as Gram;

const kg: Kilogram = Kilogram(10);
const g: Gram = Gram(10000);

// Tas tagad izraisīs TypeScript kļūdu
// const kg2: Kilogram = g; // Tips 'Gram' nav piešķirams tipam 'Kilogram'.

console.log(kg, g);

Paskaidrojums:

• Mēs definējam unikālu simbolu, izmantojot `Symbol()`. Katrs `Symbol()` izsaukums izveido unikālu vērtību, nodrošinot, ka mūsu zīmoli ir atšķirīgi.
• Mēs definējam `Kilogram` un `Gram` tipus kā `number` un objekta, kas satur unikālo simbolu kā atslēgu ar `true` vērtību, krustojumus. Modifikators `readonly` nodrošina, ka zīmolu nevar modificēt pēc izveidošanas.
• Mēs izmantojam palīgfunkcijas (`Kilogram` un `Gram`) ar tipa apgalvojumiem (`as Kilogram` un `as Gram`), lai izveidotu apzīmētu tipu vērtības. Tas ir nepieciešams, jo TypeScript nevar automātiski secināt apzīmēto tipu.

Tagad TypeScript pareizi atzīmē kļūdu, kad mēģināt piešķirt `Gram` vērtību `Kilogram` mainīgajam. Tas nodrošina tipa drošību un novērš nejaušas sajaukšanas.

Ģenerēšanas zīmološana atkārtotai izmantošanai

Lai izvairītos no zīmološanas parauga atkārtošanas katram tipam, varat izveidot ģenerēšanas palīgtipu:

type Brand<K, T> = K & { readonly __brand: unique symbol; };

// Definē Kilogram, izmantojot ģenerisko Brand tipu
type Kilogram = Brand<number, 'Kilogram'>;

// Definē Gram, izmantojot ģenerisko Brand tipu
type Gram = Brand<number, 'Gram'>;

// Palīgfunkcija Kilogram vērtību izveidei
const Kilogram = (value: number) => value as Kilogram;

// Palīgfunkcija Gram vērtību izveidei
const Gram = (value: number) => value as Gram;

const kg: Kilogram = Kilogram(10);
const g: Gram = Gram(10000);

// Tas joprojām izraisīs TypeScript kļūdu
// const kg2: Kilogram = g; // Tips 'Gram' nav piešķirams tipam 'Kilogram'.

console.log(kg, g);

Šī pieeja vienkāršo sintaksi un atvieglo apzīmētu tipu konsekventu definēšanu.

Papildu lietošanas gadījumi un apsvērumi

Objektu zīmološana

Nominālo zīmološanu var piemērot arī objektu tipiem, ne tikai tādiem primitīvajiem tipiem kā skaitļi vai virknes.

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

const UserIDBrand: unique symbol = Symbol();
type UserID = number & { readonly [UserIDBrand]: true };

interface Product {
  id: number;
  name: string;
}

const ProductIDBrand: unique symbol = Symbol();
type ProductID = number & { readonly [ProductIDBrand]: true };

// Funkcija, kas paredz UserID
function getUser(id: UserID): User {
  // ... ieviešana, lai izgūtu lietotāju pēc ID
  return {id: id, name: "Example User"};
}

const userID = 123 as UserID;
const productID = 456 as ProductID;

const user = getUser(userID);

// Tas izraisītu kļūdu, ja netiktu izkomentēts
// const user2 = getUser(productID); // Arguments of type 'ProductID' is not assignable to parameter of type 'UserID'.

console.log(user);

Tas novērš nejaušu `ProductID` nodošanu tur, kur ir paredzēts `UserID`, pat ja abi galu galā ir attēloti kā skaitļi.

Darbs ar bibliotēkām un ārējiem tipiem

Strādājot ar ārējām bibliotēkām vai API, kas nepiedāvā apzīmētos tipus, varat izmantot tipu apgalvojumus, lai izveidotu apzīmētos tipus no esošajām vērtībām. Tomēr esiet piesardzīgs, to darot, jo būtībā apgalvojat, ka vērtība atbilst apzīmētajam tipam, un jums ir jāpārliecinās, ka tas patiešām tā ir.

// Pieņemsim, ka jūs saņemat numuru no API, kas attēlo UserID
const rawUserID = 789; // Numurs no ārējā avota

// Izveidojiet apzīmētu UserID no neapstrādāta numura
const userIDFromAPI = rawUserID as UserID;

Izpildlaika apsvērumi

Ir svarīgi atcerēties, ka nominālā zīmološana TypeScript ir tikai kompilācijas laika konstrukcija. Zīmoli (unikālie simboli) tiek dzēsti kompilācijas laikā, tāpēc nav izpildlaika papildu izdevumu. Tomēr tas nozīmē arī to, ka nevarat paļauties uz zīmoliem izpildlaika tipu pārbaudei. Ja jums ir nepieciešama izpildlaika tipu pārbaude, jums būs jāievieš papildu mehānismi, piemēram, pielāgoti tipu sargi.

Tipu sargi izpildlaika validācijai

Lai veiktu apzīmēto tipu izpildlaika validāciju, varat izveidot pielāgotus tipu sargus:

function isKilogram(value: number): value is Kilogram {
  // Reālajā scenārijā jūs varat pievienot papildu pārbaudes šeit,
  // piemēram, pārliecinoties, ka vērtība ir kilogramiem derīgā diapazonā.
  return typeof value === 'number';
}

const someValue: any = 15;

if (isKilogram(someValue)) {
  const kg: Kilogram = someValue;
  console.log("Vērtība ir Kilogram:", kg);
} else {
  console.log("Vērtība nav Kilogram");
}

Tas ļauj droši sašaurināt vērtības tipu izpildlaikā, nodrošinot, ka tas atbilst apzīmētajam tipam, pirms to izmantojat.

Nominālās zīmološanas priekšrocības

• Uzlabota tipu drošība: Novērš nejaušas tipu aizstāšanas un samazina loģisko kļūdu risku.
• Uzlabota koda skaidrība: Padara kodu lasāmāku un vieglāk saprotamu, skaidri atšķirot dažādus tipus ar vienu un to pašu pamata attēlojumu.
• Samazināts atkļūdošanas laiks: Atklāj ar tipiem saistītas kļūdas kompilācijas laikā, ietaupot laiku un pūles atkļūdošanas laikā.
• Paaugstināta koda uzticība: Nodrošina lielāku pārliecību par koda pareizību, nodrošinot stingrākus tipa ierobežojumus.

Nominālās zīmološanas ierobežojumi

• Tikai kompilācijas laiks: Zīmoli tiek dzēsti kompilācijas laikā, tāpēc tie nenodrošina izpildlaika tipu pārbaudi.
• Nepieciešami tipu apgalvojumi: Apzīmēto tipu izveidei bieži vien ir nepieciešami tipu apgalvojumi, kas potenciāli var apiet tipu pārbaudi, ja tiek izmantoti nepareizi.
• Palielināts paraugs: Apzīmēto tipu definēšana un izmantošana var pievienot jūsu kodam nelielu paraugu, lai gan to var mazināt ar ģenerēšanas palīgtipiem.

Labākā prakse nominālo zīmolu izmantošanai

• Izmantojiet ģenerālo zīmološanu: Izveidojiet ģenerālās palīgtipus, lai samazinātu paraugu un nodrošinātu konsekvenci.
• Izmantojiet tipu sargus: Ja nepieciešams, ieviesiet pielāgotus tipu sargus izpildlaika validācijai.
• Piemērojiet zīmolus apdomīgi: Nepārforsējiet nominālo zīmološanu. Piemērojiet to tikai tad, kad jums ir jāpiemēro stingrāka tipu pārbaude, lai novērstu loģiskas kļūdas.
• Skaidri dokumentējiet zīmolus: Skaidri dokumentējiet katra apzīmētā tipa mērķi un lietojumu.
• Apsveriet veiktspēju: Lai gan izpildlaika izmaksas ir minimālas, kompilācijas laiks var palielināties pārmērīgas lietošanas gadījumā. Profilējiet un optimizējiet, ja nepieciešams.

Piemēri dažādās nozarēs un lietojumprogrammās

Nominālā zīmološana atrod lietojumu dažādās jomās:

• Finanšu sistēmas: Atšķirība starp dažādām valūtām (USD, EUR, GBP) un kontu veidiem (Krājkonti, Norēķinu konti), lai novērstu nepareizus darījumus un aprēķinus. Piemēram, banku lietojumprogramma var izmantot nominālos tipus, lai nodrošinātu, ka procentu aprēķini tiek veikti tikai krājkontiem un ka valūtas konvertācijas tiek pareizi piemērotas, pārskaitot līdzekļus starp kontiem dažādās valūtās.
• E-komercijas platformas: Atšķirība starp produktu ID, klientu ID un pasūtījuma ID, lai izvairītos no datu bojājumiem un drošības ievainojamībām. Iedomājieties, ka nejauši piešķirat klienta kredītkartes informāciju produktam – nominālie tipi var palīdzēt novērst šādas katastrofālas kļūdas.
• Veselības aprūpes lietojumprogrammas: Atšķirība starp pacientu ID, ārstu ID un iecelšanas ID, lai nodrošinātu pareizu datu asociāciju un novērstu pacientu ierakstu nejaušu sajaukšanu. Tas ir ļoti svarīgi pacientu privātuma un datu integritātes uzturēšanai.
• Piegādes ķēdes pārvaldība: Atšķirība starp noliktavu ID, sūtījuma ID un produkta ID, lai precīzi izsekotu preces un novērstu loģistikas kļūdas. Piemēram, nodrošinot, ka sūtījums tiek piegādāts pareizajā noliktavā un ka sūtījumā esošie produkti atbilst pasūtījumam.
• IoT (lietiskais internets) sistēmas: Atšķiršana starp sensora ID, ierīces ID un lietotāja ID, lai nodrošinātu pareizu datu vākšanu un kontroli. Tas ir īpaši svarīgi scenārijos, kur drošība un uzticamība ir vissvarīgākā, piemēram, viedās mājas automatizācijas vai rūpnieciskās vadības sistēmās.
• Spēles: Atšķirība starp ieroču ID, varoņu ID un priekšmetu ID, lai uzlabotu spēles loģiku un novērstu izmantošanu. Vienkārša kļūda varētu ļaut spēlētājam aprīkot priekšmetu, kas paredzēts tikai NPC, izjaucot spēles līdzsvaru.

Alternatīvas nominālajai zīmološanai

Lai gan nominālā zīmološana ir jaudīga tehnika, citas pieejas var sasniegt līdzīgus rezultātus noteiktās situācijās:

• Klases: Klases ar privātām īpašībām izmantošana var nodrošināt zināmu nominālās tipizēšanas pakāpi, jo dažādu klašu instances pēc būtības atšķiras. Tomēr šī pieeja var būt izvērstāka nekā nominālā zīmološana un var nebūt piemērota visiem gadījumiem.
• Enum: TypeScript enumu izmantošana nodrošina zināmu nominālās tipizēšanas pakāpi izpildlaikā noteiktam, ierobežotam iespējamo vērtību kopumam.
• Literāļu tipi: Virknes vai skaitļu literāļu tipu izmantošana var ierobežot mainīgā iespējamās vērtības, taču šī pieeja nenodrošina tādu pašu tipa drošības līmeni kā nominālā zīmološana.
• Ārējās bibliotēkas: Tādas bibliotēkas kā `io-ts` piedāvā izpildlaika tipu pārbaudes un validācijas iespējas, kuras var izmantot, lai nodrošinātu stingrākus tipa ierobežojumus. Tomēr šīs bibliotēkas pievieno izpildlaika atkarību un var nebūt nepieciešamas visiem gadījumiem.

Secinājums

TypeScript nominālā zīmološana nodrošina spēcīgu veidu, kā uzlabot tipu drošību un novērst loģiskas kļūdas, izveidojot necaurspīdīgas tipu definīcijas. Lai gan tas neaizstāj patiesu nominālo tipizēšanu, tas piedāvā praktisku risinājumu, kas var ievērojami uzlabot jūsu TypeScript koda robustumu un uzturamību. Saprotot nominālās zīmološanas principus un apdomīgi tos piemērojot, jūs varat rakstīt uzticamākas un bez kļūdām lietojumprogrammas.

Atcerieties, ka, lemjot par nominālās zīmološanas izmantošanu savos projektos, jāņem vērā kompromisi starp tipu drošību, koda sarežģītību un izpildlaika papildu izmaksām.

Ietverot labāko praksi un rūpīgi apsverot alternatīvas, jūs varat izmantot nominālo zīmološanu, lai rakstītu tīrāku, vieglāk uzturamu un robustāku TypeScript kodu. Izbaudiet tipu drošības spēku un veidojiet labāku programmatūru!