TypeScript Tikslūs Tipai: Griežtas Objektų Formos Atitikimas Patikimam Kodui

TypeScript, JavaScript viršrinkinys, įneša statinį tipizavimą į dinamišką interneto kūrimo pasaulį. Nors TypeScript siūlo didelių pranašumų tipų saugumo ir kodo palaikymo srityse, jo struktūrinio tipizavimo sistema kartais gali lemti netikėtą elgseną. Būtent čia atsiranda „tiksliųjų tipų“ koncepcija. Nors TypeScript neturi integruotos funkcijos, aiškiai pavadintos „tiksliaisiais tipais“, panašų elgesį galime pasiekti derindami TypeScript funkcijas ir technikas. Šiame tinklaraščio įraše gilinsimės į tai, kaip TypeScript'e įgyvendinti griežtesnį objektų formos atitikimą, siekiant pagerinti kodo patikimumą ir išvengti dažnų klaidų.

TypeScript Struktūrinio Tipizavimo Supratimas

TypeScript naudoja struktūrinį tipizavimą (dar žinomą kaip „duck typing“), o tai reiškia, kad tipų suderinamumą lemia tipų nariai, o ne jų deklaruoti pavadinimai. Jei objektas turi visas savybes, kurių reikalauja tipas, jis laikomas suderinamu su tuo tipu, nepaisant to, ar jis turi papildomų savybių.

Pavyzdžiui:

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); // Tai veikia puikiai, nors myPoint turi 'z' savybę

Šiame scenarijuje TypeScript leidžia perduoti `myPoint` į `printPoint` funkciją, nes jame yra reikalaujamos `x` ir `y` savybės, nors jis turi ir papildomą `z` savybę. Nors šis lankstumas gali būti patogus, jis taip pat gali sukelti subtilių klaidų, jei netyčia perduodate objektus su netikėtomis savybėmis.

Perteklinių Savybių Problema

Struktūrinio tipizavimo atlaidumas kartais gali užmaskuoti klaidas. Apsvarstykite funkciją, kuri tikisi konfigūracijos objekto:

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 čia nesiskundžia!

console.log(myConfig.typo); // išspausdina true. Papildoma savybė tyliai egzistuoja

Šiame pavyzdyje `myConfig` turi papildomą savybę `typo`. TypeScript nerodo klaidos, nes `myConfig` vis dar atitinka `Config` sąsają. Tačiau spausdinimo klaida niekada neaptinkama, ir programa gali neveikti taip, kaip tikėtasi, jei `typo` turėjo būti `typoo`. Šios, atrodytų, nereikšmingos problemos gali virsti dideliais galvos skausmais derinant sudėtingas programas. Trūkstama ar neteisingai parašyta savybė gali būti ypač sunkiai aptinkama dirbant su objektais, esančiais kituose objektuose.

Būdai, Kaip Įgyvendinti Tikslius Tipus TypeScript'e

Nors tikrieji „tikslūs tipai“ nėra tiesiogiai prieinami TypeScript'e, štai keletas technikų, kaip pasiekti panašių rezultatų ir įgyvendinti griežtesnį objektų formos atitikimą:

1. Tipų Tvirtinimų Naudojimas su `Omit`

`Omit` pagalbinis tipas leidžia sukurti naują tipą, pašalinant tam tikras savybes iš esamo tipo. Kartu su tipo tvirtinimu tai gali padėti išvengti perteklinių savybių.

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

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

// Sukurkite tipą, kuris apima tik Point savybes
const exactPoint: Point = myPoint as Omit & Point;

// Klaida: Tipas '{ x: number; y: number; z: number; }' nėra priskiriamas tipui 'Point'.
// Objekto literalas gali nurodyti tik žinomas savybes, o 'z' neegzistuoja 'Point' tipe.

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


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

Šis metodas išmeta klaidą, jei `myPoint` turi savybių, kurios nėra apibrėžtos `Point` sąsajoje.

Paaiškinimas: `Omit` sukuria tipą, kuris iš `myPoint` tipo pašalina visus raktus, esančius `Point`. Tuomet `& Point` sujungia šį tipą su `Point` tipu, iš esmės reikalaudamas, kad objektas atitiktų `Point` tipą. Patvirtinant objektą šiam kombinuotam tipui, kompiliatorius patikrina papildomas savybes ir, jei tokių randa, išmeta klaidą. Tai verčia mus deklaruoti teisingą formą pradinio objekto apibrėžimo metu.

2. Funkcijos Naudojimas Objektams Kurti

Galite sukurti gamyklinę funkciją (factory function), kuri priima tik sąsajoje apibrėžtas savybes. Šis metodas užtikrina stiprų tipų tikrinimą objekto kūrimo metu.

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 });

