any, unknown, never: верх, низ и лазейка

any — отказ от проверки, и смотрите, как он расползается

any — это не «какой-то тип», это «перестань проверять это значение». Что угодно совместимо с any, и any совместим с чем угодно. Опасна вторая половина: она позволяет значению тихо втечь в позиции, требующие конкретного типа.

const data: any = JSON.parse('{"port": "oops"}');
const port: number = data.port; // ✅ ошибки нет — `any` -> number разрешено
//    ^? const port: number  — но во время выполнения это строка "oops"

port.toFixed(2); // компилируется; падает в рантайме: toFixed is not a function

Хуже того, any заразен. Прочтите свойство any, вызовите его, проиндексируйте — результат тоже any, поэтому дыра распространяется по всей цепочке вызовов:

function getUser(): any { /* ... */ }

const u = getUser();      // any
const name = u.profile;   // any  — всё ещё без проверки
const upper = name.bigify(); // any — `.bigify` не существует, но ошибки нет

Один any в источнике тихо отравляет всё ниже по течению. Поэтому any должен быть редким, локальным и намеренным — никогда не типом границы вроде распарсенного JSON-тела или нетипизированного результата библиотеки.

unknown — безопасный верхний тип

unknown — типобезопасный аналог any. Как и any, это верхний тип: всякое значение совместимо с ним. В отличие от any, со значением unknown нельзя сделать ничего, пока вы не сузите его до чего-то конкретного.

const data: unknown = JSON.parse('{"port": 8080}');

const port: number = data.port;
// Error: 'data' is of type 'unknown'.
//   Property 'port' does not exist on type 'unknown'.

if (typeof data === "object" && data !== null && "port" in data) {
  const p = data.port;
  //    ^? const p: unknown  — всё ещё unknown, пока не сужено дальше
}

unknown заставляет доказать форму до использования — через typeof, in, защитник типа или рантайм-валидатор (Zod, Valibot). Это правильный тип для всякой недоверенной границы: JSON.parse, fetch().json(), localStorage, полезные нагрузки шин сообщений. Детальная механика сужения — в следующем юните; здесь суть лишь в том, какой тип брать: unknown, не any.

never — пустой нижний тип

Когда значение доказуемо не может существовать? Чаще, чем кажется — и когда вы используете этот факт намеренно, never становится самым честным сигналом, который может вернуть функция.

never — тип без значений, пустое множество. Это нижний тип (bottom type — тип, располагающийся в самом низу решётки совместимости): совместим с любым типом, но ничто (кроме never) не совместимо с ним. Он появляется всюду, где значения доказуемо не может быть:

function fail(msg: string): never { // никогда не возвращает нормально
  throw new Error(msg);
}

function loop(): never { // никогда не завершается
  while (true) {}
}

type Impossible = string & number;
//   ^? type Impossible = never  — нет значения, которое одновременно string И number

Ценнейшее применение — проверка исчерпания (exhaustiveness). Сузив объединение до ничего, оставшийся тип — never, и его можно утвердить, чтобы вызвать ошибку компиляции, если когда-нибудь добавят новый случай:

type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; side: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.r ** 2;
    case "square": return s.side ** 2;
    default: {
      const _exhaustive: never = s; // здесь s сужено до `never`
      return _exhaustive;
    }
  }
}

Добавьте { kind: "triangle"; base: number; height: number } в Shape и забудьте обработать — и ветка default теперь видит s как этот тип треугольника, а не never, поэтому const _exhaustive: never = s выдаёт ошибку:

// Error: Type '{ kind: "triangle"; ... }' is not assignable to type 'never'.

Крошечный хелпер assertNever превращает это в однострочник, который вы кладёте в каждый default:

function assertNever(x: never): never {
  throw new Error(`Unhandled case: ${JSON.stringify(x)}`);
}
// default: return assertNever(s);

Это превращает «я забыл случай» из рантайм-сюрприза в ошибку времени компиляции — один из самых рычажных паттернов во всём языке.

Решётка совместимости

Представьте типы как решётку. unknown наверху (всё в него входит), never внизу (он входит во всё), конкретные типы посередине. any на самом деле в решётке не живёт вовсе — это боковая лазейка, одновременно и верх, и низ, что и делает его несостоятельным (unsound):