Основы вывода: как проверщик заполняет типы, которые вы не написали

Вывод из инициализатора

Когда вы объявляете переменную со значением, TypeScript выводит её тип из правой части. Но точный тип зависит от ключевого слова связывания из-за расширения (widening):

let a = "hello";
//  ^? let a: string  — `let` изменяем, поэтому литерал расширяется до базового типа

const b = "hello";
//    ^? const b: "hello"  — `const` не может измениться, литеральный тип сохраняется

Это самое важное правило вывода, которое стоит впитать. let можно переприсвоить, поэтому привязка его к литералу "hello" была бы бесполезна — TS расширяет до string. const неизменяем, поэтому точный литеральный тип "hello" и безопасен, и информативнее. То же с числами и булевыми: let n = 3 это number, const n = 3 это 3.

Свойства объекта расширяются — даже под const

Вот сюрприз, на котором спотыкаются все. const на связывании не делает содержимое неизменяемым, потому что свойства объекта изменяемы:

const config = { mode: "dark", retries: 3 };
//    ^? const config: { mode: string; retries: number }
//       НЕ { mode: "dark"; retries: 3 } — свойства расширяются
config.mode = "light"; // законно — свойство изменяемо, поэтому его тип расширен до `string`

const замораживает лишь ссылку config, а не config.mode. Поскольку свойство можно переприсвоить, TS расширяет его до string. Когда литеральные типы действительно нужно сохранить — скажем, чтобы передать в функцию, ожидающую объединение, — используйте утверждение const:

const config = { mode: "dark", retries: 3 } as const;
//    ^? const config: { readonly mode: "dark"; readonly retries: 3 }
config.mode = "light";
// Error: Cannot assign to 'mode' because it is a read-only property.

as const делает каждое свойство readonly и сохраняет его литеральный тип. Глубоко это разберём в уроке о литеральных типах; пока знайте — это лекарство, когда расширение выбрасывает информацию, которая вам была нужна.

Контекстная типизация: колбэки получают типы бесплатно

Вывод также течёт внутрь от ожидаемого типа. Когда функция ждёт колбэк, параметры колбэка типизируются из этого ожидания — вы их не аннотируете:

const names = ["ada", "alan", "grace"];
const upper = names.map((n) => n.toUpperCase());
//                       ^? (parameter) n: string
//    ^? const upper: string[]

n это string, потому что Array<string>.map объявляет свой колбэк как (value: string, ...) => U. Это контекстная типизация: позиция, в которой находится функциональный литерал, поставляет типы параметров. Поэтому DOM-обработчики тоже работают без аннотаций:

button.addEventListener("click", (e) => {
  //                                ^? (parameter) e: MouseEvent
  console.log(e.clientX);
});

Строка "click" выбирает перегрузку, чей обработчик принимает MouseEvent, и это течёт в e. Аннотация e: MouseEvent здесь — избыточный шум.

Наилучший общий тип для литералов массива

Когда вы пишете литерал массива, TypeScript вычисляет единый тип элемента — наилучший общий тип (best common type) — которому удовлетворяют все элементы:

const xs = [1, 2, 3];
//    ^? const xs: number[]

const mixed = [1, "two", 3];
//    ^? const mixed: (string | number)[]  — объединение типов элементов

Если у элементов нет общего супертипа в области видимости, TS образует их объединение. Заметьте: const на связывании не сохраняет [1,2,3] как кортеж [number, number, number] — это по-прежнему number[]; только as const даёт кортеж readonly [1, 2, 3] (разбираем в уроке о литеральных типах).

Типы возврата тоже выводятся

Вы почти никогда не аннотируете тип возврата для внутренних хелперов — TS выводит его из операторов return:

function parsePort(raw: string) {
  const n = Number(raw);
  return Number.isInteger(n) ? n : null;
}
//       ^? function parsePort(raw: string): number | null

Выведенный возврат — number | null из двух ветвей. Это отлично для локального кода — но острый инструмент на границах API.

Когда аннотировать, а когда выводить

Это вопрос, который рано или поздно ставит каждая TypeScript-кодовая база: аннотируешь лишнее — борешься с проверщиком; аннотируешь мало — теряешь контракт. Вот правило, к которому сходятся профессиональные кодовые базы:

Принцип: аннотируйте границы, выводите внутренности. Явные типы возврата экспортируемых функций — аннотации наивысшей ценности: они делают контракт намеренным и ловят случайное расширение при рефакторинге тела.