„TypeScript“: grąžinimo tipo apribojimų vykdymas naudojant eilės patvirtinimą

Tipo saugos užtikrinimas sudėtingose ​​TypeScript API

Dirbant su TypeScript sudėtingose ​​programose labai svarbu užtikrinti, kad kiekviena funkcija ar metodas atitiktų griežtą tipo struktūrą. Bet kas atsitinka, kai prie grąžinamo objekto netyčia pridedamos papildomos savybės? Dažnai „TypeScript“ nepastebės problemos, leisdamas kodui perduoti be įspėjimo. Dėl to gali atsirasti paslėptų klaidų, kurias vėliau gali būti sunku atsekti.

Paimkite, pavyzdžiui, scenarijų, kai kuriate API atsako tvarkyklę. Jei tvarkytojo grąžinimo tipas turėtų apimti tik konkrečius laukus, tarkime, „testas“ ir „riba“, tačiau atsiranda papildomų, nenumatytų savybių, tai gali panaikinti funkcionalumą. Griežtų tipo apribojimų vykdymas gali apsaugoti jus nuo netikėtų rezultatų ar vykdymo klaidų, ypač valdant dideles arba bendrai naudojamas kodų bazes. 😊

Šiame straipsnyje apžvelgsime pavyzdį API sąranką naudojant TypeScript kuri apima dvi skirtingas sritis: „LIST“ ir „GENERIC“. Kiekviena sritis turi savo numatomą struktūrą, tačiau iššūkis yra užtikrinti, kad atsakyme nebūtų papildomų laukų. Naudodami galingą „TypeScript“ tipo tikrinimo ir enums funkciją, galime įgyvendinti šias taisykles, kad užtikrintume švarų, nuspėjamą kodą.

Sekite toliau, kad pamatytumėte, kaip galime sukurti patikimus tipus „TypeScript“, kurie ne tik apibrėžia mūsų objektų formą, bet ir taiko apribojimus, kad būtų išvengta atsitiktinių papildymų, užtikrinant švaresnę ir patikimesnę kodų bazę. 🚀

Giliai pasinerkite į API atsakymų „TypeScript“ tipo vykdymą

Naudojant TypeScript griežtas API atsakymų tipų tikrinimas gali padėti anksti pastebėti klaidas, ypač dirbant su sudėtingais tipais ir enums. Aukščiau pateikti scenarijų pavyzdžiai yra skirti valdyti dviejų konkrečių tipų API atsakymus naudojant TypeScript sąrašai apibrėžti griežtas struktūras. Suskirstydami atsakymus į tipus „LIST“ arba „GENERIC“, naudodami Taikymo sritisType enum, sukuriame sistemą, kurioje kiekviena apimtis turi atitikti tikslią struktūrą. Tai ypač naudinga apibrėžiant tokias funkcijas kaip API atsakymai, kai kiekvienam atsakymo tipui reikalingi unikalūs laukai, pvz., ribinis laukas LIST tipo, kuris nėra būtinas GENERIC tipui. Praktiškai tai užtikrina, kad visas papildomas ypatybes, pvz., netikėtą „abc“ atsakyme, „TypeScript“ užfiksuos kompiliavimo metu, užkertant kelią vykdymo laiko problemoms ir išlaikant švaresnius duomenų srautus mūsų programose.

Norėdami tai pasiekti, apibrėžėme dvi sąsajas, GetApiPropsGeneric ir GetApiPropsList, kurie nurodo kiekvienos apimties atsakymo struktūrą. The rekvizitai funkcija šiose sąsajose grąžina arba a Bendras tipas arba a Sąrašas tipas, priklausomai nuo apimties. Bendrasis tipas yra lankstus, leidžiantis bet kokią struktūrą, tačiau sąrašo tipas prideda griežtą riba lauke, užtikrinant, kad LIST atsakymuose yra ši savybė. Tikroji galia čia yra įgyvendinant pagalbininkus, tokius kaip EnforceExactKeys, kuri leidžia mums nurodyti, kad mūsų grąžinamo objekto ypatybės turi tiksliai atitikti numatomą struktūrą – jokių papildomų savybių neleidžiama. Šis metodas yra būtinas valdant didelius projektus su keliais kūrėjais, kur tokie tipo patikrinimai gali užkirsti kelią tylioms klaidoms. 👨‍💻

