Zum Inhalt springen

Spass mit TypeScript für Fortgeschrittene

Zwei Männer stehen an einem Schreibtisch und schauen auf einen Computerbildschirm in einem Großraumbüro. Eine weitere Person sitzt mit Kopfhörern an einem Schreibtisch im Vordergrund.

Dieser Artikel richtet sich an alle, die die Grundlagen von TypeScript kennen, es aber noch nie in einem grossen Projekt eingesetzt und/oder seine Advanced Types noch nicht erkundet haben.

Mein Ziel: dich anhand von jeder Menge Beispielen davon zu überzeugen, dass das mächtige Typsystem von TypeScript elegante Lösungen für komplexe Probleme im Web Engineering liefert. Und dass du damit verblüffende und unterhaltsame Modelle bauen kannst.

Schau dir dieses Video an und nimm die Code-Snippets unten zur Hand.

Bausteine

Diese Typen findest du in der offiziellen TypeScript-Dokumentation. Sie sind die Bausteine für fortgeschrittenere und ausgefallenere Dinge. Betrachte diesen Abschnitt als Cheat Sheet.

Intersection Types

Alle Members aus mehreren Typen holen:

type Duck = Quackable & Swimmable;

Stellst du dir Typen als Mengen vor, bekommst du hier die Schnittmenge zweier Typen, also eine kleinere Menge. Das kann verwirrend sein, denn der resultierende Typ hat ein «grösseres» Interface, nämlich die Vereinigung der Members beider Typen.

Union Types

Gemeinsame Members aus mehreren Typen holen (der resultierende Typ ist die Vereinigung der beiden, also eine grössere Menge):

type Flyable = Eagle | Butterfly;

Eigene Type Guards

Bedingter Type Cast:

const canFly = (animal: Animal): animal is Flyable =>
  typeof (animal as any).fly === 'function';

if (canFly(animal)) {
  animal.fly();
}

Mit dem Keyword is definierst du Funktionen, die «von Hand» bestimmen, ob ein Wert zu einem Typ gehört. TypeScript geht dann im true-Zweig einer Bedingung von diesem Typ aus.

Type Assertion

Eine Kurzform für einen Cast, wenn du weisst, dass eine bestimmte Variable garantiert definiert ist:

person.children[0]!.name;

Literal Types

Du kannst echte primitive Literale (Strings, Booleans usw.) als Typen verwenden:

type Move = 'ROCK' | 'PAPER' | 'SCISSOR';

Stellst du dir Typen als Mengen vor, ist der Typ 'ROCK' die Menge, die nur den Wert 'ROCK' enthält.

Never

Ein Ausdruck, der nie aufgelöst wird:

const throws = (): never => {
  throw new Error('This never returns');
}

const loops = (): never => {
  while (true) {
    console.log('This never returns either');
  }
}

Dieser Typ taucht in den Beispielen unten wie von Zauberhand an vielen überraschenden Stellen auf.

Unknown

Ein sichererer Typ als any für Variablen, denen du nicht trauen kannst:

let a: string;

let x: any;
a = x; // Compiles
x = a; // Compiles

let y: unknown;
y = a; // Compiles
a = y; // Does not compile

Index Types

Auf die Typen von Objekt-Keys oder -Values zugreifen:

type Duck = {
  colors: string;
  feathers: number;
}

type DuckProps = keyof Duck; // = 'colors' | 'feathers'
type ColorType = Duck['colors']; // = string
type DuckValues = Duck[DuckProps] // = string | number

Mapped Types

Einen Objekttyp von einem anderen ableiten:

type Map1 = { [key: string]: string };

type Map2 = { [P in 'a' | 'b' | 'c']: string };
// = { a: string, b: string, c: string }

type Map3 = { [P in 'a' | 'b' | 'c']: P };
// = { a: 'a', b: 'b', c: 'c' }

Diese mächtige Abstraktion ergibt mehr Sinn, sobald du konkrete Anwendungen davon siehst.

Conditional Types

Einen Typ über eine Bedingung von einem anderen Typ abhängig machen:

type StringOrNumber<T> = T extends boolean ? string : number;

type T1 = StringOrNumber<true>; // string
type T2 = StringOrNumber<false>; // string
type T3 = StringOrNumber<Object>; // number

Hier eine echte Anwendung für Conditional Types:

type TypeName<T> =
  T extends string ? "string":
  T extends number ? "number" :
  T extends boolean ? "boolean" :
  T extends undefined ? "undefined" :
  T extends Function ? "function" :
  "object";

type T0 = TypeName<string>; // "string"

Mit dem Keyword infer führst du eine Typvariable ein, deren Typ inferiert wird:

