12k
All articles

Weniger bekannte TypeScript-Features, die sich zu lernen lohnen

Entdecken Sie sieben wenig bekannte TypeScript-Funktionen: von const-Typparametern und NoInfer bis zu Assertion-Funktionen und verbatimModuleSyntax, mit Versionen und Codebeispielen.

OpenReplay Team
OpenReplay Team
Weniger bekannte TypeScript-Features, die sich zu lernen lohnen

Sieben TypeScript-Features, die selbst viele erfahrene Entwickler noch nicht nutzen: const-Typparameter (5.0), NoInfer (5.4), Assertion-Funktionen (3.7), benannte Tupel-Elemente (4.0), Varianz-Annotationen (4.7), das Schlüsselwort accessor (4.9) sowie import type in Kombination mit verbatimModuleSyntax (3.8 bzw. 5.0).

Wenn Sie TypeScript etwa zur Zeit von Version 4.x gelernt haben und seitdem vor allem mit dem Ausliefern von Features beschäftigt waren, schreiben Sie vermutlich noch immer as const an Aufrufstellen und fügen zusätzliche Typparameter hinzu, um zu verhindern, dass die Typinferenz Typen aufweitet. Neuere Releases bieten für beides kürzere Lösungen.

Dieser Artikel stellt die Features nacheinander vor: was sie leisten, mit welcher Version sie eingeführt wurden und jeweils ein kurzes Beispiel, das im Strict Mode kompiliert.

Das Wichtigste in Kürze

  • Ein const-Typparameter (TypeScript 5.0) inferiert ["/", "/users"] als readonly ["/", "/users"], sofern der Constraint readonly ist, etwa readonly string[].
  • NoInfer<T> (TypeScript 5.4) verhindert, dass ein Parameter als Inferenzquelle dient. Ein Standardwert kann so den Typ, den die übrigen Argumente festlegen, nicht aufweiten.
  • Eine Assertion-Funktion mit der Signatur asserts value is T verengt ihr Argument nach dem Aufruf für den gesamten restlichen Scope, nicht nur innerhalb eines if-Blocks.
  • Unter verbatimModuleSyntax wird ein Import nur dann entfernt, wenn sich type auf die gesamte Anweisung bezieht. import { type X } from "./mod" erzeugt import {} from "./mod", das Modul wird also weiterhin ausgeführt.

Fortgeschrittene TypeScript-Features nach Version

Die Tabelle listet die sieben weniger bekannten TypeScript-Features zusammen mit der Version, in der sie eingeführt wurden, und den Entwicklern, für die sie am relevantesten sind.

FeatureEingeführt inHauptzielgruppe
Assertion-Funktionen3.7App- und Bibliothekscode
import type3.8Build-Konfiguration
Benannte Tupel-Elemente4.0Autoren von Hooks und APIs
Varianz-Annotationen (in/out)4.7Bibliotheksautoren
Schlüsselwort accessor4.9Nutzer von Decorators
const-Typparameter5.0Autoren generischer APIs
verbatimModuleSyntax5.0Build-Konfiguration
NoInfer<T>5.4Autoren generischer APIs

Const-Typparameter (TypeScript 5.0)

Mit TypeScript 5.0 kam der Modifier const für Typparameter hinzu. Er veranlasst den Compiler, Array- und Objektliterale so zu inferieren, als hätte der Aufrufer as const geschrieben. Aufrufer müssen also nicht mehr an die Assertion denken, um Literaltypen zu erhalten.

Kombinieren Sie den const-Modifier mit einem readonly-Constraint, wenn Sie readonly-Ergebnisse wünschen. Bei einem veränderbaren Constraint wie string[] fielen TypeScript 5.0 bis 5.2 auf string[] zurück. Seit 5.3 inferiert der Compiler stattdessen ein veränderbares Tupel. Außerdem wirkt der const-Modifier nur auf Literale, die direkt im Aufruf stehen. Eine zuvor deklarierte Variable behält den bereits aufgeweiteten Typ.

function defineRoutes<T extends readonly string[]>(paths: T): T { return paths; }
const a = defineRoutes(["/", "/users"]);        // string[]

function defineRoutesExact<const T extends readonly string[]>(paths: T): T { return paths; }
const b = defineRoutesExact(["/", "/users"]);   // readonly ["/", "/users"]

function defineRoutesMutable<const T extends string[]>(paths: T): T { return paths; }
const c = defineRoutesMutable(["/", "/users"]); // ["/", "/users"] (TS 5.3+; string[] in 5.0–5.2)

NoInfer für kontrollierte Inferenz (TypeScript 5.4)

NoInfer<T>, eingeführt in TypeScript 5.4, verhindert, dass der Compiler ein bestimmtes Argument als Inferenzquelle heranzieht. Dieses Argument wird dann gegen den aus den übrigen Parametern inferierten Typ geprüft, statt ihn aufzuweiten. Vor 5.4 bestand der übliche Workaround in einem zweiten Typparameter, der durch den ersten eingeschränkt wurde. Das funktionierte, fügte aber einen Typparameter hinzu, der in der Signatur nur ein einziges Mal vorkam.