//Tai nesikompiliuos:
//const myConfigError = createConfig({ apiUrl: "https://api.example.com", timeout: 5000, typo: true });
//Argumento tipas '{ apiUrl: string; timeout: number; typo: true; }' nėra priskiriamas parametro tipui 'Config'.
// Objekto literalas gali nurodyti tik žinomas savybes, o 'typo' neegzistuoja 'Config' tipe.

Grąžindami objektą, sukonstruotą tik su `Config` sąsajoje apibrėžtomis savybėmis, užtikrinate, kad jokios papildomos savybės nepraslys. Tai daro konfigūracijos kūrimą saugesniu.

3. Tipų Apsaugų (Type Guards) Naudojimas

Tipų apsaugos yra funkcijos, kurios susiaurina kintamojo tipą tam tikroje srityje. Nors jos tiesiogiai neužkerta kelio perteklinėms savybėms, jos gali padėti jums aiškiai jas patikrinti ir imtis atitinkamų veiksmų.

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 //patikrinkite raktų skaičių. Pastaba: trapu ir priklauso nuo tikslaus User raktų skaičiaus.
  );
}

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); //Čia nepateks
} else {
  console.log("Invalid User");
}

Šiame pavyzdyje `isUser` tipo apsauga tikrina ne tik būtinų savybių buvimą, bet ir jų tipus bei *tikslų* savybių skaičių. Šis metodas yra aiškesnis ir leidžia jums grakščiai tvarkyti netinkamus objektus. Tačiau savybių skaičiaus tikrinimas yra trapus. Kai `User` gauna/praranda savybių, patikrinimas turi būti atnaujintas.

4. `Readonly` ir `as const` Panaudojimas

Nors `Readonly` neleidžia modifikuoti esamų savybių, o `as const` sukuria tik skaitomą kortezą (tuple) ar objektą, kur visos savybės yra giliai tik skaitomos ir turi literalinius tipus, jie gali būti naudojami griežtesniam apibrėžimui ir tipų tikrinimui, derinant su kitais metodais. Tačiau nei vienas iš jų pats savaime neužkerta kelio perteklinėms savybėms.

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

//Sukurkite Readonly tipą
type ReadonlyOptions = Readonly;

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

//options.width = 300; //klaida: Negalima priskirti 'width', nes tai tik skaitoma savybė.

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

//config.timeout = 5000; //klaida: Negalima priskirti 'timeout', nes tai tik skaitoma savybė.

//Tačiau perteklinės savybės vis dar leidžiamos:
const invalidOptions: ReadonlyOptions = { width: 100, height: 200, depth: 300 }; //nėra klaidos. Vis dar leidžia perteklinės savybes.


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

//Dabar tai sukels klaidą:
//const invalidStrictOptions: StrictOptions = { width: 100, height: 200, depth: 300 };
//Tipas '{ width: number; height: number; depth: number; }' nėra priskiriamas tipui 'StrictOptions'.
//  Objekto literalas gali nurodyti tik žinomas savybes, o 'depth' neegzistuoja 'StrictOptions' tipe.

Tai pagerina nekintamumą (immutability), bet apsaugo tik nuo mutacijos, o ne nuo papildomų savybių egzistavimo. Derinant su `Omit` ar funkcijos metodu, jis tampa efektyvesnis.

5. Bibliotekų Naudojimas (pvz., Zod, io-ts)

Bibliotekos, tokios kaip Zod ir io-ts, siūlo galingas vykdymo metu (runtime) atliekamo tipo patvirtinimo ir schemų apibrėžimo galimybes. Šios bibliotekos leidžia apibrėžti schemas, kurios tiksliai aprašo jūsų duomenų laukiamą formą, įskaitant perteklinių savybių prevenciją. Nors jos prideda vykdymo laiko priklausomybę, jos siūlo labai patikimą ir lankstų sprendimą.

Pavyzdys su 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); // Tai nebus pasiekta
} catch (error) {
  console.error("Validation Error:", error.errors);
}

Zod `parse` metodas išmes klaidą, jei įvestis neatitinka schemos, efektyviai užkertant kelią perteklinėms savybėms. Tai suteikia vykdymo laiko patvirtinimą ir taip pat generuoja TypeScript tipus iš schemos, užtikrinant nuoseklumą tarp jūsų tipų apibrėžimų ir vykdymo laiko patvirtinimo logikos.

Geriausios Praktikos Tiksliems Tipams Įgyvendinti

Štai keletas geriausių praktikų, į kurias reikėtų atsižvelgti įgyvendinant griežtesnį objektų formos atitikimą TypeScript'e:

