TypeScript precīzie tipi: stingra objektu formas saskaņošana robustam kodam

TypeScript, kas ir JavaScript virskopa, ienes statisko tipēšanu dinamiskajā tīmekļa izstrādes pasaulē. Lai gan TypeScript piedāvā ievērojamas priekšrocības attiecībā uz tipu drošību un koda uzturējamību, tā strukturālās tipēšanas sistēma dažkārt var izraisīt neparedzētu uzvedību. Šeit spēlē nāk "precīzo tipu" koncepcija. Lai gan TypeScript nav iebūvētas funkcijas ar nosaukumu "precīzie tipi", mēs varam panākt līdzīgu uzvedību, izmantojot TypeScript funkciju un metožu kombināciju. Šis emuāra ieraksts iedziļināsies, kā ieviest stingrāku objektu formas saskaņošanu TypeScript, lai uzlabotu koda robustumu un novērstu bieži sastopamas kļūdas.

Izpratne par TypeScript strukturālo tipēšanu

TypeScript izmanto strukturālo tipēšanu (zināmu arī kā "duck typing"), kas nozīmē, ka tipu saderību nosaka tipu dalībnieki, nevis to deklarētie nosaukumi. Ja objektam ir visas īpašības, ko pieprasa tips, tas tiek uzskatīts par saderīgu ar šo tipu, neatkarīgi no tā, vai tam ir papildu īpašības.

Piemēram:

interface Point {
  x: number;
  y: number;
}

const myPoint = { x: 10, y: 20, z: 30 };

function printPoint(point: Point) {
  console.log(`X: ${point.x}, Y: ${point.y}`);
}

printPoint(myPoint); // Tas darbojas labi, lai gan myPoint ir īpašība 'z'

Šajā scenārijā TypeScript ļauj nodot `myPoint` funkcijai `printPoint`, jo tas satur nepieciešamās `x` un `y` īpašības, lai gan tam ir papildu īpašība `z`. Lai gan šī elastība var būt ērta, tā var arī izraisīt smalkas kļūdas, ja nejauši nododat objektus ar neparedzētām īpašībām.

Problēma ar liekajām īpašībām

Strukturālās tipēšanas pielaidība dažkārt var maskēt kļūdas. Apsveriet funkciju, kas sagaida konfigurācijas objektu:

interface Config {
  apiUrl: string;
  timeout: number;
}

function setup(config: Config) {
  console.log(`API URL: ${config.apiUrl}`);
  console.log(`Timeout: ${config.timeout}`);
}

const myConfig = { apiUrl: "https://api.example.com", timeout: 5000, typo: true };

setup(myConfig); // TypeScript šeit nesūdzas!

console.log(myConfig.typo); //izdrukā true. Papildu īpašība klusi eksistē

Šajā piemērā `myConfig` ir papildu īpašība `typo`. TypeScript neizsauc kļūdu, jo `myConfig` joprojām atbilst `Config` saskarnei. Tomēr drukas kļūda nekad netiek noķerta, un lietojumprogramma varētu nedarboties, kā paredzēts, ja drukas kļūda bija domāta kā `typoo`. Šīs šķietami nenozīmīgās problēmas var pāraugt lielās galvassāpēs, atkļūdojot sarežģītas lietojumprogrammas. Trūkstoša vai nepareizi uzrakstīta īpašība var būt īpaši grūti atklājama, strādājot ar objektiem, kas ligzdoti citos objektos.

Pieejas precīzo tipu ieviešanai TypeScript

Lai gan patiesi "precīzie tipi" nav tieši pieejami TypeScript, ir vairākas metodes, kā panākt līdzīgus rezultātus un ieviest stingrāku objektu formas saskaņošanu:

1. Tipu apgalvojumu izmantošana ar `Omit`

`Omit` utilīttips ļauj izveidot jaunu tipu, izslēdzot noteiktas īpašības no esoša tipa. Apvienojumā ar tipa apgalvojumu tas var palīdzēt novērst liekās īpašības.

interface Point {
  x: number;
  y: number;
}

const myPoint = { x: 10, y: 20, z: 30 };

// Izveidojiet tipu, kas ietver tikai Point īpašības
const exactPoint: Point = myPoint as Omit & Point;

