Spass mit TypeScript für Fortgeschrittene

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 compileIndex 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 | numberMapped 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>; // numberHier 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[]>; // = stringDiverse 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>; // = stringBestimmte 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.ElementKombiniert 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>; // = numberDen 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

Geschrieben von
Nicola Marcacci Rossi
Ähnliche Challenge auf dem Tisch? Lass uns drüber reden.
Weitere Artikel
Technology|April 2018Aufbau von APIs der Unternehmensklasse mit GraphQL, MySQL und Node.js

Technology|April 2017Wenn Sie die Ersetzung einer komplexen Webanwendung vorschlagen, sollten Sie diese zehn Aspekte nicht außer Acht lassen

Technology|April 2017Fünf Dinge, die Sie beachten sollten, bevor Sie eine komplexe Legacy-Webanwendung ersetzen
