TypeScript Exakta Typer: Strikt Objektformsmatchning för Robust Kod

TypeScript, en superset av JavaScript, ger statisk typning till den dynamiska världen av webbutveckling. Medan TypeScript erbjuder betydande fördelar när det gäller typsäkerhet och kodunderhållbarhet, kan dess strukturella typsystem ibland leda till oväntat beteende. Det är här konceptet "exakta typer" kommer in i bilden. Även om TypeScript inte har en inbyggd funktion som uttryckligen heter "exakta typer", kan vi uppnå liknande beteende genom en kombination av TypeScript-funktioner och tekniker. Detta blogginlägg kommer att fördjupa sig i hur man framtvingar striktare objektformsmatchning i TypeScript för att förbättra kodens robusthet och förhindra vanliga fel.

Förstå TypeScripts Strukturella Typning

TypeScript använder strukturell typning (även känd som anktypning), vilket innebär att typkompatibilitet bestäms av typernas medlemmar, snarare än deras deklarerade namn. Om ett objekt har alla egenskaper som krävs av en typ, anses det vara kompatibelt med den typen, oavsett om den har ytterligare egenskaper.

Till exempel:

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); // Detta fungerar bra, även om myPoint har egenskapen 'z'

I det här scenariot tillåter TypeScript att `myPoint` skickas till `printPoint` eftersom den innehåller de obligatoriska egenskaperna `x` och `y`, även om den har en extra egenskap `z`. Även om denna flexibilitet kan vara praktisk, kan den också leda till subtila buggar om du oavsiktligt skickar objekt med oväntade egenskaper.

Problemet med Överskottsegenskaper

Den mildhet som den strukturella typningen har kan ibland maskera fel. Tänk på en funktion som förväntar sig ett 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 klagar inte här!

console.log(myConfig.typo); //skriver ut true. Den extra egenskapen finns tyst

I det här exemplet har `myConfig` en extra egenskap `typo`. TypeScript genererar inget fel eftersom `myConfig` fortfarande uppfyller `Config`-gränssnittet. Men stavfelet fångas aldrig, och applikationen kanske inte beter sig som förväntat om stavfelet var avsett att vara `typoo`. Dessa till synes obetydliga problem kan växa till stora huvudvärk när man felsöker komplexa applikationer. En saknad eller felstavad egenskap kan vara särskilt svår att upptäcka när man hanterar objekt som är kapslade i objekt.

Metoder för att Framtvinga Exakta Typer i TypeScript

Även om sanna "exakta typer" inte är direkt tillgängliga i TypeScript, är här flera tekniker för att uppnå liknande resultat och framtvinga striktare objektformsmatchning:

1. Använda Typsäkerhetskontroller med `Omit`

`Omit`-verktygstypen låter dig skapa en ny typ genom att exkludera vissa egenskaper från en befintlig typ. Kombinerat med en typsäkerhetskontroll kan detta hjälpa till att förhindra överskottsegenskaper.

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

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

// Skapa en typ som bara inkluderar egenskaperna för Point
const exactPoint: Point = myPoint as Omit & Point;

// Fel: Typ '{ x: number; y: number; z: number; }' kan inte tilldelas typen 'Point'.
// Objektliteralen får bara specificera kända egenskaper, och 'z' finns inte 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);

Denna metod genererar ett fel om `myPoint` har egenskaper som inte är definierade i `Point`-gränssnittet.

Förklaring: `Omit` skapar en typ som utelämnar alla nycklar som finns i `Point` från typen `myPoint`. `& Point` korsar sedan denna typ med `Point`-typen, vilket i huvudsak kräver att objektet överensstämmer med `Point`-typen. Genom att påstå objektet till denna kombinerade typ, kontrollerar kompilatorn efter extra egenskaper och genererar ett fel om några hittas. Detta tvingar oss att deklarera rätt form när vi initialt definierar vårt objekt.

2. Använda en Funktion för att Skapa Objekt

Du kan skapa en fabrikfunktion som bara accepterar de egenskaper som definieras i gränssnittet. Denna metod ger stark typkontroll vid tidpunkten för objektskapandet.

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

