Praktyczne wzorce z uniami i przecięciami

Wprowadzenie

Wzorzec opcjonalnego ładunku

type Event =
  | { type: 'click'; x: number; y: number }
  | { type: 'keypress'; key: string }
  | { type: 'blur' };

Builder/mixin z przecięciem

type Serializable = { serialize(): string };
type Validatable = { validate(): boolean };
type Model = Serializable & Validatable & { id: number };

Unia do normalizacji danych wejściowych

function toArray<T>(val: T | T[]): T[] {
  return Array.isArray(val) ? val : [val];
}

Typy brandowane z przecięciem

type UserId = number & { __brand: 'UserId' };
type PostId = number & { __brand: 'PostId' };
// Prevents accidentally mixing IDs

Wzorzec WithOptional

type RequiredFields = { id: number; email: string };
type OptionalFields = Partial<{ name: string; bio: string }>;
type UserUpdate = RequiredFields & OptionalFields;

Polimorficzne właściwości komponentu

type ButtonProps =
  | { variant: 'primary'; onClick: () => void }
  | { variant: 'link'; href: string };

Rozszerzanie typów innych firm

import type { Request } from 'express';
type AuthRequest = Request & { user: User };

Łączenie unii i przecięcia

type Admin = { role: 'admin' };
type User = { role: 'user' };
type LoggedIn = { sessionId: string };
type AuthUser = (Admin | User) & LoggedIn;

Strażnicy typów dla elementów unii

function isAdmin(u: AuthUser): u is Admin & LoggedIn {
  return u.role === 'admin';
}

Rozdzielność w przecięciach

type Base = { id: number };
type AB = Base & (string | number);
// equivalent to: (Base & string) | (Base & number)

Szybkie sprawdzenie

Podsumowanie