Naudingumo tipas EnforceExactKeys yra šios sąrankos pagrindas. Jis veikia lygindamas kiekvieną laukiamo atsako struktūros raktą, kad įsitikintų, jog jie tiksliai atitinka tikrąjį atsakymo tipą. Jei randami papildomi raktai, pvz., „abc“, „TypeScript“ parodys kompiliavimo laiko klaidą. Toks griežtas tikrinimas gali užkirsti kelią problemoms, kurios kitu atveju būtų užkluptos tik gamyboje. Aukščiau pateiktuose scenarijuose naudojamas valideApiProps užtikrina, kad būtų priimtos tik nurodytos savybės, pridėdamas antrinį patvirtinimo sluoksnį. The valideApiProps funkcija veikia pasirinkdama skirtingus grąžinimo tipus pagal pateiktą apimtį, todėl ją galima priderinti ir vis tiek vykdyti struktūrą. Šis dviejų sluoksnių tipo vykdymas, naudojant „EnforceExactKeys“ ir „validateApiProps“, padidina mūsų „TypeScript“ kodų bazės patikimumą.

Siekiant užtikrinti, kad sprendimas išliktų patikimas, kiekvienai konfigūracijai patikrinti buvo pridėti vienetų testai. Naudojant Jest, apibūdinti ir bandymas funkcijos sukuria logines testų grupes ir atskirus testavimo atvejus. The tikėtis(...).toThrowError() funkcija patikrina, ar netinkamos ypatybės, pvz., „abc“ sąraše LIST, sukelia klaidą, patvirtinančią, kad mūsų struktūros patvirtinimas veikia. Pavyzdžiui, jei į rekvizitus patenka netinkama nuosavybė, Jest testai paryškins tai kaip nesėkmingą testą ir padės kūrėjams greitai išspręsti problemą. Kruopščiai išbandę kiekvieną konfigūraciją galime pasitikėti, kad mūsų „TypeScript“ sąranka teisingai apdoroja kiekvieną atsakymo tipą ir pateikia atitinkamas klaidas dėl bet kokių neatitikimų, todėl mūsų kodas tampa saugesnis, nuspėjamas ir patikimesnis. 🚀

// Define an enum to control scope types
enum ScopeType { LIST = "LIST", GENERIC = "GENERIC" }

// Define the types expected for each scope
type Generic<T> = T;
type List<T> = T & { limit: number; };

// Define interfaces with specific return shapes for each scope
interface GetApiPropsGeneric<T> {
  props: (storeState: string) => Generic<T>;
  api: (args: Generic<T>) => void;
  type: string;
  scope: ScopeType.GENERIC;
}

interface GetApiPropsList<T> {
  props: (storeState: string) => List<T>;
  api: (args: List<T>) => void;
  type: string;
  scope: ScopeType.LIST;
}

// Helper type to enforce strict property keys in props function
type EnforceExactKeys<T, U> = U & { [K in keyof U]: K extends keyof T ? U[K] : never };

// Main API function with type check for enforced keys
const apiProps = <T extends unknown>(a: GetApiPropsList<T> | GetApiPropsGeneric<T>) => {
  console.log("API call initiated");
}

// Valid usage with enforced property types
type NewT = { test: string };
apiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "1444", limit: 12 }),
  api: () => {},
  type: "example",
});

// Invalid usage, will produce a TypeScript error for invalid key
apiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "1444", limit: 12, abc: "error" }), // Extra key 'abc'
  api: () => {},
  type: "example",
});