type ElementType<T> = T extends (infer U)[] ? U : never;
type T = ElementType<[]>; // = never
type T1 = ElementType<string[]>; // = string

Diverse Patterns

Funktionale Programmierung

Das hat nicht direkt mit Advanced Types zu tun. Es zeigt eher, wie du mit TypeScript schlank und trotzdem typsicher programmieren kannst. In der Java-Welt gibt es im Clean-Code-Paradigma zwei Hauptkategorien von Klassen: Objekte und Datentypen. Datentypen repräsentieren Daten (denk an Getter und Setter), Objekte repräsentieren Funktionalität (denk an Methoden). Mit TypeScript lässt sich dieser Ansatz noch weiter vereinfachen: Du nimmst einfach Interfaces, um Daten zu repräsentieren, und Funktionen, um sie zu verändern. Kein aufgeblähter Boilerplate-Code, keine Konstruktoren, Getter und Setter. Gib einfach ein simples Objekt zurück und TypeScript stellt sicher, dass es richtig strukturiert ist.

interface RawPerson {
  identifier: number;
  first_name: string;
  last_name: string;
}

interface Person {
  id: string;
  fullName: string;
}

const transformPerson = (raw: RawPerson): Person => {
  return {
    id: `${raw.identifier}`,
    fullName: `${raw.first_name} ${raw.last_name}`,
  }
}

Discriminated Unions

TypeScript merkt, wenn du in einem switch-Statement alle möglichen Varianten eines Typs abgedeckt hast, und zwingt dich nicht zu einem default-Statement.

type Eagle = {
  kind: 'eagle';
  fly: () => 'fly';
};

type Duck = {
  kind: 'duck';
  quack: () => 'quack';
};

type Bird = {
  kind: 'bird';
};

type Animal = Eagle | Duck | Bird;

const doSomething = (animal: Animal): string => {
  switch (animal.kind) {
    case 'eagle':
      return animal.fly();
    case 'duck':
      return animal.quack();
    case 'bird':
      return "animal.quack()";
  }
}

Typen aus Konstanten ableiten

Oft brauchen wir Literal Types sowohl als Werte wie auch als Typen. Um Redundanz zu vermeiden, leiten wir Letztere aus Ersteren ab.

const MOVES = {
  ROCK: { beats: 'SCISSOR' },
  PAPER: { beats: 'ROCK' },
  SCISSOR: { beats: 'PAPER' },
};
type Move = keyof typeof MOVES;
const move: Move = 'ROCK';

Nicht vertrauenswürdiger User-Input

Nicht vertrauenswürdiger User-Input ist ein Anwendungsfall für unknown.

const validateInt = (s: unknown): number => {
  let n;
  switch (typeof s) {
    case 'number':
      // handle
    case 'string':
      // handle
    // other cases
    default:
      throw new Error('Not a number.');
  }
}

Mapped Types

Eine readonly-Version eines Typs erstellen:

type Readonly<T> = { readonly [P in keyof T]: T[P] };
type ReadonlyDuck = Readonly<Duck>;
// = { readonly color: string; readonly feathers: number }

Eine partielle Version eines Typs ableiten:

type Partial<T> = { [P in keyof T]?: T[P] };
type PartialDuck = Partial<Duck>;
// = { color?: string; feathers?: number }

Eine Version eines Typs ableiten, in der alle Felder Pflicht sind:

type PartialDuck = {
  color?: string;
  feathers?: number;
}
type Required<T> = { [P in keyof T]-?: T[P] };
type Duck = Required<PartialDuck>;
// = { color: string; feathers: number }

Eine nullable Version eines Typs ableiten:

type Nullable<T> = { [P in keyof T]: T[P] | null }
type NullableDuck = Partial<Duck>;
// = { color: string | null; feathers: number | null }

Einen Typ mit nur bestimmten Feldern ableiten (Pick):

type Pick<T, K extends keyof T> = { [P in K]: T[P] };
type ColorDuck = Pick<Duck, 'color'>;

Ein Beispiel aus der Praxis: Wir wählen bestimmte Spalten aus einer SQL-Tabelle aus, und TypeScript leitet den partiellen Typ automatisch für uns ab:

async function fetchPersonById<T extends keyof Person>(
  id: string,
  ...fields: T[]
): Promise<Pick<Reaction, T>> {
  return await knex('Person')
    .where({ id })
    .select(fields)
    .first();
}

const reaction = await fetchPersonById(id, 'name', 'age');
// = { name: string, age: number }

Einen Record (alle Properties haben denselben vorgegebenen Typ) aus einem Typ ableiten:

type Record<K extends string, T> = { [P in K]: T };
type Day = 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday' | 'Sunday';
type EverydayParty = Record<Day, 'party'>;
/*
  = {
    Monday: 'party';
    Tuesday: 'party';
    Wednesday: 'party';
    Thursday: 'party';
    Friday: 'party';
    Saturday: 'party';
    Sunday: 'party';
  }
*/