• Pasirinkite tinkamą techniką: Geriausias metodas priklauso nuo jūsų konkrečių poreikių ir projekto reikalavimų. Paprastesniais atvejais gali pakakti tipų tvirtinimų su `Omit` arba gamyklinių funkcijų. Sudėtingesniems scenarijams arba kai reikalingas vykdymo laiko patvirtinimas, apsvarstykite galimybę naudoti bibliotekas, tokias kaip Zod ar io-ts.
• Būkite nuoseklūs: Taikykite pasirinktą metodą nuosekliai visame savo kode, kad išlaikytumėte vienodą tipų saugumo lygį.
• Dokumentuokite savo tipus: Aiškiai dokumentuokite savo sąsajas ir tipus, kad perduotumėte laukiamą duomenų formą kitiems programuotojams.
• Testuokite savo kodą: Rašykite vienetinius testus (unit tests), kad patikrintumėte, ar jūsų tipų apribojimai veikia kaip tikėtasi ir ar jūsų kodas tinkamai tvarko netinkamus duomenis.
• Apsvarstykite kompromisus: Griežtesnio objektų formos atitikimo įgyvendinimas gali padaryti jūsų kodą patikimesnį, bet taip pat gali pailginti kūrimo laiką. Pasverkite naudą ir kaštus ir pasirinkite metodą, kuris labiausiai tinka jūsų projektui.
• Palaipsninis diegimas: Jei dirbate su didele esama kodo baze, apsvarstykite galimybę šias technikas diegti palaipsniui, pradedant nuo svarbiausių jūsų programos dalių.
• Apibrėžiant objektų formas, teikite pirmenybę sąsajoms (interfaces), o ne tipų sinonimams (type aliases): Sąsajos paprastai yra pageidautinesnės, nes jos palaiko deklaracijų sujungimą (declaration merging), kas gali būti naudinga plečiant tipus skirtinguose failuose.

Pavyzdžiai iš Realaus Pasaulio

Pažvelkime į keletą realaus pasaulio scenarijų, kur tikslūs tipai gali būti naudingi:

• API užklausų turiniai (payloads): Siunčiant duomenis į API, labai svarbu užtikrinti, kad turinys atitiktų laukiamą schemą. Griežtų tipų taikymas gali padėti išvengti klaidų, kurias sukelia netikėtų savybių siuntimas. Pavyzdžiui, daugelis mokėjimų apdorojimo API yra ypač jautrios netikėtiems duomenims.
• Konfigūracijos failai: Konfigūracijos failuose dažnai būna daug savybių, ir spausdinimo klaidos yra dažnos. Naudojant tikslius tipus, galima anksti pagauti šias klaidas. Jei konfigūruojate serverių vietas debesų kompiuterijos diegime, spausdinimo klaida vietos nustatyme (pvz. eu-west-1 vs. eu-wet-1) taps ypač sunkiai derinamu, jei nebus aptikta iš anksto.
• Duomenų transformavimo grandinės: Transformuojant duomenis iš vieno formato į kitą, svarbu užtikrinti, kad išvesties duomenys atitiktų laukiamą schemą.
• Pranešimų eilės: Siunčiant pranešimus per pranešimų eilę, svarbu užtikrinti, kad pranešimo turinys būtų tinkamas ir turėtų teisingas savybes.

Pavyzdys: Tarptautinimo (i18n) Konfigūracija

Įsivaizduokite, kad tvarkote vertimus daugiakalbei programai. Jūs galite turėti tokį konfigūracijos objektą:

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

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

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


//Tai bus problema, nes egzistuoja perteklinė savybė, tyliai įvedanti klaidą.
const spanishConfig: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós",
    typo: "unintentional translation"
  }
};

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

Be tiksliųjų tipų, spausdinimo klaida vertimo rakte (pvz., pridedant `typo` lauką) gali likti nepastebėta, o tai lemtų trūkstamus vertimus vartotojo sąsajoje. Įgyvendindami griežtesnį objektų formos atitikimą, galite pagauti šias klaidas kūrimo metu ir užkirsti kelią joms patekti į gamybinę aplinką.

Išvada

Nors TypeScript neturi integruotų „tiksliųjų tipų“, panašių rezultatų galite pasiekti naudodami TypeScript funkcijų ir technikų derinį, pvz., tipų tvirtinimus su `Omit`, gamyklines funkcijas, tipų apsaugas, `Readonly`, `as const` ir išorines bibliotekas, tokias kaip Zod ir io-ts. Įgyvendindami griežtesnį objektų formos atitikimą, galite pagerinti savo kodo patikimumą, išvengti dažnų klaidų ir padaryti savo programas patikimesnes. Nepamirškite pasirinkti metodo, kuris geriausiai atitinka jūsų poreikius, ir nuosekliai jį taikyti visame savo kode. Atidžiai apsvarstę šiuos metodus, galite geriau kontroliuoti savo programos tipus ir padidinti ilgalaikį palaikomumą.