Unions, Literaltypen und Narrowing

function formatiere(wert: string | number): string {
  if (typeof wert === "string") {
    return wert.toUpperCase();      // hier ist wert: string
  }
  return wert.toFixed(2);           // hier ist wert: number
}
console.log(formatiere("hallo"), formatiere(3.14159));

HALLO 3.14

function laenge(x: string | string[] | null): number {
  if (x === null) return 0;
  if (Array.isArray(x)) return x.length;
  return x.length;
}
console.log(laenge(null), laenge(["a", "b"]), laenge("Hallo"));

0 2 5

type Richtung = "links" | "rechts" | "oben" | "unten";
type Wuerfel = 1 | 2 | 3 | 4 | 5 | 6;

function gehe(r: Richtung, schritte: number = 1): string {
  return `${schritte} Schritt(e) nach ${r}`;
}
const w: Wuerfel = 4;
console.log(gehe("links"), gehe("oben", 3), w);

1 Schritt(e) nach links 3 Schritt(e) nach oben 4

type Richtung = "links" | "rechts";
function gehe(r: Richtung) {}
gehe("hinten");

error TS2345: Argument of type '"hinten"' is not assignable to parameter of type 'Richtung'.

type Form =
  | { art: "kreis"; radius: number }
  | { art: "rechteck"; breite: number; hoehe: number }
  | { art: "dreieck"; basis: number; hoehe: number };

function flaeche(f: Form): number {
  switch (f.art) {
    case "kreis":
      return Math.PI * f.radius ** 2;
    case "rechteck":
      return f.breite * f.hoehe;
    case "dreieck":
      return (f.basis * f.hoehe) / 2;
  }
}
console.log(flaeche({ art: "kreis", radius: 1 }).toFixed(2));
console.log(flaeche({ art: "rechteck", breite: 3, hoehe: 4 }));
console.log(flaeche({ art: "dreieck", basis: 6, hoehe: 5 }));

3.14
12
15

function pruefe(x: never): never {
  throw new Error("Nicht behandelt: " + JSON.stringify(x));
}
type Ampel = "rot" | "gelb" | "gruen";
function aktion(a: Ampel): string {
  switch (a) {
    case "rot": return "halt";
    case "gelb": return "achtung";
    case "gruen": return "los";
    default: return pruefe(a);     // Fehler, sobald ein Fall fehlt
  }
}
console.log(aktion("rot"), aktion("gruen"));

halt los

interface Hund { bellen(): string }
interface Katze { miauen(): string }

function istHund(t: Hund | Katze): t is Hund {
  return "bellen" in t;
}
function laut(t: Hund | Katze): string {
  return istHund(t) ? t.bellen() : t.miauen();
}
console.log(laut({ bellen: () => "Wuff" }), laut({ miauen: () => "Miau" }));

Wuff Miau

type Ergebnis<T> = { ok: true; wert: T } | { ok: false; fehler: string };

function teile(a: number, b: number): Ergebnis<number> {
  return b === 0 ? { ok: false, fehler: "Division durch 0" } : { ok: true, wert: a / b };
}
for (const [a, b] of [[10, 2], [1, 0]]) {
  const r = teile(a, b);
  console.log(r.ok ? `Ergebnis ${r.wert}` : `Fehler: ${r.fehler}`);
}

Ergebnis 5
Fehler: Division durch 0