Литеральные типы: одиночные значения как типы и as const, который их хранит

Одно значение, используемое как тип

Каждое примитивное значение может быть и типом: "GET" — это тип, чей единственный обитатель — строка "GET". Так же 200, true, 42n. Сами по себе они редко полезны — но как объединения становятся точными, самодокументирующимися доменами:

type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
type StatusCode = 200 | 201 | 400 | 404 | 500;
type Toggle = true | false; // т.е. boolean

function request(method: HttpMethod, url: string) { /* ... */ }

request("GET", "/users");   // ✅
request("PATCH", "/users"); // Error: Argument of type '"PATCH"' is not
//                          //   assignable to parameter of type 'HttpMethod'.

Объединение литералов — замкнутое множество, которое проверщик принуждает, а редактор автодополняет. Это самый частый «enum» в современном TypeScript — и у него нулевой рантайм-след.

Расширение, снова: откуда берутся литералы и где теряются

Вы встретили расширение в уроке о выводе. Литералы — ровно то, что расширение выбрасывает. Решает ключевое слово связывания:

let m = "GET";
//  ^? let m: string  — `let` расширяет; литерал утрачен

const m2 = "GET";
//    ^? const m2: "GET"  — `const` хранит литерал

Так что const уже даёт литерал для примитивов. Ловушка — объекты, куда const не дотягивается до свойств:

const config = { method: "GET" };
//    ^? const config: { method: string }  — свойство расширено до string

request(config.method, "/x");
// Error: Argument of type 'string' is not assignable to parameter of type 'HttpMethod'.

Вот в точности баг из Hook: config.method расширился до string, потому что свойство изменяемо, поэтому больше не входит в объединение HttpMethod. Такова цена встречи структурной типизации с расширением.

as const: глубоко, readonly, литерально

Лекарство — утверждение const. as const делает над своим операндом сразу три вещи: делает каждое свойство readonly, не даёт расширения (хранит литеральные типы) и превращает литералы массивов в кортежи вместо массивов.

const config = { method: "GET", retries: 3 } as const;
//    ^? const config: { readonly method: "GET"; readonly retries: 3 }

request(config.method, "/x"); // ✅ теперь config.method это литерал "GET"

Смотрите, как оно работает сверху донизу на вложенных данных, массивах и кортежах:

const before = ["a", "b"];
//    ^? const before: string[]

const after = ["a", "b"] as const;
//    ^? const after: readonly ["a", "b"]  — readonly-кортеж литералов

const route = { path: "/users", methods: ["GET", "POST"] } as const;
//    ^? const route: {
//         readonly path: "/users";
//         readonly methods: readonly ["GET", "POST"];
//       }

Без as const methods был бы string[]; с ним — точный кортеж readonly ["GET", "POST"]. Это движок «конфиг-как-типы»: напишите обычный объектный литерал, добавьте as const и выводите типы прямо из рантайм-значения (typeof config, config["methods"][number]) — единый источник истины, без дублирования.

Когда расширение кусает — и лекарство

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

type Level = "debug" | "info" | "warn" | "error";

function setLevel(l: Level) { /* ... */ }

const settings = { level: "warn" };
setLevel(settings.level);
// Error: Argument of type 'string' is not assignable to parameter of type 'Level'.

// Лекарства (выберите одно):
const settings2 = { level: "warn" as const };      // сузить одно свойство
const settings3 = { level: "warn" } as const;      // сузить весь объект
const settings4 = { level: "warn" as Level };       // аннотировать к целевому объединению

Любое из них сохраняет level достаточно точным, чтобы удовлетворить Level. Общий урок: когда строите данные, предназначенные для слота с объединением литералов, надо остановить расширение — либо as const, либо типизацией переменной прямо к объединению.

Объединения литералов против enum

Прежде чем тянуться к enum, спросите себя: нужно ли это значение как рантайм-объект, или вы просто хотите, чтобы проверщик отвергал всё вне известного множества? Чаще всего — второе, и ровно это делают объединения литералов при нулевой рантайм-цене. Вот как они сравниваются:

Команды предпочитают объединения as const, потому что у них нет рантайм-цены, они сериализуются прозрачно (API шлёт "GET", а не непрозрачный слот enum) и остаются структурными — обычный "GET" откуда угодно просто подходит. enum всё ещё уместен для битовых флагов или когда нужен замкнутый объект-пространство имён в рантайме, но это уже не дефолтный выбор.