📋Spickzettel

let n: number = 1;
const s = "abc"; // Typ: "abc"
let liste: string[] = [];
let paar: [string, number] = ["a", 1];

interface Punkt {
  readonly x: number;
  y?: number;
}
type Id = string | number;

function f(a: number, b = 2, c?: string): string {
  return String(a + b) + (c ?? "");
}
const g = (x: number): boolean => x > 0;
type Fn = (x: number) => void;

function summe(...z: number[]) {
  return z.reduce((a, b) => a + b, 0);
}
function p(x: string): number;
function p(x: number): string;
function p(x: string | number) {
  return typeof x === "string" ? Number(x) : String(x);
}

type A = string | number;
type B = { a: 1 } & { b: 2 };

type Modus = "hell" | "dunkel";
const FARBEN = ["rot", "blau"] as const;
type Farbe = (typeof FARBEN)[number];

const k = { port: 80 } satisfies Record<string, number>;
k.port.toFixed(); // bleibt number

const nutzer = { id: 1, name: "Ada" };
type Nutzer = typeof nutzer;
type Schluessel = keyof Nutzer; // "id" | "name"
type Name = Nutzer["name"]; // string

function f(x: string | number | Date | null) {
  if (x === null) return;
  if (typeof x === "string") x.trim();
  else if (x instanceof Date) x.getTime();
  else x.toFixed();
}

function istText(x: unknown): x is string {
  return typeof x === "string";
}
function sicher(x: unknown): asserts x is number {
  if (typeof x !== "number") throw new Error();
}

type S = "a" | "b";
function f(s: S) {
  switch (s) {
    case "a": return 1;
    case "b": return 2;
    default: const n: never = s; return n;
  }
}

function erstes<T>(l: T[]): T | undefined {
  return l[0];
}
function lies<T, K extends keyof T>(o: T, k: K): T[K] {
  return o[k];
}

class Box<T = unknown> {
  constructor(public inhalt: T) {}
}
const b = new Box("x"); // Box<string>

interface U { id: number; name: string; mail?: string }
type A = Partial<U>;
type B = Required<U>;
type C = Readonly<U>;
type D = Pick<U, "id">;
type E = Omit<U, "id">;
type F = Record<"a" | "b", number>;

type G = Exclude<"a" | "b" | "c", "a">;
type H = Extract<string | number, number>;
type I = NonNullable<string | null>;
type J = ReturnType<() => number>;
type K = Parameters<(a: string) => void>;
type L = Awaited<Promise<number>>;

type Nullbar<T> = { [K in keyof T]: T[K] | null };
type Getter<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type IstText<T> = T extends string ? true : false;
type Element<T> = T extends (infer E)[] ? E : never;

type Ereignis = `on${Capitalize<"klick" | "fokus">}`;
type Px = `${number}px`;

abstract class Tier {
  #id = 1;              // echt privat (JS)
  private p = 0;        // nur Compiler
  protected name = "";
  readonly art: string = "Tier";
  abstract laut(): string;
}

interface Laut { laut(): string }
class Hund implements Laut {
  laut() { return "Wuff"; }
}

// npm i -D typescript
// npx tsc --init        tsconfig.json anlegen
// npx tsc               übersetzen
// npx tsc --noEmit      nur prüfen
// npx tsc -w            beobachten
// node datei.ts         Type Stripping (Node ≥ 22.18 / 23.6)
// npx tsx datei.ts      ausführen mit tsx
export {};