Hur man skapar och använder TypeScript-verktygstyper

TypeScript tillhandahåller en uppsättning verktygstyper som gör det lättare att transformera och hantera befintliga typer. Dessa inbyggda verktygstyper tillåter utvecklare att manipulera typer på olika sätt, vilket hjälper till att förenkla koden och undvika upprepning. Den här guiden utforskar några av de vanligaste verktygstyperna och hur de kan skapas och användas i ett TypeScript-projekt.

Vad är TypeScript-verktygstyper?

Verktygstyper i TypeScript är fördefinierade typer som hjälper till att transformera andra typer. De kan användas för att skapa nya typer baserat på befintliga genom att antingen välja, utelämna eller ändra egenskaper. De spelar en viktig roll för att upprätthålla ren, återanvändbar kod.

Vanligt använda TypeScript-verktygstyper

Här är några av de vanligaste TypeScript-verktygstyperna:

• Partiell<T> – Gör alla egenskaper av typen T valfria.
• Obligatorisk<T> – Kräver alla egenskaper av typen T.
• Readonly<T> – Gör alla egenskaper av typen T skrivskyddade.
• Välj<T, K> – Väljer en uppsättning egenskaper K från typen T.
• Utelämna<T, K> – Tar bort en uppsättning egenskaper K från typen T.
• Record<K, T> – Konstruerar en objekttyp med nycklar av typen K och värden av typen T.

Exempel: Använda partiell<T>

Verktygstypen Partial gör alla egenskaper för ett gränssnitt valfria. Så här kan den användas:

interface User {
  name: string;
  age: number;
  email: string;
}

const updateUser = (user: Partial<User>) => {
  // Update logic
};

updateUser({ name: "John" });

I det här exemplet accepterar updateUser ett argument av typen Partial<User>, vilket betyder att endast några av egenskaperna för User-gränssnittet krävs.

Exempel: Använda Pick<T, K>

Verktygstypen Pick gör det möjligt att välja en undergrupp av egenskaper från en typ:

interface User {
  name: string;
  age: number;
  email: string;
}

type UserContactInfo = Pick<User, "name" | "email">;

const contactInfo: UserContactInfo = {
  name: "John",
  email: "john@example.com"
};

Här skapar Pick<User, “name” | “email”> en ny typ UserContactInfo med endast egenskaperna name och email från den ursprungliga User gränssnitt.

Exempel: Använda Omit<T, K>

Verktygstypen Omit tar bort specificerade egenskaper från en typ:

interface User {
  name: string;
  age: number;
  email: string;
}

type UserWithoutEmail = Omit<User, "email">;

const user: UserWithoutEmail = {
  name: "John",
  age: 30
};

I det här exemplet skapas UserWithoutEmail-typen genom att utelämna egenskapen email från User-gränssnittet.

Skapa anpassade verktygstyper

Anpassade verktygstyper kan också skapas med TypeScripts avancerade typfunktioner som villkorliga typer, mappade typer och mer. Här är ett enkelt exempel på en anpassad verktygstyp som gör alla egenskaper valfria:

type MyPartial<T> = {
  [P in keyof T]?: T[P];
};

interface User {
  name: string;
  age: number;
  email: string;
}

const user: MyPartial<User> = {
  name: "Alice"
};

Denna anpassade MyPartial-typ fungerar på samma sätt som TypeScripts inbyggda Partial-verktygstyp.

Slutsats

TypeScript-verktygstyper är en viktig funktion för att arbeta med typer på ett flexibelt och återanvändbart sätt. Genom att utnyttja dessa verktygstyper kan koden göras mer kortfattad och underhållbar. Oavsett om du använder inbyggda verktygstyper som Partial, Pick och Omit eller skapar anpassade, förbättrar de TypeScripts typsystem avsevärt.