// Kļūda: Tips '{ x: number; y: number; z: number; }' nav piešķirams tipam 'Point'.
// Objekta literālis var norādīt tikai zināmas īpašības, un 'z' nepastāv tipā 'Point'.

function printPoint(point: Point) {
  console.log(`X: ${point.x}, Y: ${point.y}`);
}


//Labojums
const myPointCorrect = { x: 10, y: 20 };
const exactPointCorrect: Point = myPointCorrect as Omit & Point;
printPoint(exactPointCorrect);

Šī pieeja izmetīs kļūdu, ja `myPoint` būs īpašības, kas nav definētas `Point` saskarnē.

Paskaidrojums: `Omit` izveido tipu, kas no `myPoint` tipa izslēdz visas atslēgas, kas atrodas `Point`. Pēc tam `& Point` šo tipu krusto ar `Point` tipu, būtībā pieprasot, lai objekts atbilstu `Point` tipam. Apgalvojot objektu šim apvienotajam tipam, kompilators pārbauda papildu īpašības un izmet kļūdu, ja tādas tiek atrastas. Tas liek mums deklarēt pareizo formu, sākotnēji definējot mūsu objektu.

2. Funkcijas izmantošana objektu veidošanai

Jūs varat izveidot rūpnīcas funkciju, kas pieņem tikai tās īpašības, kas definētas saskarnē. Šī pieeja nodrošina spēcīgu tipu pārbaudi objekta izveides brīdī.

interface Config {
  apiUrl: string;
  timeout: number;
}

function createConfig(config: Config): Config {
  return {
    apiUrl: config.apiUrl,
    timeout: config.timeout,
  };
}

const myConfig = createConfig({ apiUrl: "https://api.example.com", timeout: 5000 });

//Šis netiks kompilēts:
//const myConfigError = createConfig({ apiUrl: "https://api.example.com", timeout: 5000, typo: true });
//Argumenta tips '{ apiUrl: string; timeout: number; typo: true; }' nav piešķirams parametra tipam 'Config'.
// Objekta literālis var norādīt tikai zināmas īpašības, un 'typo' nepastāv tipā 'Config'.

Atgriežot objektu, kas konstruēts tikai ar `Config` saskarnē definētajām īpašībām, jūs nodrošināt, ka nevar iezagties liekas īpašības. Tas padara konfigurācijas izveidi drošāku.

3. Tipu aizsargu izmantošana

Tipu aizsargi ir funkcijas, kas sašaurina mainīgā tipu noteiktā darbības jomā. Lai gan tie tieši nenovērš liekās īpašības, tie var palīdzēt jums tās skaidri pārbaudīt un veikt atbilstošas darbības.

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

function isUser(obj: any): obj is User {
  return (
    typeof obj === 'object' &&
    obj !== null &&
    'id' in obj && typeof obj.id === 'number' &&
    'name' in obj && typeof obj.name === 'string' &&
    Object.keys(obj).length === 2 //pārbauda atslēgu skaitu. Piezīme: trausls un atkarīgs no User precīzā atslēgu skaita.
  );
}

const potentialUser1 = { id: 123, name: "Alice" };
const potentialUser2 = { id: 456, name: "Bob", extra: true };

if (isUser(potentialUser1)) {
  console.log("Valid User:", potentialUser1.name);
} else {
  console.log("Invalid User");
}

if (isUser(potentialUser2)) {
  console.log("Valid User:", potentialUser2.name); //Šeit nenonāks
} else {
  console.log("Invalid User");
}

Šajā piemērā `isUser` tipu aizsargs pārbauda ne tikai nepieciešamo īpašību esamību, bet arī to tipus un *precīzu* īpašību skaitu. Šī pieeja ir skaidrāka un ļauj jums eleganti apstrādāt nederīgus objektus. Tomēr īpašību skaita pārbaude ir trausla. Ikreiz, kad `User` iegūst/zaudē īpašības, pārbaude ir jāatjaunina.

4. `Readonly` un `as const` izmantošana

Kamēr `Readonly` novērš esošo īpašību modificēšanu un `as const` izveido tikai lasāmu kortežu vai objektu, kur visas īpašības ir dziļi tikai lasāmas un tām ir literālie tipi, tos var izmantot, lai radītu stingrāku definīciju un tipu pārbaudi, apvienojot ar citām metodēm. Tomēr neviens no tiem pats par sevi nenovērš liekās īpašības.