// Helper type that checks the shape against an exact match
type StrictShape<Expected> = {
  [K in keyof Expected]: Expected[K];
};

// Define the function with strict key control using the helper
function validateApiProps<T>(
  a: T extends { scope: ScopeType.LIST } ? GetApiPropsList<T> : GetApiPropsGeneric<T>
): void {
  console.log("Validated API props");
}

// Enforcing strict shape
validateApiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "value", limit: 10 }),
  api: () => {},
  type: "correct",
});

// Invalid entry, causes error on extra property 'invalidProp'
validateApiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "value", limit: 10, invalidProp: "error" }),
  api: () => {},
  type: "incorrect",
});

import { validateApiProps } from './path_to_script';
describe('validateApiProps', () => {
  test('allows correct shape for LIST scope', () => {
    const validProps = {
      scope: ScopeType.LIST,
      props: (_) => ({ test: "value", limit: 10 }),
      api: () => {},
      type: "correct",
    };
    expect(() => validateApiProps(validProps)).not.toThrow();
  });

  test('throws error on invalid property', () => {
    const invalidProps = {
      scope: ScopeType.LIST,
      props: (_) => ({ test: "value", limit: 10, invalidProp: "error" }),
      api: () => {},
      type: "incorrect",
    };
    expect(() => validateApiProps(invalidProps)).toThrowError();
  });
});

„TypeScript“ strategijos, skirtos tikslių grąžinimo tipų įgyvendinimui

Dirbant su TypeScriptGrąžinimo tipų valdymas su griežtais apribojimais padeda užtikrinti nuspėjamas API struktūras, ypač sudėtingose ​​kodų bazėse. Vienas veiksmingų būdų užtikrinti, kad funkcija grąžintų tik leistinas ypatybes, yra tinkinti paslaugų tipai, kurie užtikrina tikslią atitiktį. Šis metodas ypač naudingas dirbant su REST API arba sudėtingas programas su įvairiomis atsako struktūromis, nes tai padeda išvengti netyčinių atsako objektų papildymų, galinčių sukelti klaidų. Kurdami bendruosius paslaugų tipus, „TypeScript“ kūrėjai gali patikrinti, ar kiekvienas API atsakymas atitinka numatytą struktūrą, todėl API iškvietimai ir atsako tvarkymas tampa tvirtesni.

Esant tokiems scenarijams kaip šis, conditional types tampa būtina, leidžianti patikrinti objektų formas ir užtikrinti, kad būtų papildomos savybės, pvz., nenumatytos abc raktas, neįsitraukite į atsakymus. „TypeScript“ siūlo galingus įrankius šiam tikslui, įskaitant mapped types ir conditional types kurie patvirtina savybių pavadinimus ir tipus pagal iš anksto nustatytą struktūrą. Naudodami susietus tipus, kūrėjai gali užtikrinti tikslius tipų atitikmenis, o sąlyginiai tipai gali modifikuoti grąžinimo struktūras pagal nurodytą įvesties tipą. Šių strategijų derinimas padeda užtikrinti, kad funkcijos veiktų nuosekliai įvairiose srityse ir API atsakymuose.

Be to, integruojant testavimo sistemas, pvz Jest leidžia kūrėjams patikrinti „TypeScript“ apribojimus atliekant vienetų testus, užtikrinant, kad kodas veiktų taip, kaip tikėtasi įvairiuose scenarijuose. Pavyzdžiui, jei atsiranda ypatybė, kuri nepriklauso numatytam tipui, Jest testai gali iš karto pabrėžti šią problemą, todėl kūrėjai gali pastebėti klaidas kūrimo ciklo pradžioje. Naudojant statinį tipo vykdymą ir dinaminį testavimą, komandos gali kurti saugias, patikimas programas, kurios gali atlikti griežtus tipo patikrinimus, teikti stabilesnius API atsakymus ir pagerinti priežiūrą. 🚀