//Detta kommer inte att kompileras:
//const myConfigError = createConfig({ apiUrl: "https://api.example.com", timeout: 5000, typo: true });
//Argument av typen '{ apiUrl: string; timeout: number; typo: true; }' kan inte tilldelas parametern av typen 'Config'.
// Objektliteralen får bara specificera kända egenskaper, och 'typo' finns inte i typen 'Config'.

Genom att returnera ett objekt som konstrueras med endast de egenskaper som definieras i `Config`-gränssnittet, säkerställer du att inga extra egenskaper kan smyga sig in. Detta gör det säkrare att skapa konfigurationen.

3. Använda Typskydd

Typskydd är funktioner som begränsar typen av en variabel inom ett specifikt omfång. Även om de inte direkt förhindrar överskottsegenskaper, kan de hjälpa dig att uttryckligen kontrollera dem och vidta lämpliga åtgärder.

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 //kontrollera antalet nycklar. Obs: skör och beror på Users exakta antal nycklar.
  );
}

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

if (isUser(potentialUser1)) {
  console.log("Giltig användare:", potentialUser1.name);
} else {
  console.log("Ogiltig användare");
}

if (isUser(potentialUser2)) {
  console.log("Giltig användare:", potentialUser2.name); //Kommer inte att träffas här
} else {
  console.log("Ogiltig användare");
}

I det här exemplet kontrollerar `isUser`-typskyddet inte bara förekomsten av obligatoriska egenskaper utan också deras typer och det *exakta* antalet egenskaper. Denna metod är mer explicit och låter dig hantera ogiltiga objekt på ett elegant sätt. Kontrollen av antalet egenskaper är dock bräcklig. Närhelst `User` får/tappar egenskaper måste kontrollen uppdateras.

4. Utnyttja `Readonly` och `as const`

Medan `Readonly` förhindrar ändring av befintliga egenskaper, och `as const` skapar en skrivskyddad tupel eller ett objekt där alla egenskaper är djupt skrivskyddade och har litterära typer, kan de användas för att skapa en striktare definition och typkontroll när de kombineras med andra metoder. Även om ingen av dem förhindrar överskottsegenskaper på egen hand.

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

//Skapa Readonly-typen
type ReadonlyOptions = Readonly;

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

//options.width = 300; //fel: Kan inte tilldela 'width' eftersom det är en skrivskyddad egenskap.

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

//config.timeout = 5000; //fel: Kan inte tilldela 'timeout' eftersom det är en skrivskyddad egenskap.

//Överskottsegenskaper är dock fortfarande tillåtna:
const invalidOptions: ReadonlyOptions = { width: 100, height: 200, depth: 300 }; //inget fel. Tillåter fortfarande överskottsegenskaper.


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

//Detta kommer nu att ge fel:
//const invalidStrictOptions: StrictOptions = { width: 100, height: 200, depth: 300 };
//Typ '{ width: number; height: number; depth: number; }' kan inte tilldelas typen 'StrictOptions'.
//  Objektliteralen får bara specificera kända egenskaper, och 'depth' finns inte i typen 'StrictOptions'.

Detta förbättrar oföränderligheten, men förhindrar bara mutation, inte förekomsten av extra egenskaper. Kombinerat med `Omit`, eller funktionen, blir det effektivare.

5. Använda Bibliotek (t.ex. Zod, io-ts)

Bibliotek som Zod och io-ts erbjuder kraftfulla validerings- och schemadefinitionsmöjligheter vid körning. Dessa bibliotek låter dig definiera scheman som exakt beskriver den förväntade formen på din data, inklusive att förhindra överskottsegenskaper. Även om de lägger till ett körningsberoende, erbjuder de en mycket robust och flexibel lösning.

Exempel 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("Parsad Giltig Användare:", parsedValidUser);

try {
  const parsedInvalidUser = UserSchema.parse(invalidUser);
  console.log("Parsad Ogiltig Användare:", parsedInvalidUser); // Detta kommer inte att nås
} catch (error) {
  console.error("Valideringsfel:", error.errors);
}

Zods `parse`-metod kommer att generera ett fel om ingången inte överensstämmer med schemat, vilket effektivt förhindrar överskottsegenskaper. Detta ger körningstidsvalidering och genererar också TypeScript-typer från schemat, vilket säkerställer överensstämmelse mellan dina typdefinitioner och valideringslogik vid körning.

