TypeScript-Standardbibliothek: Vollständiger Überblick |…

TypeScript-Standardbibliothek: Vollständiger Überblick

TypeScript ist eine streng typisierte Obermenge von JavaScript, die statische Typisierung und leistungsstarke Werkzeuge für die Entwicklung großer Anwendungen hinzufügt. Im Gegensatz zu vielen Sprachen verfügt TypeScript nicht über eine umfangreiche integrierte Standardbibliothek im klassischen Sinne (wie z. B. Java oder Python). Stattdessen bietet es eine Reihe von eingebauten Typen, Hilfsprogrammen für die Arbeit mit Typen, Dekorateuren und Compiler-Werkzeugen. In diesem Artikel werden wir alle Schlüsselkomponenten der TypeScript-Standardbibliothek im Detail durchgehen.

1. Eingebaute Datentypen

TypeScript enthält alle primitiven Typen von JavaScript und fügt eigene hinzu:

boolean — logischer Typ
number — Zahlen (ganze Zahlen und Gleitkommazahlen)
string — Zeichenketten
null und undefined — spezielle Werte
symbol — eindeutige Identifikatoren
bigint — große ganze Zahlen
any — Deaktivierung der Typprüfung
unknown — sichere Alternative zu any
never — Typ für Funktionen, die niemals enden
void — Fehlen eines Rückgabewerts

Beispiel für die Verwendung eingebauter Typen:

let isDone: boolean = false;let decimal: number = 42;let color: string = "blau";let notSure: unknown = 4;notSure = "jetzt ein String"; // zulässig

function error(message: string): never {    throw new Error(message);}

2. Hilfstypen (Utility Types)

TypeScript bietet leistungsstarke eingebaute Hilfsprogramme zur Transformation von Typen. Hier sind die nützlichsten davon:

Partial<T> — macht alle Felder des Typs T optional
Required<T> — macht alle Felder erforderlich
Readonly<T> — macht alle Felder schreibgeschützt
Pick<T, K> — wählt die angegebenen Schlüssel aus dem Typ aus
Omit<T, K> — schließt die angegebenen Schlüssel aus
Record<K, T> — erstellt einen Objekttyp mit Schlüsseln K und Werten T
Exclude<T, U> — schließt Typen aus, die in U vorhanden sind
ReturnType<T> — extrahiert den Rückgabetyp einer Funktion

Beispiel für die Verwendung von Hilfstypen:

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

// Teilweise Aktualisierung eines Benutzersfunction updateUser(id: number, changes: Partial<User>): void {    // Aktualisierungslogik}

// Nur lesenconst readonlyUser: Readonly<User> = {    id: 1,    name: "Ivan",    email: "ivan@example.com"};

// Auswahl von Felderntype UserName = Pick<User, "name" | "email">;

3. Dekorateure

Dekorateure sind spezielle Deklarationen, die es ermöglichen, Klassen, Methoden, Eigenschaften und Parameter zu modifizieren. TypeScript unterstützt mehrere Arten von Dekorateuren:

Klassen-Dekorateure — werden auf den Klassenkonstruktor angewendet
Methoden-Dekorateure — werden auf Klassenmethoden angewendet
Eigenschafts-Dekorateure — werden auf Eigenschaften angewendet
Parameter-Dekorateure — werden auf Methodenparameter angewendet

Beispiel eines Methoden-Dekorateurs für die Protokollierung:

function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {    const originalMethod = descriptor.value;    descriptor.value = function (...args: any[]) {        console.log(`Aufruf von ${propertyKey} mit Argumenten: ${JSON.stringify(args)}`);        return originalMethod.apply(this, args);    };    return descriptor;}

class Calculator {    @log    add(a: number, b: number): number {        return a + b;    }}

const calc = new Calculator();calc.add(2, 3); // Protokolliert: "Aufruf von add mit Argumenten: [2,3]"

4. Arbeiten mit Arrays und Promises

TypeScript erbt alle Array- und Promise-Methoden von JavaScript und fügt typsichere Überladungen hinzu:

// Arrays mit Typannotationconst numbers: number[] = [1, 2, 3, 4, 5];const doubled = numbers.map(n => n * 2); // Typ: number[]

// Promises mit Typannotationasync function fetchData(): Promise<string> {    const response = await fetch("https://api.example.com/data");    return response.text();}

// Typsichere Fehlerbehandlungasync function safeFetch(): Promise<string | null> {    try {        return await fetchData();    } catch (error) {        console.error("Fehler beim Abrufen der Daten:", error);        return null;    }}

5. Fazit

Die TypeScript-Standardbibliothek ist zwar nicht so umfangreich wie die von Java oder Python, bietet aber dennoch leistungsstarke Werkzeuge für die typsichere Entwicklung. Eingebaute Typen, Hilfstypen, Dekorateure und die Integration mit JavaScript-Ökosystemen machen TypeScript zu einer ausgezeichneten Wahl für moderne Webentwicklung. Verwenden Sie diese Werkzeuge, um saubereren, wartbareren und fehlerresistenteren Code zu schreiben.