Erzählen Sie mir von den Utility-Typen in TypeScript…

Die Utility-Typen in TypeScript sind eingebaute Typen, die es ermöglichen, bestehende Datentypen in neue Typen umzuwandeln, indem sie verschiedene nützliche Operationen ausführen. Sie helfen, die Flexibilität und Wiederverwendbarkeit von Typen zu erhöhen und reduzieren Redundanz im Code.

Haupt-Utility-Typen:

Partial<Type>: Erstellt einen neuen Typ, bei dem alle Eigenschaften von Type optional sind.

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

type PartialUser = Partial<User>;
// PartialUser ist { id?: number; name?: string; age?: number; }

Readonly<Type>: Erstellt einen neuen Typ, bei dem alle Eigenschaften von Type nur lesbar sind.

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

type ReadonlyPoint = Readonly<Point>;
// ReadonlyPoint ist { readonly x: number; readonly y: number; }

Pick<Type, Keys>: Erstellt einen Typ, der eine ausgewählte Menge von Eigenschaften Keys aus Type enthält.

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
}

type ProductSummary = Pick<Product, 'id' | 'name' | 'price'>;
// ProductSummary ist { id: number; name: string; price: number; }

Omit<Type, Keys>: Erstellt einen Typ, der eine bestimmte Menge von Eigenschaften Keys aus Type ausschließt.

interface Order {
  id: number;
  productId: number;
  quantity: number;
  timestamp: string;
}

type OrderDetails = Omit<Order, 'timestamp'>;
// OrderDetails ist { id: number; productId: number; quantity: number; }

Exclude<Type, ExcludedUnion>: Erstellt einen Typ, der alle Elemente von Type enthält, die nicht in ExcludedUnion enthalten sind. Wird für Union-Typen verwendet.

type Colors = 'red' | 'green' | 'blue' | 'yellow';
type PrimaryColors = Exclude<Colors, 'yellow'>;
// PrimaryColors ist 'red' | 'green' | 'blue'

Extract<Type, Union>: Erstellt einen Typ, der nur die Elemente aus Type enthält, die auch in Union enthalten sind. Wird für Union-Typen verwendet.

type AllAnimals = 'dog' | 'cat' | 'fish' | 'bird';
type PetAnimals = Extract<AllAnimals, 'dog' | 'cat'>;
// PetAnimals ist 'dog' | 'cat'

NonNullable<Type>: Erstellt einen Typ, der null und undefined ausschließt.

type MaybeString = string | null | undefined;
type NotNullableString = NonNullable<MaybeString>;
// NotNullableString ist string

Record<Keys, Type>: Erstellt einen Objekttyp mit Schlüssel aus Keys und Werten vom Typ Type.

type CityPopulation = Record<string, number>;
// CityPopulation ist { [key: string]: number }

const population: CityPopulation = {
  "Moscow": 12635466,
  "Saint Petersburg": 5381033,
};

Parameters<Type>: Gibt ein Tuple der Parameter-Typen der Funktion Type zurück.

function greet(name: string, age: number): string {
  return `Hello, ${name}! You are ${age}.`;
}

type GreetParams = Parameters<typeof greet>;
// GreetParams ist [name: string, age: number]

ReturnType<Type>: Gibt den Rückgabetyp der Funktion Type zurück.

function calculateSum(a: number, b: number): number {
  return a + b;
}

type SumResult = ReturnType<typeof calculateSum>;
// SumResult ist number

ConstructorParameters<Type>: Gibt ein Tuple oder Array der Parameter des Konstruktors der Klasse Type zurück.

class MyClass {
  constructor(name: string, id: number) {}
}

type MyClassParams = ConstructorParameters<typeof MyClass>;
// MyClassParams ist [name: string, id: number]

InstanceType<Type>: Gibt den Instanztyp der Klasse Type zurück.

class AnotherClass {
  value: string;
  constructor(v: string) {
    this.value = v;
  }
}

type AnotherClassInstance = InstanceType<typeof AnotherClass>;
// AnotherClassInstance ist AnotherClass

Die Verwendung von Utility-Typen macht den Code sicherer, wartbarer und ausdrucksstärker, indem sie eine effiziente Verwaltung komplexer Datentypen ermöglicht.

Erzählen Sie mir von den Utility-Typen in TypeScript.