Bästa Metoder för att Framtvinga Exakta Typer

Här är några bästa metoder att tänka på när du framtvingar striktare objektformsmatchning i TypeScript:

• Välj rätt teknik: Den bästa metoden beror på dina specifika behov och projektkrav. För enkla fall kan typsäkerhetskontroller med `Omit` eller fabrikfunktioner räcka. För mer komplexa scenarier eller när validering vid körning krävs, överväg att använda bibliotek som Zod eller io-ts.
• Var konsekvent: Använd din valda metod konsekvent i hela din kodbas för att upprätthålla en enhetlig nivå av typsäkerhet.
• Dokumentera dina typer: Dokumentera tydligt dina gränssnitt och typer för att kommunicera den förväntade formen på din data till andra utvecklare.
• Testa din kod: Skriv enhetstester för att verifiera att dina typbegränsningar fungerar som förväntat och att din kod hanterar ogiltig data på ett elegant sätt.
• Överväg kompromisserna: Att framtvinga striktare objektformsmatchning kan göra din kod mer robust, men det kan också öka utvecklingstiden. Väg fördelarna mot kostnaderna och välj den metod som är mest meningsfull för ditt projekt.
• Gradvis införande: Om du arbetar med en stor befintlig kodbas, överväg att införa dessa tekniker gradvis, med början i de mest kritiska delarna av din applikation.
• Föredra gränssnitt framför typalias när du definierar objektformer: Gränssnitt är generellt sett att föredra eftersom de stöder deklarationssammanslagning, vilket kan vara användbart för att utöka typer över olika filer.

Exempel från Verkliga Världen

Låt oss titta på några scenarier i verkliga världen där exakta typer kan vara fördelaktiga:

• API-förfrågningsnyttolaster: När du skickar data till ett API är det avgörande att se till att nyttolasten överensstämmer med det förväntade schemat. Att framtvinga exakta typer kan förhindra fel orsakade av att skicka oväntade egenskaper. Till exempel är många betalningsbearbetnings-API:er extremt känsliga för oväntad data.
• Konfigurationsfiler: Konfigurationsfiler innehåller ofta ett stort antal egenskaper, och stavfel kan vara vanliga. Att använda exakta typer kan hjälpa till att fånga dessa stavfel tidigt. Om du konfigurerar serverplatser i en molnimplementering kommer ett stavfel i en platsinställning (t.ex. eu-west-1 vs. eu-wet-1) att bli extremt svårt att felsöka om det inte fångas upp i förväg.
• Datatransformationspipelines: När du transformerar data från ett format till ett annat är det viktigt att se till att utdatadata överensstämmer med det förväntade schemat.
• Meddelandeköer: När du skickar meddelanden via en meddelandekö är det viktigt att se till att meddelandenyttolasten är giltig och innehåller rätt egenskaper.

Exempel: Internationaliseringskonfiguration (i18n)

Föreställ dig att hantera översättningar för en flerspråkig applikation. Du kanske har ett konfigurationsobjekt som detta:

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

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

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


//Detta kommer att vara ett problem, eftersom en överskottsegenskap finns, och tyst introducerar en bugg.
const spanishConfig: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós",
    typo: "unintentional translation"
  }
};

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

Utan exakta typer kan ett stavfel i en översättningsnyckel (som att lägga till ett `typo`-fält) gå obemärkt förbi, vilket leder till saknade översättningar i användargränssnittet. Genom att framtvinga striktare objektformsmatchning kan du fånga dessa fel under utvecklingen och förhindra att de når produktion.

Slutsats

Även om TypeScript inte har inbyggda "exakta typer", kan du uppnå liknande resultat med en kombination av TypeScript-funktioner och tekniker som typsäkerhetskontroller med `Omit`, fabrikfunktioner, typskydd, `Readonly`, `as const` och externa bibliotek som Zod och io-ts. Genom att framtvinga striktare objektformsmatchning kan du förbättra robustheten i din kod, förhindra vanliga fel och göra dina applikationer mer pålitliga. Kom ihåg att välja den metod som passar dina behov bäst och vara konsekvent med att tillämpa den i hela din kodbas. Genom att noggrant överväga dessa metoder kan du ta större kontroll över din applikations typer och öka långsiktig underhållbarhet.