Hoe u TypeScript-hulpprogrammatypen kunt maken en gebruiken

TypeScript biedt een set utility types ​​die het makkelijker maken om bestaande types te transformeren en beheren. Deze ingebouwde utility types stellen ontwikkelaars in staat om types op verschillende manieren te manipuleren, wat helpt om code te vereenvoudigen en herhaling te voorkomen. Deze gids onderzoekt enkele van de meest voorkomende utility types en hoe ze kunnen worden gemaakt en gebruikt in een TypeScript-project.

Wat zijn TypeScript-hulpprogrammatypen?

Utility types in TypeScript zijn vooraf gedefinieerde types die helpen bij het transformeren van andere types. Ze kunnen worden gebruikt om nieuwe types te maken op basis van bestaande types door eigenschappen te selecteren, weg te laten of te wijzigen. Ze spelen een essentiële rol bij het onderhouden van schone, herbruikbare code.

Veelgebruikte TypeScript-hulpprogrammatypen

Hier zijn enkele van de meest gebruikte TypeScript-hulpprogramma's:

• Partial<T> – Maakt alle eigenschappen van het type T optioneel.
• Vereist<T> – Maakt alle eigenschappen van het type T verplicht.
• Readonly<T> – Maakt alle eigenschappen van het type T alleen-lezen.
• Pick<T, K> – Kiest een set eigenschappen K van het type T.
• Omit<T, K> – Verwijdert een set eigenschappen K uit type T.
• Record<K, T> – Construeert een objecttype met sleutels van het type K en waarden van het type T.

Voorbeeld: Gedeeltelijk gebruiken<T>

Het Partial hulpprogrammatype maakt alle eigenschappen van een interface optioneel. Dit is hoe het gebruikt kan worden:

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

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

updateUser({ name: "John" });

In dit voorbeeld accepteert updateUser een argument van het type Partial<User>, wat betekent dat slechts enkele eigenschappen van de User-interface vereist zijn.

Voorbeeld: Pick gebruiken<T, K>

Met het hulpprogramma Pick kunt u een subset van eigenschappen uit een type selecteren:

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

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

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

Hier maakt Pick<User, “name” | “email”> een nieuw type UserContactInfo met alleen de eigenschappen name en email van de oorspronkelijke User interface.

Voorbeeld: Omit gebruiken<T, K>

Het hulpprogramma Omit verwijdert opgegeven eigenschappen uit een type:

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

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

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

In dit voorbeeld wordt het type UserWithoutEmail gemaakt door de eigenschap email weg te laten uit de interface User.

Aangepaste hulpprogrammatypen maken

Aangepaste hulpprogrammatypen kunnen ook worden gemaakt met behulp van de geavanceerde typefuncties van TypeScript, zoals voorwaardelijke typen, toegewezen typen en meer. Hier is een eenvoudig voorbeeld van een aangepast hulpprogrammatype dat alle eigenschappen optioneel maakt:

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

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

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

Dit aangepaste type MyPartial functioneert op een vergelijkbare manier als het ingebouwde hulpprogramma Partial van TypeScript.

Conclusie

TypeScript-hulpprogrammatypen zijn een essentiële functie voor het werken met typen op een flexibele en herbruikbare manier. Door deze hulpprogrammatypen te benutten, kan code bondiger en beter te onderhouden worden. Of u nu ingebouwde hulpprogrammatypen zoals Partial, Pick en Omit gebruikt of aangepaste typen maakt, ze verbeteren het typesysteem van TypeScript aanzienlijk.