Kdy byste měli v TypeScript používat typy a kdy…

Typy (type) by měly být používány pro:

Unie (sjednocení) a průniky (průniky):

type Status = "pending" | "completed" | "failed";
type UserWithAddress = User & Address;

Primitivní typy a literály:

type ID = string | number;
type Direction = "up" | "down" | "left" | "right";

Tuply (tuples):

type RgbColor = [number, number, number];

Vytváření aliasů pro existující typy:
```
type StringOrNumber = string | number;
```

Podmíněné typy (conditional types):

type TypeOfProp<T, K extends keyof T> = T[K];

Rozhraní (interface) by měly být používány pro:

Popis struktury objektů:

interface User {
  id: number;
  name: string;
  age?: number; // volitelná vlastnost
}

Implementace třídami (implements):

interface Logger {
  log(message: string): void;
}

class ConsoleLogger implements Logger {
  log(message: string) {
    console.log(message);
  }
}

Rozšíření jiných rozhraní (extends):

interface Person {
  name: string;
}

interface Employee extends Person {
  employeeId: number;
}

Deklarativní slučování (declaration merging): To umožňuje rozšířit existující rozhraní jeho opětovným oznámením. S typy to není možné.
```
interface Box {
  width: number;
}

interface Box { // To přidá vlastnost height k rozhraní Box
  height: number;
}
```

Stručné srovnání:

Vlastnost	`type`	`interface`
Unie typy	Ano	Ne
Průnikové typy	Ano	Ne
Primitivní typy/literály	Ano	Ne
Tuply	Ano	Ne
Aliasy typů	Ano	Ne
Podmíněné typy	Ano	Ne
Popis objektů	Ano	Ano
Implementace třídami	Ne	Ano
Rozšíření	Ano (`&` použití)	Ano (`extends` použití)
Deklarativní slučování	Ne	Ano

Obecně platí, že pro popis struktury objektů je vhodnější používat interface, protože lépe odpovídá objektově orientovanému přístupu a podporuje deklarativní slučování. Pro ostatní případy, zejména pro kombinace a tvorbu nových typů z existujících, je flexibilnější type.

Kdy byste měli v TypeScript používat typy a kdy rozhraní?