function createSelect<T extends string>(options: T[], initial: NoInfer<T>) {
  return { options, value: initial };
}

createSelect(["draft", "published"], "draft");    // OK
createSelect(["draft", "published"], "archived");
// Error: Argument of type '"archived"' is not assignable
// to parameter of type '"draft" | "published"'.

Ohne NoInfer würde T zu "draft" | "published" | "archived" aufgeweitet, und der Tippfehler würde kompilieren. Die Referenz zu den Utility Types dokumentiert den Typ zusammen mit Partial und Pick.

Assertion-Funktionen (TypeScript 3.7)

Eine Assertion-Funktion verengt ihr Argument für den gesamten restlichen umschließenden Scope, sobald sie ohne Exception zurückkehrt. Damit eignet sie sich gut für Fail-Fast-Guard-Clauses, die keine Verzweigung benötigen. Ein Type Guard (value is T) verengt nur innerhalb der Bedingung, in der er aufgerufen wird. Eine Signatur der Form asserts value is T, eingeführt in TypeScript 3.7, verengt dagegen alles, was nach dem Aufruf folgt.

function assertIsDefined<T>(value: T, name = "value"): asserts value is NonNullable<T> {
  if (value === undefined || value === null) {
    throw new Error(`${name} is not defined`);
  }
}

const root = document.getElementById("app"); // HTMLElement | null
assertIsDefined(root, "#app");
root.classList.add("ready");                 // root: HTMLElement

Assertion-Funktionen haben einen Haken: Schreiben Sie den Helper als Arrow Function, die einer nicht annotierten const zugewiesen wird, schlägt die Aufrufstelle mit der Meldung „Assertions require every name in the call target to be declared with an explicit type annotation.” fehl. Verwenden Sie entweder eine Funktionsdeklaration oder versehen Sie die const mit einer expliziten Typannotation.

Benannte Tupel-Elemente (TypeScript 4.0)

Benannte Tupel-Elemente, eingeführt in TypeScript 4.0, ermöglichen es, jede Position in einem Tupeltyp zu benennen. Die Namen erscheinen in Editor-Hovers, in der Signaturhilfe und in Fehlermeldungen. Tupel-Labels ändern ausschließlich, was Editoren und Fehlermeldungen anzeigen. Sie verändern weder den Typ des Tupels, noch hindern sie Aufrufer daran, die Elemente unter beliebigen Namen zu destrukturieren. Seit TypeScript 5.2 kann ein Tupel zudem benannte und unbenannte Elemente mischen.

Der klassische Anwendungsfall ist ein Rückgabetyp im Stil eines Hooks:

type ToggleState = [isOn: boolean, toggle: () => void];

function useToggle(initial = false): ToggleState {
  let isOn = initial;
  return [isOn, () => { isOn = !isOn; }];
}

const [open, toggleOpen] = useToggle(); // any names work; labels show in hovers

Varianz-Annotationen: in und out (TypeScript 4.7)

Varianz-Annotationen, eingeführt in TypeScript 4.7, erlauben es, explizit festzulegen, ob ein Typparameter kovariant (out), kontravariant (in) oder beides ist. Varianz-Annotationen richten sich vor allem an Bibliotheksautoren; Anwendungscode benötigt sie so gut wie nie. Die Release Notes zu 4.7 stellen sie als Mittel dar, die Absicht zu dokumentieren und bei tief rekursiven Typen die Typprüfung zu beschleunigen. TypeScript meldet einen Fehler, wenn eine Annotation der tatsächlichen Verwendung des Parameters widerspricht, akzeptiert aber Annotationen, die strenger als nötig sind.

interface Producer<out T> { get: () => T }
interface Consumer<in T> { accept: (value: T) => void }

interface Bad<in T> { get: () => T }
// Error: Type 'Bad<super-T>' is not assignable to type 'Bad<sub-T>'
// as implied by variance annotation.

Das Schlüsselwort accessor (TypeScript 4.9)

Mit TypeScript 4.9 kamen Auto-Accessors hinzu. Sie werden wie ein Klassenfeld deklariert, jedoch mit vorangestelltem accessor. Der Compiler macht daraus ein Getter-Setter-Paar, das auf einem nicht erreichbaren privaten Feld basiert. Ein Auto-Accessor bietet einem Decorator damit eine zentrale Stelle, um sowohl Lese- als auch Schreibzugriffe auf das Feld abzufangen.

Das folgende Beispiel verwendet die Standard-Decorator-Signatur aus TypeScript 5.0 mit Typen aus der im Compiler mitgelieferten decorators.d.ts. Es setzt voraus, dass experimentalDecorators deaktiviert ist, da Legacy-Decorators eine andere Signatur verwenden.