Conditional Types

Union Types filtern

Eine Teilmenge aus einem Typ filtern bzw. extrahieren:

type Filter<T, U> = T extends U ? T : never;
type T1 = Filter<"a" | "b", "a">; // = "a"

// Natively available as Extract
type T2 = Extract<"a" | "b", "a"> // = "a"

Eine Teilmenge von einem Typ abziehen bzw. ausschliessen:

type Diff<T, U> = T extends U ? never : T;
type T1 = Diff<"a" | "b", "a">; // = "b"

// Natively available as Exclude
type T2 = Exclude<"a" | "b", "a"> // = "b"

null und undefined aus einem Typ ausschliessen (und ihn damit non-nullable machen):

type NonNullable<T> = Diff<T, null | undefined>;
type T = NonNullable<string | null | undefined>; // = string

Bestimmte Felder aus einem Typ weglassen:

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
type PartialDuck = Omit<Duck, 'feathers'>;
// = { color: string }

Hier ein Beispiel aus der Praxis (wie du einen React.js-HOC korrekt typisierst):

export interface WithUserProps {
  user: User;
}

export const withUser = <P extends WithUserProps>
  (Component: React.ComponentType<P>) => (props: Omit<P, WithUserProps>) => (
    <Component {...props} user={getUser()} />
  )

const UsernameComponent = ({ user, message }: { user: User, message: string }) => (
  <div>Hi {user.username}! {message}</div>
)

const Username = withUser(UsernameComponent); // ({ message }) => JSX.Element

Kombiniert mit Mapped Types

Die Funktions-Properties eines Objekts holen:

type FunctionPropertyNames<T> = {
  [K in keyof T]: T[K] extends Function ? K : never
}[keyof T];
type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;

type Duck = {
  color: string,
  fly: () => void,
}
type T1 = FunctionProperties<Duck>; // = { fly: () => void }
type T2 = FunctionPropertyNames<Duck>; // = "fly"

Die Nicht-Funktions-Properties eines Objekts holen:

type NonFunctionPropertyNames<T> = {
  [K in keyof T]: T[K] extends Function ? never : K
}[keyof T];

type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;

type Duck = {
  color: string,
  fly: () => void,
}
type T1 = NonFunctionProperties<Duck>; // = { color: string }
type T2 = NonFunctionPropertyNames<Duck>; // = "color"

Den Rückgabetyp einer Funktion holen:

type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;

const x = (a: string): number => 1;
type R = ReturnType<typeof x>; // = number

Den Instanztyp einer Konstruktorfunktion holen:

type InstanceType<T extends new (...args: any[]) => any>
  = T extends new (...args: any[]) => infer R ? R : any;

class Duck {}

const make2 = <T extends new (...args: any[]) => any>
  (constructor: T): [InstanceType<T>, InstanceType<T>] =>
    [new constructor(), new constructor()]

const ducks = make2(Duck); // = [Duck, Duck]

Redis mit Promises

Noch ein Beispiel aus der Praxis. Alle Methoden der npm-Library redis arbeiten mit Callbacks. Wir arbeiten lieber mit Promises und async/await. Den neuen Typ können wir aus dem alten ableiten, und zwar so, wie wir ihn aufbauen.

import { ClientOpts, createClient } from 'redis';
import { promisify } from 'util';

export const promisifyRedis = (opts: ClientOpts) => {
  const redis = createClient(opts);

  const promisifiedRedis = {
    setex: promisify(redis.setex),
    get: promisify(redis.get),
  };
  const wrappedRedis: typeof promisifiedRedis = {} as any;
  for (const key of Object.keys(promisifiedRedis) as (keyof typeof promisifiedRedis)[]) {
    wrappedRedis[key] = promisifiedRedis[key].bind(redis);
  }
  return wrappedRedis;
};

export type Redis = ReturnType<typeof promisifyRedis>;
/* =
type Redis = {
  setex: (arg1: string, arg2: number, arg3: string) => Promise<string>;
  get: (arg1: string) => Promise<...>;
}
*/

Fazit

Ich hoffe, ich konnte dich von der Power von TypeScript überzeugen. Und jetzt: Ran an die TYPEN!

Ressourcen

Ein Mann mit Brille, Bart und kurzen Haaren in einem marineblauen Button-Down-Hemd und khakifarbenen Hosen steht lächelnd vor einem blauen Hintergrund.

Geschrieben von
Nicola Marcacci Rossi

Technology|Dezember 2018

Ähnliche Challenge auf dem Tisch? Lass uns drüber reden.

Weitere Artikel

© 2026 smartive AG