interface Options {
  width: number;
  height: number;
}

//Izveidojiet Readonly tipu
type ReadonlyOptions = Readonly;

const options: ReadonlyOptions = { width: 100, height: 200 };

//options.width = 300; //kļūda: Nevar piešķirt 'width', jo tā ir tikai lasāma īpašība.

//Izmantojot as const
const config = { api_url: "https://example.com", timeout: 3000 } as const;

//config.timeout = 5000; //kļūda: Nevar piešķirt 'timeout', jo tā ir tikai lasāma īpašība.

//Tomēr liekās īpašības joprojām ir atļautas:
const invalidOptions: ReadonlyOptions = { width: 100, height: 200, depth: 300 }; //nav kļūdas. Joprojām atļauj liekās īpašības.


interface StrictOptions {
  readonly width: number;
  readonly height: number;
}

//Tagad būs kļūda:
//const invalidStrictOptions: StrictOptions = { width: 100, height: 200, depth: 300 };
//Tips '{ width: number; height: number; depth: number; }' nav piešķirams tipam 'StrictOptions'.
//  Objekta literālis var norādīt tikai zināmas īpašības, un 'depth' nepastāv tipā 'StrictOptions'.

Tas uzlabo nemainīgumu, bet novērš tikai mutāciju, nevis papildu īpašību esamību. Apvienojumā ar `Omit` vai funkcijas pieeju tas kļūst efektīvāks.

5. Bibliotēku izmantošana (piemēram, Zod, io-ts)

Bibliotēkas kā Zod un io-ts piedāvā jaudīgas izpildlaika tipu validācijas un shēmu definēšanas iespējas. Šīs bibliotēkas ļauj definēt shēmas, kas precīzi apraksta jūsu datu sagaidāmo formu, ieskaitot lieko īpašību novēršanu. Lai gan tās pievieno izpildlaika atkarību, tās piedāvā ļoti robustu un elastīgu risinājumu.

Piemērs ar Zod:

import { z } from 'zod';

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
});

type User = z.infer;

const validUser = { id: 1, name: "John" };
const invalidUser = { id: 2, name: "Jane", extra: true };

const parsedValidUser = UserSchema.parse(validUser);
console.log("Parsed Valid User:", parsedValidUser);

try {
  const parsedInvalidUser = UserSchema.parse(invalidUser);
  console.log("Parsed Invalid User:", parsedInvalidUser); // Šis netiks sasniegts
} catch (error) {
  console.error("Validation Error:", error.errors);
}

Zod `parse` metode izmetīs kļūdu, ja ievade neatbilst shēmai, efektīvi novēršot liekās īpašības. Tas nodrošina izpildlaika validāciju un arī ģenerē TypeScript tipus no shēmas, nodrošinot konsekvenci starp jūsu tipu definīcijām un izpildlaika validācijas loģiku.

Labākā prakse precīzo tipu ieviešanai

Šeit ir dažas labākās prakses, kas jāņem vērā, ieviešot stingrāku objektu formas saskaņošanu TypeScript:

• Izvēlieties pareizo metodi: Labākā pieeja ir atkarīga no jūsu specifiskajām vajadzībām un projekta prasībām. Vienkāršiem gadījumiem var pietikt ar tipu apgalvojumiem ar `Omit` vai rūpnīcas funkcijām. Sarežģītākiem scenārijiem vai kad nepieciešama izpildlaika validācija, apsveriet iespēju izmantot bibliotēkas, piemēram, Zod vai io-ts.
• Esiet konsekventi: Piemērojiet izvēlēto pieeju konsekventi visā savā kodu bāzē, lai uzturētu vienotu tipu drošības līmeni.
• Dokumentējiet savus tipus: Skaidri dokumentējiet savas saskarnes un tipus, lai citiem izstrādātājiem paziņotu par jūsu datu sagaidāmo formu.
• Testējiet savu kodu: Rakstiet vienības testus, lai pārbaudītu, vai jūsu tipu ierobežojumi darbojas kā paredzēts un vai jūsu kods eleganti apstrādā nederīgus datus.
• Apsveriet kompromisus: Stingrākas objektu formas saskaņošanas ieviešana var padarīt jūsu kodu robustāku, bet tas var arī palielināt izstrādes laiku. Izvērtējiet ieguvumus attiecībā pret izmaksām un izvēlieties pieeju, kas ir vispiemērotākā jūsu projektam.
• Pakāpeniska ieviešana: Ja strādājat ar lielu esošu kodu bāzi, apsveriet iespēju ieviest šīs metodes pakāpeniski, sākot ar jūsu lietojumprogrammas kritiskākajām daļām.
• Definējot objektu formas, dodiet priekšroku saskarnēm, nevis tipu aizstājvārdiem: Saskarnes parasti ir ieteicamākas, jo tās atbalsta deklarāciju apvienošanu, kas var būt noderīga, paplašinot tipus dažādos failos.