function logged<This, V>(
  target: ClassAccessorDecoratorTarget<This, V>,
  context: ClassAccessorDecoratorContext<This, V>
): ClassAccessorDecoratorResult<This, V> {
  return {
    set(value) {
      console.log(`set ${String(context.name)} =`, value);
      target.set.call(this, value);
    },
  };
}

class Settings {
  @logged accessor theme = "light";
}

import type mit verbatimModuleSyntax (TypeScript 3.8 und 5.0)

Unter verbatimModuleSyntax entfernt TypeScript einen Import nur dann, wenn sich type auf die gesamte Anweisung bezieht. Alle anderen Imports werden unverändert ausgegeben. Die Syntax import type gibt es bereits seit TypeScript 3.8. Das Flag selbst kam mit 5.0 und ersetzte importsNotUsedAsValues und preserveValueImports, die in 5.0 als veraltet markiert wurden und in TypeScript 7 nicht mehr existieren.

{ "compilerOptions": { "verbatimModuleSyntax": true } }
import type { User } from "./api";         // erased entirely
import { fetchUser, type Post } from "./api"; // emits: import { fetchUser } from "./api";
import { type Config } from "./config";    // emits: import {} from "./config";

Die dritte Zeile, import { type Config }, ist eine typische Stolperfalle. Ein Inline-Modifier type hinterlässt trotzdem einen leeren Import, sodass das Modul geladen wird und seine Seiteneffekte ausgeführt werden. Sobald Sie das Flag aktivieren, führt jeder Typ, der ohne type-Modifier importiert wird, zu einem Kompilierfehler. Die Migration besteht im Wesentlichen darin, reine Typ-Imports mit benannten Bindungen in import type umzuwandeln.

Weiterführende Themen zu fortgeschrittenem TypeScript

Einige Themen wurden bewusst ausgeklammert, da ihnen eigene Artikel gewidmet sind:

Fazit

Die meisten dieser Features ersetzen entweder einen Workaround oder verlagern eine Prüfung von einer Laufzeitkonvention ins Typsystem. const-Typparameter und NoInfer verschaffen generischen APIs eine präzise Inferenz, ohne Aufrufern zusätzliche Arbeit abzuverlangen. Assertion-Funktionen und benannte Tupel machen alltäglichen Anwendungscode robuster, und verbatimModuleSyntax sorgt für vorhersehbar ausgegebene Imports. Ein pragmatischer erster Schritt: Aktivieren Sie verbatimModuleSyntax in einem Package, beheben Sie die vom Compiler gemeldeten reinen Typ-Imports und ergänzen Sie anschließend const bei jedem Generic, dessen Aufrufer bisher as const anhängen müssen.

FAQs

Funktioniert verbatimModuleSyntax in Projekten, die CommonJS ausgeben?

Ja, allerdings müssen Dateien, die als CommonJS ausgegeben werden, die CommonJS-artige Syntax von TypeScript verwenden: import fs = require('fs') für Imports und export = für Exports. ESM-Import- oder -Export-Anweisungen in solchen Dateien führen zu einem Kompilierfehler. Aktuelle Releases melden ihn als TS1295 und schlagen vor, das Feld type in der package.json zu ändern oder die Moduleinstellungen anzupassen. Dateien, die als ESM ausgegeben werden, behalten die normale Import- und Export-Syntax.

Brauche ich isolatedModules noch, wenn ich verbatimModuleSyntax aktiviere?

Nein. Laut TSConfig-Referenz wird isolatedModules standardmäßig auf true gesetzt, sobald verbatimModuleSyntax aktiviert ist. Die Prüfungen für die Transpilierung einzelner Dateien greifen also automatisch, und Sie können den expliziten Eintrag entfernen. Diese Prüfungen sind für Tools wie esbuild, SWC und Babel relevant, die jede Datei separat kompilieren und nicht erkennen können, ob ein importierter Name ein Typ oder ein Wert ist.

Kann eine Assertion-Funktion async sein?

Nein. TypeScript kennt keine asynchrone Assertion-Signatur, ein Rückgabetyp wie Promise<asserts value is T> ist daher ungültig. Das Feature wurde in TypeScript-Issue 37681 angefragt, ist aber nicht Teil der Sprache. Der übliche Workaround besteht darin, zuerst die asynchrone Operation mit await abzuwarten und anschließend eine synchrone Assertion-Funktion auf das Ergebnis anzuwenden – oder die asynchrone Funktion den validierten Wert mit einem verengten Typ zurückgeben zu lassen.

Open-source session replay

Complete picture for complete understanding

Capture every clue your frontend is leaving so you can instantly get to the root cause of any issue with OpenReplay — the open-source session replay tool for developers. Self-host it in minutes, and have complete control over your customer data.

Star on GitHub12k

We use cookies to improve your experience. By using our site, you accept cookies.