TypeScript Præcise Typer: Strikt Objektformmatchning for Robust Kode

TypeScript, en supersæt af JavaScript, bringer statisk typning til den dynamiske verden af webudvikling. Mens TypeScript tilbyder betydelige fordele med hensyn til typesikkerhed og kodevedligeholdelse, kan dets strukturelle typesystem nogle gange føre til uventet adfærd. Det er her, konceptet med "præcise typer" kommer i spil. Selvom TypeScript ikke har en indbygget funktion, der eksplicit hedder "præcise typer", kan vi opnå lignende adfærd gennem en kombination af TypeScript-funktioner og -teknikker. Dette blogindlæg vil dykke ned i, hvordan man håndhæver strengere objektformmatchning i TypeScript for at forbedre kode-robusthed og forhindre almindelige fejl.

Forståelse af TypeScripts Strukturelle Typing

TypeScript anvender strukturel typing (også kendt som duck typing), hvilket betyder, at typekompatibilitet bestemmes af typernes medlemmer snarere end deres erklærede navne. Hvis et objekt har alle de egenskaber, der kræves af en type, betragtes det som kompatibelt med den type, uanset om det har yderligere egenskaber.

For eksempel:

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); // Dette virker fint, selvom myPoint har 'z'-egenskaben

I dette scenarie tillader TypeScript, at `myPoint` videregives til `printPoint`, fordi det indeholder de nødvendige `x` og `y` egenskaber, selvom det har en ekstra `z`-egenskab. Selvom denne fleksibilitet kan være praktisk, kan den også føre til subtile fejl, hvis du utilsigtet sender objekter med uventede egenskaber.

Problemet med Overskydende Egenskaber

Lempelsen af strukturel typing kan nogle gange maskere fejl. Overvej en funktion, der forventer et konfigurationsobjekt:

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 klager ikke her!

console.log(myConfig.typo); //udskriver true. Den ekstra egenskab eksisterer stille

I dette eksempel har `myConfig` en ekstra egenskab `typo`. TypeScript rejser ikke en fejl, fordi `myConfig` stadig opfylder `Config`-grænsefladen. Fejlen fanges dog aldrig, og applikationen opfører sig muligvis ikke som forventet, hvis fejlen var beregnet til at være `typoo`. Disse tilsyneladende ubetydelige problemer kan vokse til store hovedpiner ved fejlfinding af komplekse applikationer. En manglende eller forkert stavet egenskab kan være særligt vanskelig at opdage, når man beskæftiger sig med objekter indlejret i objekter.

Tilgange til at Gennemføre Præcise Typer i TypeScript

Selvom sande "præcise typer" ikke er direkte tilgængelige i TypeScript, er her flere teknikker til at opnå lignende resultater og håndhæve strengere objektformmatchning:

1. Brug af Type Assertioner med `Omit`

`Omit`-hjælpetypen giver dig mulighed for at oprette en ny type ved at udelukke visse egenskaber fra en eksisterende type. Kombineret med en type assertion kan dette hjælpe med at forhindre overskydende egenskaber.

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

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

// Opret en type, der kun inkluderer egenskaberne af Point
const exactPoint: Point = myPoint as Omit & Point;

// Fejl: Type '{ x: number; y: number; z: number; }' kan ikke tildeles typen 'Point'.
// Objektliteral kan kun angive kendte egenskaber, og 'z' findes ikke i typen 'Point'.

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


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

Denne tilgang udløser en fejl, hvis `myPoint` har egenskaber, der ikke er defineret i `Point`-grænsefladen.

Forklaring: `Omit` opretter en type, der udelader alle nøgler, der er til stede i `Point` fra typen af `myPoint`. `& Point` krydser derefter denne type med `Point`-typen, hvilket i det væsentlige kræver, at objektet overholder `Point`-typen. Ved at påstå objektet til denne kombinerede type kontrollerer kompilatoren for ekstra egenskaber og udløser en fejl, hvis der findes nogen. Dette tvinger os til at erklære den korrekte form, når vi oprindeligt definerer vores objekt.

2. Brug af en Funktion til at Oprette Objekter

