Hvordan lage og bruke TypeScript-verktøytyper

TypeScript gir et sett med verktøytyper som gjør det enklere å transformere og administrere eksisterende typer. Disse innebygde verktøytypene lar utviklere manipulere typer på forskjellige måter, og hjelper til med å forenkle koden og unngå repetisjon. Denne veiledningen utforsker noen av de vanligste verktøytypene og hvordan de kan opprettes og brukes i et TypeScript-prosjekt.

Hva er TypeScript-verktøytyper?

Verktøytyper i TypeScript er forhåndsdefinerte typer som hjelper til med å transformere andre typer. De kan brukes til å lage nye typer basert på eksisterende ved enten å velge, utelate eller endre egenskaper. De spiller en viktig rolle i å opprettholde ren, gjenbrukbar kode.

Vanlig brukte TypeScript-verktøytyper

Her er noen av de mest brukte TypeScript-verktøytypene:

• Delvis<T> – Gjør alle egenskaper av typen T valgfrie.
• Påkrevd<T> – Gjør alle egenskaper av typen T nødvendige.
• Skrivebeskyttet<T> – Gjør alle egenskaper av typen T skrivebeskyttet.
• Plukk<T, K> – Velger et sett med egenskaper K fra typen T.
• Utelat<T, K> – Fjerner et sett med egenskaper K fra typen T.
• Record<K, T> – Konstruerer en objekttype med nøkler av typen K og verdier av typen T.

Eksempel: Bruk av delvis<T>

Partial-verktøytypen gjør alle egenskapene til et grensesnitt valgfrie. Slik kan det brukes:

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

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

updateUser({ name: "John" });

I dette eksemplet godtar updateUser et argument av typen Partial<User>, noe som betyr at bare noen av egenskapene til User-grensesnittet kreves.

Eksempel: Bruk av Pick<T, K>

Pick-verktøytypen lar deg velge et undersett av egenskaper fra en type:

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

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

const contactInfo: UserContactInfo = {
  name: "John",
  email: "[email protected]"
};

Her oppretter Pick<User, “name” | “email”> en ny type UserContactInfo med bare egenskapene name og email fra den opprinnelige User grensesnitt.

Eksempel: Bruk av Utelat<T, K>

Omit-verktøytypen fjerner spesifiserte egenskaper fra en type:

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

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

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

I dette eksemplet opprettes UserWithoutEmail-typen ved å utelate egenskapen email fra User-grensesnittet.

Opprette egendefinerte verktøytyper

Egendefinerte verktøytyper kan også opprettes ved å bruke TypeScripts avanserte typefunksjoner som betingede typer, kartlagte typer og mer. Her er et enkelt eksempel på en egendefinert verktøytype som gjør alle egenskaper valgfrie:

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

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

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

Denne tilpassede MyPartial-typen fungerer på samme måte som TypeScripts innebygde Partial-verktøytype.

Konklusjon

TypeScript-verktøytyper er en viktig funksjon for å arbeide med typer på en fleksibel og gjenbrukbar måte. Ved å utnytte disse verktøytypene kan koden gjøres mer kortfattet og vedlikeholdbar. Enten du bruker innebygde verktøytyper som Partial, Pick og Omit eller oppretter egendefinerte, forbedrer de TypeScripts typesystem betydelig.