Reālās pasaules piemēri

Apskatīsim dažus reālās pasaules scenārijus, kuros precīzie tipi var būt noderīgi:

• API pieprasījumu datu pakas: Sūtot datus uz API, ir ļoti svarīgi nodrošināt, ka datu paka atbilst sagaidāmajai shēmai. Precīzo tipu ieviešana var novērst kļūdas, ko izraisa neparedzētu īpašību sūtīšana. Piemēram, daudzas maksājumu apstrādes API ir ārkārtīgi jutīgas pret neparedzētiem datiem.
• Konfigurācijas faili: Konfigurācijas faili bieži satur lielu skaitu īpašību, un drukas kļūdas var būt bieži sastopamas. Precīzo tipu izmantošana var palīdzēt noķert šīs drukas kļūdas agrīnā stadijā. Ja jūs iestatāt serveru atrašanās vietas mākoņa izvietošanā, drukas kļūda atrašanās vietas iestatījumā (piem., eu-west-1 pret eu-wet-1) kļūs ārkārtīgi grūti atkļūdojama, ja tā netiks noķerta jau sākumā.
• Datu transformācijas konveijeri: Pārveidojot datus no viena formāta uz otru, ir svarīgi nodrošināt, ka izvades dati atbilst sagaidāmajai shēmai.
• Ziņojumu rindas: Sūtot ziņojumus caur ziņojumu rindu, ir svarīgi nodrošināt, ka ziņojuma datu paka ir derīga un satur pareizās īpašības.

Piemērs: Internacionalizācijas (i18n) konfigurācija

Iedomājieties, ka pārvaldāt tulkojumus daudzvalodu lietojumprogrammai. Jums varētu būt šāds konfigurācijas objekts:

interface Translation {
  greeting: string;
  farewell: string;
}

interface I18nConfig {
  locale: string;
  translations: Translation;
}

const englishConfig: I18nConfig = {
  locale: "en-US",
  translations: {
    greeting: "Hello",
    farewell: "Goodbye"
  }
};


//Šī būs problēma, jo pastāv lieka īpašība, klusi ieviešot kļūdu.
const spanishConfig: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós",
    typo: "unintentional translation"
  }
};

//Risinājums: Izmantojot Omit
const spanishConfigCorrect: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós"
  } as Omit & Translation
};

Bez precīziem tipiem drukas kļūda tulkojuma atslēgā (piemēram, pievienojot `typo` lauku) varētu palikt nepamanīta, izraisot trūkstošus tulkojumus lietotāja saskarnē. Ieviešot stingrāku objektu formas saskaņošanu, jūs varat noķert šīs kļūdas izstrādes laikā un novērst to nonākšanu ražošanā.

Noslēgums

Lai gan TypeScript nav iebūvētu "precīzo tipu", jūs varat sasniegt līdzīgus rezultātus, izmantojot TypeScript funkciju un metožu kombināciju, piemēram, tipu apgalvojumus ar `Omit`, rūpnīcas funkcijas, tipu aizsargus, `Readonly`, `as const` un ārējās bibliotēkas, piemēram, Zod un io-ts. Ieviešot stingrāku objektu formas saskaņošanu, jūs varat uzlabot sava koda robustumu, novērst bieži sastopamas kļūdas un padarīt savas lietojumprogrammas uzticamākas. Atcerieties izvēlēties pieeju, kas vislabāk atbilst jūsu vajadzībām, un būt konsekventiem tās piemērošanā visā savā kodu bāzē. Rūpīgi apsverot šīs pieejas, jūs varat iegūt lielāku kontroli pār savas lietojumprogrammas tipiem un palielināt ilgtermiņa uzturējamību.