Du kan oprette en fabriksfunktion, der kun accepterer de egenskaber, der er defineret i grænsefladen. Denne tilgang giver stærk typekontrol på tidspunktet for objektets oprettelse.

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

//Dette vil ikke kompilere:
//const myConfigError = createConfig({ apiUrl: "https://api.example.com", timeout: 5000, typo: true });
//Argument of type '{ apiUrl: string; timeout: number; typo: true; }' can not be assigned to parameter of type 'Config'.
// Object literal may only specify known properties, and 'typo' does not exist in type 'Config'.

Ved at returnere et objekt konstrueret med kun de egenskaber, der er defineret i `Config`-grænsefladen, sikrer du, at ingen ekstra egenskaber kan snige sig ind. Dette gør det sikrere at oprette konfigurationen.

3. Brug af Type Guards

Type guards er funktioner, der indsnævrer typen af en variabel inden for et specifikt omfang. Selvom de ikke direkte forhindrer overskydende egenskaber, kan de hjælpe dig med eksplicit at kontrollere dem og træffe passende foranstaltninger.

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 //check for number of keys. Note: brittle and depends on User's exact key count.
  );
}

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); //Will not hit here
} else {
  console.log("Invalid User");
}

I dette eksempel kontrollerer `isUser` type guard ikke kun for tilstedeværelsen af krævede egenskaber, men også for deres typer og det *præcise* antal egenskaber. Denne tilgang er mere eksplicit og giver dig mulighed for at håndtere ugyldige objekter på en elegant måde. Antallet af egenskaber check er dog skrøbelig. Når `User` får/mister egenskaber, skal kontrollen opdateres.

4. Udnyttelse af `Readonly` og `as const`

Mens `Readonly` forhindrer ændring af eksisterende egenskaber, og `as const` opretter en skrivebeskyttet tupel eller objekt, hvor alle egenskaber er dybt skrivebeskyttede og har bogstavelige typer, kan de bruges til at oprette en strengere definition og typekontrol, når de kombineres med andre metoder. Selvom ingen af dem forhindrer overskydende egenskaber alene.

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

//Opret Readonly-typen
type ReadonlyOptions = Readonly;

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

//options.width = 300; //error: Cannot assign to 'width' because it is a read-only property.

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

//config.timeout = 5000; //error: Cannot assign to 'timeout' because it is a read-only property.

//However, excess properties are still allowed:
const invalidOptions: ReadonlyOptions = { width: 100, height: 200, depth: 300 }; //no error. Still allows excess properties.


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

//This will now error:
//const invalidStrictOptions: StrictOptions = { width: 100, height: 200, depth: 300 };
//Type '{ width: number; height: number; depth: number; }' can not be assigned to type 'StrictOptions'.
//  Object literal may only specify known properties, and 'depth' does not exist in type 'StrictOptions'.

Dette forbedrer uforanderlighed, men forhindrer kun mutation, ikke eksistensen af ekstra egenskaber. Kombineret med `Omit` eller funktionsmetoden bliver den mere effektiv.

5. Brug af Biblioteker (f.eks. Zod, io-ts)

Biblioteker som Zod og io-ts tilbyder kraftfuld typevalidering og skemadefinitionsfunktioner på runtime. Disse biblioteker giver dig mulighed for at definere skemaer, der præcist beskriver den forventede form af dine data, inklusive at forhindre overskydende egenskaber. Selvom de tilføjer en runtime-afhængighed, tilbyder de en meget robust og fleksibel løsning.

Eksempel med 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); // This won't be reached
} catch (error) {
  console.error("Validation Error:", error.errors);
}

Zods `parse`-metode udløser en fejl, hvis inputtet ikke er i overensstemmelse med skemaet, hvilket effektivt forhindrer overskydende egenskaber. Dette giver runtime-validering og genererer også TypeScript-typer fra skemaet, hvilket sikrer konsistens mellem dine typdefinitioner og runtime-valideringslogik.

Bedste Praksis for at Gennemføre Præcise Typer

Her er nogle bedste praksis at overveje, når du håndhæver strengere objektformmatchning i TypeScript:

• Vælg den rigtige teknik: Den bedste tilgang afhænger af dine specifikke behov og projektkrav. For enkle tilfælde kan typepåstande med `Omit` eller fabriksfunktioner være tilstrækkelige. For mere komplekse scenarier, eller når runtime-validering er påkrævet, skal du overveje at bruge biblioteker som Zod eller io-ts.
• Vær konsekvent: Anvend din valgte tilgang konsekvent i hele din kodebase for at opretholde et ensartet niveau af typesikkerhed.
• Dokumentér dine typer: Dokumentér tydeligt dine grænseflader og typer for at kommunikere den forventede form af dine data til andre udviklere.
• Test din kode: Skriv enhedstest for at verificere, at dine typebegrænsninger fungerer som forventet, og at din kode håndterer ugyldige data på en elegant måde.
• Overvej afvejningerne: Håndhævelse af strengere objektformmatchning kan gøre din kode mere robust, men det kan også øge udviklingstiden. Afvej fordelene mod omkostningerne, og vælg den tilgang, der giver mest mening for dit projekt.
• Gradvis vedtagelse: Hvis du arbejder på en stor eksisterende kodebase, skal du overveje gradvist at vedtage disse teknikker, startende med de mest kritiske dele af din applikation.
• Foretræk grænseflader frem for typealiaser, når du definerer objektformer: Grænseflader foretrækkes generelt, fordi de understøtter deklarationssammenlægning, hvilket kan være nyttigt til at udvide typer på tværs af forskellige filer.

Eksempler fra Den Virkelige Verden

Lad os se på nogle scenarier fra den virkelige verden, hvor præcise typer kan være fordelagtige:

• API-anmodnings nyttelast: Når du sender data til en API, er det afgørende at sikre, at nyttelasten er i overensstemmelse med det forventede skema. Gennemførelse af præcise typer kan forhindre fejl forårsaget af afsendelse af uventede egenskaber. For eksempel er mange API'er til betalingsbehandling ekstremt følsomme over for uventede data.
• Konfigurationsfiler: Konfigurationsfiler indeholder ofte et stort antal egenskaber, og tastefejl kan være almindelige. Brug af præcise typer kan hjælpe med at fange disse tastefejl tidligt. Hvis du opsætter serverplaceringer i en cloud-implementering, vil en tastefejl i en placeringsindstilling (f.eks. eu-west-1 vs. eu-wet-1) blive ekstremt vanskelig at debugge, hvis den ikke fanges på forhånd.
• Datatransformationspipelines: Når du transformerer data fra ét format til et andet, er det vigtigt at sikre, at outputdataene er i overensstemmelse med det forventede skema.
• Beskedkøer: Når du sender beskeder gennem en beskedkø, er det vigtigt at sikre, at meddelelsens nyttelast er gyldig og indeholder de korrekte egenskaber.

Eksempel: Internationaliseringskonfiguration (i18n)

Forestil dig at administrere oversættelser for en flersproget applikation. Du har muligvis et konfigurationsobjekt som dette:

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

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

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


//Dette vil være et problem, da der findes en overskydende egenskab, der stille introducerer en fejl.
const spanishConfig: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós",
    typo: "unintentional translation"
  }
};

//Løsning: Brug af Omit
const spanishConfigCorrect: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós"
  } as Omit & Translation
};

Uden præcise typer kan en tastefejl i en oversættelsesnøgle (som at tilføje et `typo`-felt) gå ubemærket hen, hvilket fører til manglende oversættelser i brugergrænsefladen. Ved at håndhæve strengere objektformmatchning kan du fange disse fejl under udvikling og forhindre dem i at nå produktionen.

Konklusion

Selvom TypeScript ikke har indbyggede "præcise typer", kan du opnå lignende resultater ved hjælp af en kombination af TypeScript-funktioner og teknikker som typepåstande med `Omit`, fabriksfunktioner, type guards, `Readonly`, `as const` og eksterne biblioteker som Zod og io-ts. Ved at håndhæve strengere objektformmatchning kan du forbedre robustheden af din kode, forhindre almindelige fejl og gøre dine applikationer mere pålidelige. Husk at vælge den tilgang, der passer bedst til dine behov, og være konsekvent med at anvende den i hele din kodebase. Ved omhyggeligt at overveje disse tilgange kan du få større kontrol over din applikations typer og øge den lange sigt vedligeholdelse.