ITМоя статистика
Тест по TypeScript
210 вопросов по TypeScript в 14 темах (Junior — 81, Middle — 86, Senior — 43). Выберите темы, уровень и количество вопросов — к каждому ответу есть объяснение.
Типы и интерфейсы, union и narrowing, дженерики, utility types, классы, модули и настройки компилятора.
Все вопросы по TypeScript 210
Нажмите на вариант ответа, чтобы проверить себя, или «Показать ответ».
Базовые типы14
Чем отличаются типы
string[] и Array<string>?Array<string>допускает «дыры» иundefined, аstring[]— нетstring[]— неизменяемый массив,Array<string>— изменяемыйstring[]существует только приstrict,Array<string>— всегда- Ничем: это один и тот же тип, записанный двумя способами
T[] — просто сокращённая запись для Array<T>, компилятор считает их полностью идентичными. Неизменяемый вариант пишется отдельно: readonly string[] или ReadonlyArray<string>.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?const tags: readonly string[] = ['ts'];
tags.push('js');- Компилируется, но в рантайме будет TypeError
- Ошибка:
constнельзя использовать сreadonly - Ошибка: у
readonly string[]нет методаpush - Компилируется,
readonlyзапрещает только переприсваиваниеtags
Тип
readonly string[] (он же ReadonlyArray<string>) просто не содержит мутирующих методов (push, splice, sort…), поэтому ошибка будет «Property 'push' does not exist». При этом в рантайме массив обычный — readonly существует только на уровне типов.Какая строка НЕ компилируется (TypeScript 5.6,
strict: true)?const a: String = 'text'; // 1
const b: string = new String('text'); // 2
const c: string = String(42); // 3- 1
- 2
- 3
- Все компилируются
string — примитивный тип, а String — тип объекта-обёртки. Примитив можно присвоить в String (у него есть все методы обёртки), но объект new String(...) в string — нельзя. String(42) без new возвращает примитив. В аннотациях всегда используют string, number, boolean с маленькой буквы.Какие типы выведет TypeScript для
a и b?const a = Symbol('id');
let b = Symbol('id');- Оба
symbol a: typeof a(unique symbol),b: symbola: symbol,b: unique symbol- Оба
unique symbol
Для
const, инициализированной вызовом Symbol(), TS выводит особый тип unique symbol (отображается как typeof a): он равен только этому конкретному символу и пригоден как ключ в типах объектов. Для let значение может измениться, поэтому тип расширяется до symbol.Какая строка НЕ компилируется (TypeScript 5.6,
strict: true)?type A = { name?: string };
type B = { name: string | undefined };
const a1: A = {}; // 1
const a2: A = { name: undefined }; // 2
const b1: B = {}; // 3
const b2: B = { name: undefined }; // 4- Строка 2
- Строка 3
- Строка 4
- Все строки компилируются
name?: string означает «свойство может отсутствовать», а name: string | undefined — «свойство обязано быть, но может хранить undefined». Поэтому {} подходит для A, но не для B. Запись { name: undefined } для A разрешена, пока не включён exactOptionalPropertyTypes.В tsconfig включены
strict и exactOptionalPropertyTypes. Какой вызов update компилируется?type Patch = { nick?: string };
function update(p: Patch) {}
declare const nick: string | undefined;update({ nick })update({ nick: nick ?? undefined })update(nick === undefined ? {} : { nick })update({ nick: nick?.trim() })
С
exactOptionalPropertyTypes у nick?: string значение строго string: ключ можно опустить, но нельзя передать undefined явно. Во всех остальных вариантах значение имеет тип string | undefined, поэтому компилируется только вариант, где при отсутствии значения ключа просто нет. Альтернатива — объявить nick?: string | undefined.Какое значение НЕЛЬЗЯ присвоить переменной типа
object?[]() => {}new Date()42
Тип
object (с маленькой буквы) описывает любое НЕпримитивное значение: объекты, массивы, функции, даты. Числа, строки, boolean, symbol, bigint, null и undefined в него не входят.Какое значение НЕЛЬЗЯ присвоить переменной типа
Px (TypeScript 5.6, strict: true)?type Px = `${number}px`;"px""10px""1.5px""-3px"
Шаблонный литеральный тип
${number}px описывает строки, которые начинаются с записи числа и заканчиваются на px. Дробные и отрицательные числа подходят, а в "px" числа нет вовсе. Это проверка только на этапе компиляции — для данных из рантайма всё равно нужна валидация.Почему эта строка не компилируется (
target: ES2020)?let big: bigint = 10;- Тип
bigintпишется с большой буквы:BigInt - Переменные
bigintможно объявлять только черезconst bigintне поддерживается в TypeScript10— этоnumber, а дляbigintнужен литерал10nилиBigInt(10)
number и bigint — разные, несовместимые примитивные типы, и автоматического преобразования нет. Литерал bigint записывается с суффиксом n (10n); он требует target не ниже ES2020.Какой тип у
city (TypeScript 5.6, strict: true)?type User = { address?: { city: string } };
declare const user: User;
const city = user.address?.city;string | nullstringstring | undefinedstring | null | undefined
Опциональная цепочка
?. возвращает undefined, если address отсутствует, поэтому к типу city добавляется undefined (но не null — ?. всегда даёт именно undefined). Без ?. обращение user.address.city при strict было бы ошибкой «possibly undefined».Что верно про строку
let s: string = null;?- Компилируется только при
strict: true - Ошибка при
strictNullChecks(входит вstrict); без этого флага компилируется - Всегда компилируется:
nullвходит в любой тип - Всегда ошибка, независимо от настроек
Со
strictNullChecks значения null и undefined — отдельные типы, и их нужно явно добавлять: string | null. Без флага они неявно входят в каждый тип, из-за чего TS не ловит обращения к null.Какой тип у
cfg и что произойдёт на второй строке (TypeScript 5.6, strict: true)?const cfg = Object.freeze({ mode: 'dev', port: 80 });
cfg.port = 8080;Readonly<{ mode: "dev"; port: 80 }>, ошибка компиляции:portтолько для чтенияReadonly<{ mode: string; port: number }>, ошибка только в рантаймеobject, ошибка: свойстваportнет в типеobject{ mode: string; port: number }, присваивание компилируется
Типизация
Object.freeze в стандартной библиотеке возвращает Readonly<T> и при этом сохраняет литеральные типы примитивных свойств — объект ведь уже не изменится. Поэтому TS ловит присваивание на этапе компиляции (ошибка 2540). В рантайме в нестрогом режиме JS такое присваивание молча игнорируется, а в strict mode бросает TypeError.Что произойдёт (TypeScript 5.6,
strict: true)?const nums: number[] = [1, 2];
const items: (number | string)[] = nums;
items.push('three');
console.log(nums.length, typeof nums[2]);- Выведет
2 undefined - Ошибка компиляции во второй строке
- Ошибка компиляции в
items.push('three') - Выведет
3 string
Массивы в TS ковариантны:
number[] можно присвоить в (number | string)[], хотя это не строго безопасно. Обе переменные указывают на один массив, поэтому в nums: number[] в рантайме оказывается строка — известная намеренная «дыра» в системе типов.Какой тип у
Cls?type Size = 'sm' | 'lg';
type Color = 'red' | 'blue';
type Cls = `${Size}-${Color}`;string'sm-red' | 'lg-blue'- Ошибка компиляции: объединения нельзя подставлять в шаблонный тип
'sm-red' | 'sm-blue' | 'lg-red' | 'lg-blue'
Шаблонные литеральные типы распределяются по объединениям в каждой подстановке: получается декартово произведение всех вариантов, то есть 2 × 2 = 4 строковых литерала. Так удобно описывать, например, имена CSS-классов или событий; но с большими объединениями число вариантов быстро растёт.
Вывод типов13
Какие типы выведет TypeScript для
a и b?const a = 'hello';
let b = 'hello';a: "hello",b: "hello"a: string,b: "hello"a: "hello",b: stringa: string,b: string
const нельзя переприсвоить, поэтому TS сохраняет литеральный тип "hello". Для let тип расширяется (widening) до string, ведь позже туда можно записать другую строку.Почему вызов
area(c) не компилируется (TypeScript 5.6, strict: true)?type Circle = { kind: 'circle'; r: number };
function area(s: Circle) { return Math.PI * s.r ** 2; }
const c = { kind: 'circle', r: 1 };
area(c);- Свойства объекта
constдоступны только для чтения - Свойство
c.kindвыведено какstring, а не"circle" - У
areaне указан тип возвращаемого значения r: 1выведено как литерал1, а неnumber
const фиксирует только саму переменную, а свойства объекта можно менять, поэтому литерал 'circle' расширяется до string. Исправления: as const, аннотация const c: Circle = ... или satisfies Circle.Какой тип у
cfg.hosts?const cfg = { port: 8080, hosts: ['a', 'b'] } as const;readonly ["a", "b"]string[]readonly string[]("a" | "b")[]
as const действует рекурсивно: все свойства становятся readonly, литералы не расширяются, а массивы превращаются в readonly-кортежи. Поэтому получаем readonly ["a", "b"], а port — литерал 8080.Какой тип выведет TypeScript для
arr?const arr = [1, 'a', true];readonly [1, "a", true]any[][number, string, boolean](string | number | boolean)[]
Для массивного литерала TS выводит массив, тип элемента которого — объединение типов всех элементов (литералы расширены). Кортеж получится только при явной аннотации или
as const.Какой тип выведет TypeScript для
rows?const rows = [{ x: 1 }, { x: 2, y: 'b' }];{ x: number; y: string }[]({ x: number } | { x: number; y: string })[]({ x: number; y?: undefined } | { x: number; y: string })[]{ x: number; y?: string }[]
При выводе типа из нескольких объектных литералов TS нормализует их: в варианты без свойства добавляется
y?: undefined. Благодаря этому rows[0].y можно читать без ошибки (тип string | undefined), а объединение остаётся точным.Какой тип возвращаемого значения выведет TypeScript для
f?function f(n: number) {
if (n > 0) return 'pos';
return 0;
}string | number"pos" | 0anystring
Если функция возвращает несколько разных литералов, выводится их объединение без расширения:
"pos" | 0. А вот единственный литерал расширяется: у function g() { return 'pos'; } тип результата — string.Какие типы выведет TypeScript для
b и d?const a = 'x';
let b = a;
const c: 'x' = 'x';
let d = c;b: string,d: "x"b: "x",d: "x"b: string,d: stringb: "x",d: string
У
a выведен «расширяемый» литеральный тип: при копировании в let он расширяется до string. У c литерал "x" указан явно — он нерасширяемый, поэтому d остаётся "x".Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?const onMove: (e: { x: number }) => void = (e) => {
console.log(e.y);
};- Компилируется,
e.yимеет типundefined - Ошибка: параметр
eнеявно имеет типany - Компилируется,
eимеет типany - Ошибка: свойства
yнет в типе{ x: number }
Это контекстная типизация: тип параметра
e берётся из аннотации переменной, поэтому e — { x: number }, а не any, и обращение к e.y ошибочно. По той же причине не нужно аннотировать параметры колбэков в arr.map(...).Какие типы у
a и b (TypeScript 5.6, strict: true)?let x;
x = 1;
const a = x;
x = 'str';
const b = x;a: any,b: anya: number,b: numbera: number,b: string- Ошибка:
xнеявно имеет типany
let x; без инициализатора и аннотации — «эволюционирующий any»: TS отслеживает присваивания и в каждой точке знает фактический тип. Ошибки noImplicitAny здесь нет, она появится, только если читать x там, где тип определить нельзя (например, в замыкании).Какой вариант компилируется (TypeScript 5.6,
strict: true)?type Palette = Record<string, string | number[]>;
// A
const p1: Palette = { red: [255, 0, 0], green: '#0f0' };
p1.green.toUpperCase();
// B
const p2 = { red: [255, 0, 0], green: '#0f0' } satisfies Palette;
p2.green.toUpperCase();- Оба
- Только A
- Только B
- Ни один
Аннотация
: Palette заменяет выведенный тип: p1.green становится string | number[], и у него нет toUpperCase. satisfies проверяет совместимость, но сохраняет выведенный тип, поэтому p2.green — string.Что верно про этот код (TypeScript 5.6,
strict: true)?const ids = [1, 2];
ids.push(3);
ids = [4];- Ошибка только в
ids = [4]: переменнуюconstнельзя переприсвоить - Ошибки в обеих строках
- Компилируется:
constдля массивов ничего не запрещает - Ошибка в
ids.push(3): массивconstнеизменяем
const запрещает переприсваивание переменной, но не изменение самого массива: ids имеет тип number[], и push допустим. Неизменяемый массив дают readonly number[] или as const.Какие типы выведет TypeScript для
a и b?const a = Math.random() > 0.5 ? 'yes' : 1;
let b = Math.random() > 0.5 ? 'yes' : 1;a: "yes" | 1,b: "yes" | 1a: any,b: anya: string | number,b: string | numbera: "yes" | 1,b: string | number
Тернарный оператор даёт объединение типов обеих ветвей. Для
const литералы сохраняются — "yes" | 1, а для let каждый литерал расширяется до своего базового типа, получается string | number. Правило то же, что и для одиночного литерала.Какой тип у
last (TypeScript 5.6, strict: true)?const names = ['a', 'b', 'c'];
const last = names.find(n => n.startsWith('z'));"a" | "b" | "c" | undefinedstringstring | undefinedstring | null
Array.prototype.find объявлен как возвращающий T | undefined — элемент может не найтись. Литералов "a" | "b" | "c" нет, потому что массив выведен как string[].Объединения и пересечения14
Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?function shout(x: string | number) {
return x.toUpperCase();
}- Компилируется: для чисел вернётся
undefined - Ошибка:
toUpperCaseнет у типаnumber, а значит и уstring | number - Компилируется: TS сам приведёт число к строке
- Ошибка: функция должна явно указывать тип возврата
У значения объединённого типа можно использовать только то, что есть у КАЖДОГО члена объединения.
toUpperCase есть только у string, поэтому сначала нужно сузить тип, например typeof x === 'string'.Какое обращение к
x компилируется (TypeScript 5.6, strict: true)?type A = { a: number; common: string };
type B = { b: number; common: string };
function f(x: A | B) {
// ???
}x.ax.bx.common- Ни одно, пока тип не сужен
Через значение типа
A | B доступны только общие свойства — здесь common. a есть только в A, b — только в B; к ним можно обратиться после сужения, например 'a' in x.Во что превращается тип
string & number?unknownstringstring | numbernever
Пересечение означает «значение одновременно обоих типов». Не существует значения, которое одновременно строка и число, поэтому результат —
never, и TS сразу упрощает его.Какой тип у
C['id']?type A = { id: string; name: string };
type B = { id: number };
type C = A & B;stringnumberneverstring | number
При пересечении объектных типов свойства с одинаковым именем тоже пересекаются:
string & number = never. Сам C при этом не схлопывается в never, но создать значение такого типа невозможно — свойству id нечего присвоить.Во что превращается тип
C?type A = { kind: 'a'; value: number };
type B = { kind: 'b'; value: number };
type C = A & B;{ kind: never; value: number }never{ kind: "a" | "b"; value: number }A | B
Если в пересечении конфликтуют свойства литеральных типов (дискриминанты), TS (начиная с 3.9) сводит ВЕСЬ тип к
never: такой объект заведомо невозможен. Для нелитеральных конфликтов вроде string & number в never превращается только само свойство.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?type Cat = { meow(): void };
type Dog = { bark(): void };
const pet: Cat | Dog = { meow() {}, bark() {} };- Компилируется
- Ошибка: лишнее свойство
barkдляCat - Ошибка: объект не может быть одновременно
CatиDog - Ошибка: для объединения нужно явное
as Cat
Значение подходит под
Cat (структурно), а проверка лишних свойств для объединения считает «известными» свойства всех его членов, поэтому bark не лишнее. Объединение — это «хотя бы один из», а не «ровно один из».Какой тип получится?
type Status = 'ok' | 'error' | string;never"ok" | "error""ok" | "error" | string— литералы сохраняютсяstring
Литералы
"ok" и "error" — подтипы string, поэтому объединение поглощается до string (и автодополнение литералов в редакторе пропадает). Известный обходной приём — 'ok' | 'error' | (string & {}).Какое объявление НЕ компилируется (TypeScript 5.6,
strict: true)?const a: (string | number)[] = [1, 'x']; // 1
const b: string[] | number[] = [1, 2]; // 2
const c: string[] | number[] = [1, 'x']; // 3
const d: (string | number)[] = []; // 4- 1
- 2
- 3
- 4
(string | number)[] — массив, где каждый элемент может быть строкой или числом, смешивание допустимо. string[] | number[] — либо целиком массив строк, либо целиком массив чисел, поэтому [1, 'x'] в него не подходит.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?type HasId = { id: number };
type HasName = { name: string };
const x: HasId & HasName = { id: 1 };- Компилируется: достаточно свойств одного из типов
- Ошибка: отсутствует свойство
name - Ошибка: пересечение объектов всегда
never - Компилируется,
nameполучит значениеundefined
Пересечение объектных типов требует все свойства обоих типов сразу:
{ id: number; name: string }. «Достаточно одного из» — это поведение объединения |.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?function print(x: string | number) {}
let v: string | number | boolean = 'hi';
print(v);- Компилируется: после присваивания тип
vсужен доstring - Компилируется, только если объявить
vчерезconst - Ошибка: нужно явно привести
v as string - Ошибка:
booleanне подходит подstring | number
Присваивание сужает тип: объявленный тип
v — объединение, но анализ потока управления знает, что сейчас там string. Ошибка появилась бы, если бы TS не мог доказать тип, например после присваивания значения типа boolean.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?type F = ((x: string) => void) | ((x: number) => void);
declare const f: F;
f('text');- Ошибка: объединение функций вызывать нельзя вообще
- Компилируется:
stringподходит под первый вариант - Компилируется: параметр имеет тип
string | number - Ошибка: аргумент должен иметь тип
string & number, то естьnever
Неизвестно, какая из функций лежит в
f, поэтому безопасен только аргумент, подходящий ОБЕИМ: параметры объединения функций пересекаются — string & number = never. Вызвать f можно только после сужения.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?type Action =
| { type: 'add'; payload: number }
| { type: 'reset'; payload: undefined };
function reduce({ type, payload }: Action) {
if (type === 'add') {
return payload.toFixed(2);
}
return 'reset';
}- Компилируется, только если заменить
ifнаswitch - Ошибка:
payloadвозможноundefined— после деструктуризации связь сtypeтеряется - Компилируется: TS сужает
payloadпо проверке деструктурированного дискриминанта - Ошибка: дискриминированное объединение нельзя деструктурировать в параметрах
Начиная с TS 4.6 сужение работает и для деструктурированных дискриминированных объединений: проверка
type === 'add' сужает связанную переменную payload до number. Условие — переменные из деструктуризации не переприсваиваются (параметры или const). В старых версиях действительно была ошибка «possibly undefined».Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?type Size = 's' | 'm' | 'l';
const size: Size = 'xl';- Ошибка только в рантайме
- Ошибка:
"xl"не входит в объединениеSize - Компилируется:
Size— это простоstring - Компилируется с предупреждением
Объединение строковых литералов описывает конечный набор допустимых значений, и
"xl" в него не входит. Это лёгкая альтернатива enum, которая полностью стирается при компиляции.Чему равны
T и U?type T = Exclude<'a' | 'b' | 'c', 'a' | 'c'>;
type U = Extract<'a' | 'b' | 'c', 'a' | 'd'>;T = 'b',U = 'a'T = 'b',U = 'a' | 'd'T = 'a' | 'c',U = 'b' | 'c'T = never,U = 'a'
Exclude<T, U> оставляет члены объединения T, которые НЕ присваиваются U: из 'a' | 'b' | 'c' убираются 'a' и 'c', остаётся 'b'. Extract<T, U> — наоборот, оставляет только члены T, присваиваемые U: 'd' в исходном объединении нет, поэтому результат — 'a'.Сужение типов17
Что выведет этот код после компиляции?
function fmt(x: string | number) {
if (typeof x === 'string') return x.length;
return x.toFixed(1);
}
console.log(fmt('abc'), fmt(3.14159));3 3.1abc 3.13 3.14159- Ошибка компиляции: разные типы возврата
Проверка
typeof x === 'string' сужает x до string внутри if, а после return оставшийся тип — number. Функция возвращает number | string, что допустимо: тип результата выводится как объединение.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?function count(x: string[] | null) {
if (typeof x === 'object') {
return x.length;
}
return 0;
}- Ошибка:
typeofнельзя применять к массивам - Компилируется, но всегда возвращает 0
- Компилируется: внутри
ifтипx—string[] - Ошибка:
xвозможноnull, ведьtypeof null === "object"
TS знает о JS-странности
typeof null === "object", поэтому после такой проверки x имеет тип string[] | null. Правильно проверять x !== null или просто if (x).Что выведет этот код после компиляции?
function fmt(n?: number) {
if (n) return 'n=' + n;
return 'нет значения';
}
console.log(fmt(0));- Ошибка компиляции
n=0нет значенияn=undefined
Проверка на истинность отсекает не только
undefined, но и 0, "", NaN — они ложные. TS это не ловит, ведь код корректен по типам. Чтобы отличать «нет значения» от нуля, пишут n !== undefined или n != null.Какой тип у
s внутри блока if (TypeScript 5.6, strict: true)?function f(s: string | undefined) {
if (!s) {
// s: ?
}
}undefinedstring | undefinednever""
В ложную ветку попадает и
undefined, и пустая строка "", поэтому тип остаётся string | undefined (TS не сужает string до литерала ""). Считать, что после !s там только undefined, — частая ошибка.Какой тип у
a в ветке else (TypeScript 5.6, strict: true)?type Fish = { swim(): void };
type Bird = { fly(): void };
function move(a: Fish | Bird) {
if ('swim' in a) a.swim();
else { /* a: ? */ }
}BirdneverFishFish | Bird
Оператор
in сужает объединение: в ветке true остаются члены, где есть свойство swim (Fish), в else — где его нет (Bird). Удобно для объединений без общего поля-дискриминанта.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?function year(d: Date | string) {
if (d instanceof Date) return d.getFullYear();
return d.slice(0, 4);
}- Ошибка: строку нельзя проверять через
instanceof - Ошибка:
instanceofне сужает типы - Ошибка: у
stringнетgetFullYear - Компилируется:
instanceofсужает доDate, в остальном коде остаётсяstring
instanceof проверяет цепочку прототипов в рантайме и сужает тип: внутри if — Date, после return — оставшийся string. Работает с классами и конструкторами, но не с интерфейсами и type — их в рантайме нет.Какой тип у
a внутри if (TypeScript 5.6, strict: true)?function f(a: string | number, b: string | boolean) {
if (a === b) {
// a: ?
}
}neverstring | numberstringstring | number | boolean
Строгое равенство сужает обе стороны до общего типа: значения могут совпасть, только если оба — строки. Поэтому и
a, и b внутри if имеют тип string.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?type Shape =
| { kind: 'circle'; r: number }
| { kind: 'square'; a: number }
| { kind: 'tri'; h: number };
function area(s: Shape): number {
switch (s.kind) {
case 'circle': return Math.PI * s.r ** 2;
case 'square': return s.a ** 2;
default:
const unreachable: never = s;
return unreachable;
}
}- Компилируется, для
triвернётсяundefined - Ошибка: в
defaultтипs—{ kind: "tri"; h: number }, его нельзя присвоитьnever - Ошибка: переменную типа
neverнельзя объявить - Компилируется, для
triбросится исключение
Это проверка исчерпываемости: после обработанных
case в default остаётся необработанный вариант tri, и присваивание его в never даёт ошибку компиляции. Когда все варианты обработаны, s в default становится never, и ошибка исчезает — так TS напоминает о новых членах объединения.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?let title: string | null = Math.random() > 0.5 ? 'Hi' : null;
if (title !== null) {
setTimeout(() => console.log(title.length));
}
title = null;- Ошибка:
titleвозможноnullвнутри колбэка - Ошибка:
setTimeoutнельзя вызывать внутриif - Компилируется, т.к. начиная с TS 5.4 сужение всегда сохраняется в замыканиях
- Компилируется: внутри
ifтип сужен доstring
Колбэк выполнится позже, а после него в коде есть присваивание
title = null, поэтому TS сбрасывает сужение внутри замыкания. С TS 5.4 сужение сохраняется в замыканиях, только если после их создания переменная больше не переприсваивается; без строки title = null код бы скомпилировался.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?type Box = { v: string | number };
function f(b: Box) {
if (typeof b.v === 'string') {
const s: { v: string } = b;
}
}- Ошибка:
typeofнельзя применять к свойствам - Компилируется только с
as const - Компилируется:
bсужен до{ v: string } - Ошибка: сужение
b.vне сужает тип самого объектаb
Проверка
typeof b.v сужает только выражение b.v (внутри if оно string), но тип b остаётся Box. Сам объект сужается лишь у дискриминированных объединений, где проверяется литеральное поле-дискриминант.Какой тип у
x внутри if (TypeScript 5.6, strict: true)?function f(x: string | null | undefined) {
if (x != null) {
// x: ?
}
}string | null | undefinedstring | undefinedstringstring | null
Нестрогое сравнение
!= null исключает и null, и undefined (undefined == null истинно), и TS это учитывает. Со строгим !== null остался бы string | undefined.Что произойдёт (TypeScript 5.6,
strict: true)?function isString(x: unknown): x is string {
return typeof x === 'number';
}
const v: unknown = 42;
if (isString(v)) {
console.log(v.toUpperCase());
}- Компилируется и ничего не выводит
- Ошибка компиляции: тело не соответствует предикату
x is string - Компилируется и выводит
42 - Компилируется, но в рантайме падает с TypeError
TS не проверяет, что тело пользовательского type guard действительно соответствует предикату
x is string — он просто верит функции. Здесь она возвращает true для числа, v считается строкой, и v.toUpperCase() падает в рантайме. Ошибка в guard — это молчаливая дыра в типизации.Какой тип у
p в ветке else (TypeScript 5.6, strict: true)?type Fish = { swim(): void };
type Bird = { fly(): void };
function isFish(p: Fish | Bird): p is Fish {
return 'swim' in p;
}
function move(p: Fish | Bird) {
if (isFish(p)) p.swim();
else { /* p: ? */ }
}unknownFish | BirdBirdnever
Пользовательский type guard с возвращаемым типом
p is Fish сужает аргумент в обе стороны: в ветке true — до Fish, в else — до оставшегося Bird. Если бы функция возвращала просто boolean, сужения не было бы вообще.Какой тип у
ids (TypeScript 5.6, strict: true)?const raw = [1, null, 2, null, 3];
const ids = raw.filter(x => x !== null);(number | null)[]number[]any[](number | undefined)[]
Начиная с TS 5.5 компилятор сам выводит предикат типа
x is number для простых стрелочных функций вроде x => x !== null, и перегрузка filter с предикатом возвращает number[]. В более старых версиях получался (number | null)[], и предикат приходилось писать явно.Какой тип у
x после вызова assert(...) (TypeScript 5.6, strict: true)?function assert(cond: unknown, msg?: string): asserts cond {
if (!cond) throw new Error(msg);
}
function f(x: string | number) {
assert(typeof x === 'string', 'нужна строка');
// x: ?
}stringneverbooleanstring | number
Функция-утверждение с сигнатурой
asserts cond сообщает TS: если вызов вернул управление, условие истинно. Поэтому дальше по коду x сужен до string. В отличие от type guard, её не нужно оборачивать в if — она либо проходит, либо бросает исключение.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?const assertStr = (v: unknown): asserts v is string => {
if (typeof v !== 'string') throw new Error();
};
declare const input: unknown;
assertStr(input);- Компилируется, но
inputостаётсяunknown - Компилируется, после вызова
inputимеет типstring - Ошибка: стрелочные функции не могут иметь
assertsв типе возврата - Ошибка: для вызова функции-утверждения её имя должно быть объявлено с явной аннотацией типа
Объявить стрелочную функцию-утверждение можно, но вызывать через переменную с выведенным типом нельзя: ошибка 2775 «Assertions require every name in the call target to be declared with an explicit type annotation». Исправление — аннотировать саму переменную:
const assertStr: (v: unknown) => asserts v is string = ... или использовать function.Какой тип у
x в ветке else (TypeScript 5.6, strict: true)?function norm(x: string | string[]) {
if (Array.isArray(x)) {
return x;
} else {
return [x]; // x: ?
}
}stringstring | string[]string[]any
Array.isArray объявлен как type guard (arg is any[]), поэтому в ветке if из объединения остаётся массив string[], а в else — всё остальное, то есть string. Так удобно принимать «одно значение или массив» и сразу приводить его к массиву.any, unknown и never15
Какая строка НЕ компилируется (TypeScript 5.6,
strict: true)?let a: any = 'text';
let u: unknown = 'text';
a.length; // 1
u.length; // 2
a.foo(); // 3- Только 2
- Только 3
- 2 и 3
- Все компилируются
any отключает проверку типов: с ним можно делать что угодно, даже вызывать несуществующий foo() (упадёт уже в рантайме). unknown — безопасная альтернатива: перед любым использованием значение нужно сузить (typeof, instanceof, type guard).Что выведет этот код после компиляции (TypeScript 5.6,
strict: true)?const data: any = 'abc';
const n: number = data;
console.log(typeof n);numberstringNaN- Ошибка компиляции
any можно присвоить в переменную любого типа без проверок, а аннотации типов при компиляции стираются и ничего не преобразуют. В рантайме n по-прежнему строка 'abc', хотя TS считает её number.Какое присваивание компилируется (TypeScript 5.6,
strict: true)?let u: unknown = 1;
let a: any = u; // 1
let s: string = u; // 2
let o: object = u; // 3
let n: number = u; // 4- 1
- 2
- 3
- 4
В
unknown можно записать что угодно, но сам unknown присваивается только в unknown и any. Чтобы получить number, нужно сначала сузить: if (typeof u === 'number') n = u;.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?const x: any = 1;
const n: never = x;- Ошибка: переменную типа
neverнельзя объявлять - Компилируется,
nполучит типany - Компилируется:
anyприсваивается во что угодно - Ошибка:
anyнельзя присвоить вnever
any совместим почти со всем, но есть исключение: в never нельзя присвоить ничего, кроме самого never, даже any. Именно поэтому проверка исчерпываемости const _: never = x надёжна, даже если x случайно оказался any.Какие типы возвращаемого значения выведет TypeScript для
a и b?function a() {
throw new Error('fail');
}
const b = () => {
throw new Error('fail');
};- Обе
never - Обе
void a: void,b: nevera: never,b: void
Для объявления функции (
function) без достижимого конца TS всё равно выводит void — из соображений совместимости (такую функцию часто переопределяют). Для функциональных выражений и стрелок выводится never. Если нужен never у объявления, его указывают явно: function a(): never.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?function save(): void {}
const r = save();
if (r) {
console.log('saved');
}- Компилируется,
ifникогда не выполнится - Ошибка: выражение типа
voidнельзя проверять на истинность - Компилируется,
rимеет типundefined - Ошибка: результат
void-функции нельзя присваивать в переменную
void означает «возвращаемое значение не используется», а не «возвращает undefined», поэтому TS запрещает проверять его на истинность (ошибка 1345). Сохранить результат в переменную можно — она получит тип void.Во что упрощаются эти типы?
type A = string | never;
type B = string & unknown;
type C = string | unknown;
type D = string | any;A: string,B: string,C: unknown,D: anyA: never,B: unknown,C: string,D: stringA: string,B: unknown,C: unknown,D: anyA: never,B: string,C: unknown,D: string
never — пустое множество: в объединении исчезает, а в пересечении поглощает всё. unknown — множество всех значений: в пересечении исчезает, в объединении поглощает всё. any поглощает объединение целиком.Какая строка НЕ компилируется (TypeScript 5.6,
strict: true)?const a = 'hello' as number; // 1
const b = 'hello' as unknown as number; // 2
const c = 'hello' as string | number; // 3
const d = { x: 1 } as { x: number; y: number }; // 4- 1
- 2
- 3
- 4
Утверждение
as разрешено, только если один тип совместим с другим (сужение или расширение) — string и number не пересекаются, отсюда ошибка 2352. Двойное утверждение через unknown обходит эту проверку, но ничего не преобразует в рантайме, поэтому им стоит пользоваться очень осторожно. Строка 4 допустима: { x: number; y: number } — подтип { x: number }.Что выведет этот код после компиляции?
const cache = new Map<string, number>();
const v = cache.get('a')!;
console.log(v + 1);1NaN- TypeError в рантайме
- Ошибка компиляции:
vможет бытьundefined
Оператор
! (non-null assertion) лишь убирает undefined из типа, ничего не проверяя в рантайме. Ключа 'a' нет, v равно undefined, а undefined + 1 даёт NaN. Безопаснее явно обработать отсутствие: cache.get('a') ?? 0.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?try {
JSON.parse('{oops');
} catch (e) {
console.log(e.message);
}- Компилируется:
eимеет типany - Ошибка:
eимеет типunknown - Ошибка:
JSON.parseнужно обернуть вas - Компилируется:
eимеет типError
При
strict включается useUnknownInCatchVariables, и переменная catch получает тип unknown: бросить в JS можно что угодно, не только Error. Правильно сузить: if (e instanceof Error) console.log(e.message). Без этого флага e был бы any.Какой тип у
data?const data = JSON.parse('{"id": 1}');anyobject{ id: number }unknown
JSON.parse объявлен в стандартной библиотеке как возвращающий any, поэтому data молча отключает проверки дальше по коду. Хорошая практика — сразу сузить результат: const data: unknown = JSON.parse(...) и проверить форму (или валидировать схемой).Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?const state = { items: [] };
state.items.push(1);- Ошибка: свойства объекта
constнельзя изменять - Компилируется:
itemsимеет типany[] - Компилируется:
itemsимеет типnumber[], выведенный изpush - Ошибка: аргумент типа
numberнельзя передать в параметр типаnever
Пустой массив в свойстве объекта при
strict выводится как never[] — массив, в который ничего нельзя положить. «Эволюционирующий» массив работает только для самой переменной (const arr = []; arr.push(1)), но не для свойства объекта. Решение — явно указать тип: { items: [] as number[] } или аннотировать весь объект.Что верно про возврат значения из функции, объявленной с типом
void (TypeScript 5.6, strict: true)?type Fn = () => void;
const f: Fn = () => 42; // A
function g(): void {
return 42; // B
}- Ошибки и в A, и в B
- Ошибка только в A
- Ошибка только в B
- Обе строки компилируются
Функциональный тип
() => void допускает присваивание функции, возвращающей значение: результат просто будет проигнорирован (поэтому arr.forEach(x => list.push(x)) компилируется). Но если сама функция объявлена с аннотацией : void, вернуть из неё значение нельзя.Что выведет этот код после компиляции (TypeScript 5.6,
strict: true)?type Fn = () => void;
const f: Fn = () => 42;
const r = f();
console.log(r);undefined42- Ошибка компиляции: функция возвращает
number - Ошибка компиляции: нельзя сохранить
voidв переменную
Совместимость с
() => void — правило только системы типов: функция по-прежнему возвращает 42, просто TS считает тип r равным void и не даёт им пользоваться. В рантайме никакой подмены на undefined нет.Чему равен тип
T?type T = NonNullable<string | number | null | undefined>;string | number | nullneverstring | numberstring | number | undefined
NonNullable<T> убирает из типа null и undefined, остальные члены объединения остаются. Начиная с TypeScript 4.8 он определён как T & {}: пересечение с {} отбрасывает null и undefined, а string и number не меняет.Функции17
Что произойдёт при компиляции?
function range(start?: number, end: number) {
return [start, end];
}- Ошибка: обязательный параметр не может идти после необязательного
- Ошибка: необязательные параметры требуют значения по умолчанию
- Компилируется только без
strict - Компилируется,
startпо умолчаниюundefined
Необязательные параметры (
?) должны стоять после обязательных — иначе при вызове range(5) непонятно, какому параметру отдать значение. Если нужно пропускать первый аргумент, используют значение по умолчанию (start = 0) и передают undefined явно или переходят на объект-параметр.Что выведет этот код после компиляции?
function greet(name = 'гость') {
return 'Привет, ' + name;
}
console.log(greet(undefined));- Ошибка компиляции: нельзя передать
undefined Привет,Привет, undefinedПривет, гость
Значение по умолчанию подставляется, когда аргумент отсутствует или равен
undefined, а тип параметра TS выводит как name?: string, поэтому undefined передать можно. С null значение по умолчанию не сработало бы — и TS не дал бы его передать.Какой тип у функции
greet?function greet(name = 'гость', times = 1) {
return name.repeat(times);
}(name: string | undefined, times: number | undefined) => string(name: string, times: number) => string(name?: string, times?: number) => string(name?: "гость", times?: 1) => string
Параметры со значением по умолчанию становятся необязательными в типе функции, а их тип выводится из значения с расширением литерала (
string, number). Отличие от string | undefined: необязательный параметр можно вовсе не передавать.Какой вызов НЕ компилируется (TypeScript 5.6,
strict: true)?function sum(...nums: number[]) {
return nums.reduce((a, b) => a + b, 0);
}
sum(); // 1
sum(1, 2, 3); // 2
sum([1, 2]); // 3
sum(...[1, 2]); // 4- 1
- 2
- 3
- 4
Rest-параметр
...nums: number[] собирает отдельные аргументы в массив, поэтому передать массив целиком нельзя — нужен spread sum(...arr). Вызов без аргументов допустим: nums будет пустым массивом.Почему вызов
add(...args) не компилируется (TypeScript 5.6, strict: true)?function add(a: number, b: number) {
return a + b;
}
const args = [1, 2];
add(...args);argsимеет типnumber[]неизвестной длины, а нужен кортежargsвыведен как(1 | 2)[]- Нельзя передавать
const-массив в функцию - Spread вообще нельзя использовать при вызове функций
Для
number[] TS не знает, сколько там элементов, а функции нужны ровно два аргумента — ошибка 2556 «A spread argument must either have a tuple type or be passed to a rest parameter». Решение — сделать args кортежем: [1, 2] as const или const args: [number, number] = [1, 2].Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?function show(this: { name: string }) {
return this.name;
}
show();- Ошибка: параметр
thisразрешён только в методах классов - Компилируется, вернётся
undefined - Ошибка: функция ожидает 1 аргумент, а получено 0
- Ошибка: контекст
thisтипаvoidне подходит под{ name: string }
this в первой позиции — не настоящий параметр, а объявление типа контекста вызова. При простом вызове show() контекст — void, и TS сообщает об ошибке. Правильно вызывать как метод (obj.show()) или через show.call({ name: 'A' }).Что выведет этот код после компиляции?
function log(this: Window, msg: string, level?: number) {}
console.log(log.length);3210
Параметр
this существует только в системе типов и полностью удаляется при компиляции: получится function log(msg, level) {}. Необязательный параметр без значения по умолчанию в length учитывается, поэтому результат 2.Что выведет этот код после компиляции?
function f(a: number, b = 2, c?: number) {}
console.log(f.length);3210
length функции в JS считает параметры до первого параметра со значением по умолчанию (или rest). После компиляции получается function f(a, b = 2, c), поэтому length равен 1, хотя c формально не имеет значения по умолчанию.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?function parse(x: string): number;
function parse(x: number): string;
function parse(x: string | number): string | number {
return typeof x === 'string' ? Number(x) : String(x);
}
declare const v: string | number;
parse(v);- Ошибка: ни одна перегрузка не подходит для
string | number - Компилируется, результат имеет тип
string | number - Ошибка: у реализации не может быть объединения в параметре
- Компилируется: подходит сигнатура реализации
(x: string | number)
Сигнатура реализации снаружи не видна — вызывать можно только по объявленным перегрузкам. Ни
(x: string), ни (x: number) не принимает string | number. Решение — добавить третью перегрузку (x: string | number): string | number.Какой тип у
r (TypeScript 5.6, strict: true)?function parse(x: string): number;
function parse(x: number): string;
function parse(x: any): any {
return typeof x === 'string' ? Number(x) : String(x);
}
const r = parse('5');stringstring | numberanynumber
При вызове TS перебирает перегрузки сверху вниз и берёт первую подходящую —
(x: string): number. Тип реализации (any) на вызывающий код не влияет, так что перегрузки дают точный тип результата для каждого варианта аргумента.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?function len(x: string): number;
function len(x: unknown[]): number;
function len(x: string): number {
return x.length;
}- Компилируется, но вызов
len([])упадёт - Компилируется: перегрузки и реализация независимы
- Ошибка: перегрузка
(x: unknown[])несовместима с сигнатурой реализации - Ошибка: перегрузки с одинаковым типом возврата запрещены
Каждая перегрузка должна быть совместима с сигнатурой реализации: реализация обязана принимать все варианты аргументов. Здесь она принимает только
string, поэтому TS выдаёт ошибку 2394. Нужно расширить параметр реализации: x: string | unknown[].Чем отличаются типы
A и B?type A = (x: number) => string;
type B = { (x: number): string };Aнельзя использовать для стрелочных функций- Ничем: это один и тот же функциональный тип в двух записях
Bописывает объект, а не функцию, и вызвать его нельзяB— конструктор, его нужно вызывать черезnew
Запись
{ (x: number): string } — сигнатура вызова в объектном типе; (x: number) => string — её краткая форма. Объектная запись нужна, когда у функции есть ещё и свойства ({ (x: number): string; version: string }) или несколько перегрузок. Конструктор описывается через new (...).Компилируется ли код при
strict: true? А при strictFunctionTypes: false?let handler: (x: string | number) => void;
handler = (x: string) => console.log(x.toUpperCase());- При
strict— ошибка, приstrictFunctionTypes: false— компилируется - Компилируется в обоих случаях
- Ошибка в обоих случаях
- При
strictкомпилируется, приstrictFunctionTypes: false— ошибка
Под
strictFunctionTypes параметры функциональных типов проверяются контравариантно: функция, умеющая только строки, не может заменить ту, что принимает и числа (handler(1) упал бы). Без флага действует старая бивариантность, и небезопасное присваивание пропускается.Какой тип у
r (TypeScript 5.6, strict: true)?function fmt(x: unknown): string;
function fmt(x: number): number;
function fmt(x: any): any {
return typeof x === 'number' ? x : String(x);
}
const r = fmt(42);string | numberany— по сигнатуре реализацииnumber— выбирается самая точная перегрузкаstring— выбирается первая подходящая перегрузка
TS перебирает перегрузки строго по порядку объявления и берёт первую подходящую, а не «самую точную».
(x: unknown) принимает что угодно, поэтому перегрузка для number недостижима, хотя в рантайме вернётся число 42. Правило: перегрузки пишут от более конкретных к более общим.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?function double(x) {
return x * 2;
}- Компилируется,
xимеет типnumber, выведенный изx * 2 - Компилируется,
xимеет типany - Ошибка: параметр
xнеявно имеет типany - Ошибка: не указан тип возвращаемого значения
TS не выводит типы параметров из их использования в теле функции. Без аннотации и контекстного типа параметр получает
any, а noImplicitAny (входит в strict) превращает это в ошибку 7006. Тип возврата указывать не обязательно — он выводится.Какой тип у
r (TypeScript 5.6, strict: true)?async function load() {
return 42;
}
const r = load();numberPromise<any>Promise<number>Promise<void>
async-функция всегда возвращает промис, а возвращённое значение становится его результатом, поэтому тип вызова — Promise<number>. Чтобы получить само число, нужно await load(). По той же причине явная аннотация возвращаемого типа у async-функции должна быть Promise<...>, а не просто number.Чему равен тип
P?function save(id: number, opts?: { force: boolean }) {}
type P = Parameters<typeof save>;number | { force: boolean }[id: number, opts?: { force: boolean }][number, { force: boolean }]{ id: number; opts?: { force: boolean } }
Parameters<F> извлекает типы параметров функции в виде кортежа: метки (id, opts) и необязательность сохраняются, поэтому второй элемент — опциональный. Обычно его применяют вместе с typeof, чтобы не дублировать сигнатуру, например в обёртках (...args: Parameters<typeof save>) => .... Парный ему тип — ReturnType<F>.Перечисления и кортежи17
Что выведет этот код после компиляции?
enum Color { Red, Green = 5, Blue }
console.log(Color.Blue, Color[5]);2 Green6 Green6 undefinedBlue 5
Числовые члены без инициализатора получают значение предыдущего + 1, поэтому
Blue = 6. Для числовых enum TS генерирует обратное отображение (Color[5] === 'Green'), так что по значению можно получить имя.Что выведет этот код после компиляции?
enum Num { A, B }
enum Str { A = 'a', B = 'b' }
console.log(Object.keys(Num).length, Object.keys(Str).length);4 22 42 24 4
Числовой enum компилируется в объект с прямым и обратным отображением:
{ 0: 'A', 1: 'B', A: 0, B: 1 } — 4 ключа. Строковые enum обратного отображения не имеют, поэтому ключей 2. Это важно при переборе enum через Object.keys/values.Какая строка НЕ компилируется (TypeScript 5.6,
strict: true)?enum Dir { Up, Down }
let d1: Dir = 1; // 1
let d2: Dir = 42; // 2
let d3: number = Dir.Up; // 3- 1
- 2
- 3
- Все компилируются
Начиная с TS 5.0 все enum стали объединениями своих членов, и присвоить числовой литерал, не совпадающий ни с одним значением (
42), нельзя. Литерал 1 совпадает с Dir.Down и допустим, а значение enum всегда можно присвоить в number. До TS 5.0 строка 2 тоже компилировалась.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?enum Status { Active = 'active', Banned = 'banned' }
const s: Status = 'active';- Ошибка: строковые enum нужно объявлять через
const enum - Компилируется: значение совпадает с
Status.Active - Ошибка: строковый литерал нельзя присвоить в строковый enum
- Компилируется только с
as const
Строковые enum номинальны: даже совпадающую строку
'active' нельзя присвоить в Status, нужно писать Status.Active. Это одно из отличий от объединения литералов 'active' | 'banned', где строку можно передавать напрямую.Во что скомпилируется
console.log(Dir.Down) (обычный tsc, без isolatedModules и preserveConstEnums)?const enum Dir { Up, Down }
console.log(Dir.Down);console.log(Dir.Down);и объектDirв выходном JSconsole.log(1 /* Dir.Down */);, объектаDirв JS нетconsole.log("Down");console.log(Dir[1]);
const enum существует только на этапе компиляции: обращения к членам заменяются их значениями (инлайнятся), а сам объект не генерируется. Поэтому у const enum нет обратного отображения и его не перебрать в рантайме; с isolatedModules (Babel, esbuild) использование const enum из других файлов проблематично.Чем объединение литералов
type Dir = 'up' | 'down' отличается от enum Dir { Up = 'up', Down = 'down' }?- Объединение полностью стирается при компиляции, а enum создаёт объект в рантайме
- Объединение нельзя использовать в
switch - Enum стирается при компиляции, а объединение создаёт объект
- Ничем, это синтаксический сахар
Обычный
enum — одна из немногих конструкций TS, порождающих JS-код: объект со значениями. Объединение литералов существует только в системе типов, а в коде используются обычные строки. Поэтому многие команды предпочитают объединения (или as const-объекты) вместо enum.Что произойдёт при компиляции?
enum E {
A = 'abc'.length,
B,
}- Ошибка: вычисляемые значения в enum запрещены
- Компилируется:
A = 3,B = 1 - Компилируется:
A = 3,B = 4 - Ошибка: член
Bдолжен иметь инициализатор
Вычисляемые члены числового enum разрешены, но TS не знает их значение на этапе компиляции, поэтому не может автоматически вычислить следующий член — ошибка «Enum member must have initializer». Автоинкремент работает только после константных членов.
Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?let pair: [string, number] = ['age', 30];
pair = [30, 'age'];- Компилируется с
strict: falseи без ошибок в рантайме - Компилируется: кортеж — просто массив
(string | number)[] - Ошибка: порядок типов в кортеже важен
- Ошибка: кортеж нельзя переприсвоить
Кортеж — массив фиксированной длины с типом для каждой позиции: в
[string, number] первым должен идти string. Поэтому [30, 'age'] не подходит, ошибки на обоих элементах.Что выведет этот код после компиляции (TypeScript 5.6,
strict: true)?const point: [number, number] = [1, 2];
point.push(3);
console.log(point.length);- Ошибка компиляции: у кортежа нет
push 23- TypeError в рантайме
Изменяемые кортежи наследуют методы массива, и
push не запрещён — это известное слабое место. Длина в типе остаётся 2, а в рантайме массив стал длиннее. Защититься помогает readonly [number, number].Какой тип у
Len?type Opt = [string, number?, boolean?];
type Len = Opt['length'];3number1 | 2 | 31
Необязательные элементы кортежа (
?) делают длину переменной, и TS выражает это объединением литералов: 1 | 2 | 3. Для кортежа без опциональных элементов length — точный литерал, а у обычного массива — number.Какое присваивание НЕ компилируется (TypeScript 5.6,
strict: true)?type Row = [string, ...number[], boolean];
const a: Row = ['x', true]; // 1
const b: Row = ['x', 1, 2, true]; // 2
const c: Row = ['x', 1, 2]; // 3- 1
- 2
- 3
- Все компилируются
Rest-элемент может стоять в середине кортежа:
[string, ...number[], boolean] — строка, любое количество чисел (в том числе ноль) и обязательный boolean в конце. В варианте 3 последним идёт число, поэтому ошибка.Что произойдёт при компиляции (TypeScript 5.6,
strict: true)?const origin = [0, 0] as const;
origin[0] = 10;- Компилируется, но в рантайме массив заморожен
- Компилируется:
as constзапрещает только переприсваивание переменной - Ошибка:
origin— readonly-кортеж, элемент0только для чтения - Ошибка: тип
0не принимает значение10, но readonly тут ни при чём
as const превращает массивный литерал в readonly [0, 0]: изменять элементы и вызывать push нельзя. При этом это только проверка типов — в рантайме массив не заморожен (в отличие от Object.freeze).Что верно про метки в кортеже
type Range = [start: number, end: number]?- Метки создают в рантайме объект
{ start, end } - Метки влияют только на читаемость и подсказки IDE, тип равен
[number, number] - Метки позволяют обращаться к элементам как
range.start - Кортежи с метками несовместимы с
[number, number]
Метки элементов кортежа — документация: они видны в подсказках и в сигнатуре
(...args: Range) превращаются в имена параметров start, end. На совместимость типов и рантайм они не влияют, range.start не существует.Почему вызов
sum(xy) не компилируется (TypeScript 5.6, strict: true)?function sum(xs: number[]) {
return xs.reduce((a, b) => a + b, 0);
}
const xy = [1, 2] as const;
sum(xy);- Readonly-кортеж нельзя передать туда, где ожидается изменяемый
number[] - Кортеж нельзя передать в параметр-массив
reduceнедоступен для кортежей- Литералы
1и2не являютсяnumber
as const даёт readonly [1, 2], а функция с параметром number[] теоретически может его изменить (push), поэтому TS не пропускает такой вызов. Если функция не мутирует массив, лучше объявлять параметр как readonly number[] — тогда подойдут и обычные, и readonly-массивы.Какие типы у
a и b (TypeScript 5.6, strict: true)?const pair = ['id', 42];
const [a, b] = pair;a: "id",b: 42a: any,b: anya: string,b: numbera: string | number,b: string | number
Массивный литерал без аннотации выводится как массив
(string | number)[], а не кортеж, поэтому при деструктуризации каждый элемент — string | number. Чтобы получить [string, number], нужна аннотация кортежа или as const.Какой тип возвращает
useToggle и как исправить его, чтобы получить кортеж?function useToggle(initial: boolean) {
let value = initial;
const toggle = () => { value = !value; };
return [value, toggle];
}readonly [boolean, () => void]; исправить — убратьlet[boolean, () => void]— исправлять не нужно(boolean | (() => void))[]; исправить —return [value, toggle] as constany[]; исправить — указать: any
Возвращаемый массивный литерал выводится как массив объединения, и после
const [on, toggle] = useToggle(false) обе переменные будут boolean | (() => void). as const (или явный тип возврата [boolean, () => void]) сохраняет позиции — так устроены хуки вроде useState.Чему равен тип
K?enum Color { Red, Green }
type K = keyof typeof Color;0 | 1Color'Red' | 'Green' | 0 | 1'Red' | 'Green'
typeof Color — тип самого объекта перечисления, а keyof даёт имена его членов: 'Red' | 'Green'. Обратные отображения (Color[0] === 'Red') существуют в рантайме, но в типе объекта не отражаются. Без typeof запись keyof Color относилась бы к типу значений перечисления, а не к его объекту.Интерфейсы и type13
Что произойдёт при компиляции этого кода?
interface User { name: string }
interface User { age: number }
const u: User = { name: 'Аня' }; // A- Компилируется: второе объявление просто игнорируется
- Компилируется:
ageиз второго объявления становится необязательным - Ошибка «Duplicate identifier»: интерфейс нельзя объявить дважды
- Ошибка в строке A: в объекте нет обязательного свойства
age
Одноимённые интерфейсы в одной области видимости сливаются (declaration merging): итоговый
User — это { name: string; age: number }. Поэтому литерал без age не проходит проверку. С type так нельзя — повторное объявление псевдонима даёт ошибку Duplicate identifier.Что произойдёт при компиляции?
type User = { name: string };
type User = { age: number };- Типы сольются в
{ name: string; age: number } - Второе объявление перезапишет первое
- Ошибка: Duplicate identifier
User - Получится объединение
{ name: string } | { age: number }
Псевдоним типа (
type) — это просто имя для типа, и объявить его дважды нельзя: компилятор сообщит Duplicate identifier. Слияние объявлений (declaration merging) работает для interface (а также namespace, enum и т.п.), но не для type.Что из перечисленного можно описать только через
type, но не через interface?- Объект с методами
- Объединение
string | number - Объект с необязательными свойствами
- Тип, расширяющий другой тип
Интерфейс всегда описывает форму объекта (или функции/конструктора). Объединения, кортежи, псевдонимы примитивов, условные и mapped-типы — только через
type. Необязательные свойства, методы и наследование доступны обоим способам (extends у интерфейса, & у псевдонима).Что верно про этот код?
interface A { id: string }
interface B extends A { id: number } // B
type C = A & { id: number }; // C- Ошибка только в строке B; в типе
Cсвойствоidимеет типnever - Ошибка только в строке C; в
Bсвойствоidпереопределяется наnumber - Обе строки B и C — ошибки компиляции
- Ошибок нет; в
BиCсвойствоidимеет типnumber
extends проверяет совместимость: свойство наследника должно быть подтипом свойства родителя, иначе — ошибка «Interface B incorrectly extends interface A». Пересечение & ничего не проверяет, а просто пересекает типы свойств: string & number даёт never, и создать значение такого типа уже нельзя. Это одна из причин предпочитать interface extends для иерархий.Какая строка не скомпилируется?
type Point = { x: number; y: number };
type Shape = { kind: 'circle' } | { kind: 'square' };
class P implements Point { x = 0; y = 0; } // A
class S implements Shape { kind = 'circle' as const; } // B- Обе строки
- Ни одна — оба варианта допустимы
- A — класс может реализовывать только
interface, а неtype - B — класс не может реализовывать тип-объединение
implements принимает любой объектный тип со статически известными членами, в том числе псевдоним type, — поэтому строка A корректна. Объединение не задаёт однозначный набор членов, и TypeScript сообщает: «A class can only implement an object type or intersection of object types with statically known members».Что произойдёт?
interface Config { readonly url: string }
const c: Config = { url: '/api' };
c.url = '/v2'; // A- Компилируется, а в рантайме будет TypeError
- Компилируется:
readonlyпроверяется только у классов - Ошибка компиляции в строке A:
urlдоступно только для чтения - Компилируется, присваивание молча игнорируется
readonly — проверка только времени компиляции: присвоить такое свойство TypeScript не даст (Cannot assign to url because it is a read-only property). В скомпилированном JS никакой защиты нет — Object.freeze или аналоги TypeScript не добавляет.Что выведет этот код?
interface Config { readonly tags: string[] }
const c: Config = { tags: ['a'] };
c.tags.push('b');
console.log(c.tags.length);- Ошибка компиляции:
tags— readonly - 2
- 1
- TypeError в рантайме
readonly поверхностный: он запрещает переприсвоить само свойство (c.tags = []), но не делает неизменяемым массив внутри. Чтобы запретить push, нужен тип readonly string[] (или ReadonlyArray<string>).Что выведет этот код?
interface RO { readonly x: number }
interface RW { x: number }
const ro: RO = { x: 1 };
const rw: RW = ro;
rw.x = 2;
console.log(ro.x);- 2
- Ошибка:
ROнельзя присвоитьRWиз-заreadonly - 1
- Ошибка: нельзя присвоить
rw.x
Модификатор
readonly не влияет на совместимость типов: объект с readonly-свойством можно присвоить переменной типа без readonly. Обе переменные указывают на один объект, поэтому запись через rw видна через ro. readonly защищает лишь конкретную ссылку, а не сам объект.Какой тип у
a (режим strict)?interface User { name: string; age?: number }
declare const u: User;
const a = u.age;number | nullnumber | undefined | nullnumbernumber | undefined
Необязательное свойство
age?: number может отсутствовать, поэтому при чтении его тип — number | undefined. null сюда не входит: его нужно указывать явно. Перед использованием значение сужают проверкой или задают дефолт через ??.Что произойдёт при компиляции?
interface Box { size: number; label: string }
interface Box { size: string } // A
interface Box { color: string }- Компилируется:
sizeстанетnumber | string - Компилируется: последнее объявление
sizeпобеждает - Ошибка в A: повторное объявление свойства должно иметь тот же тип
- Ошибка: интерфейс можно дополнить только один раз
При слиянии интерфейсов новые члены добавляются, но одноимённое свойство (не метод) должно иметь в точности тот же тип: «Subsequent property declarations must have the same type». Объединения или «перезаписи» не происходит. Одноимённые методы, в отличие от свойств, сливаются в перегрузки.
Для чего на практике чаще всего используют слияние объявлений интерфейсов (declaration merging)?
- Чтобы объединить два класса в один
- Чтобы дополнить чужие типы — например, добавить поле в
Windowили в интерфейс библиотеки - Чтобы создать тип-объединение из двух интерфейсов
- Чтобы переопределить тип уже существующего свойства
Повторное объявление интерфейса добавляет к нему новые члены — так расширяют глобальные типы (
Window, ProcessEnv) и типы библиотек через module augmentation. Изменить тип уже существующего свойства так нельзя: при несовпадении будет ошибка «Subsequent property declarations must have the same type».Какая строка не скомпилируется?
type A = { a: string };
type U = { a: string } | { b: number };
interface B extends A { b: number } // X
interface C extends U { c: boolean } // Y- Y — интерфейс не может расширять объединение
- Ни одна
- X — интерфейс не может расширять
type - Обе строки
Интерфейс может расширять псевдоним типа, если это объектный тип (или пересечение) со статически известными членами — строка X корректна. Объединение такой формы не имеет, поэтому
extends U — ошибка. Для «объединение плюс поле» используют type C = U & { c: boolean }.Что выдаст
tsc --strict?interface Animal { name: string }
interface Dog extends Animal { bark(): void }
interface WithMethod { handle(a: Animal): void }
interface WithProp { handle: (a: Animal) => void }
const dogOnly = (d: Dog) => d.bark();
const m: WithMethod = { handle: dogOnly }; // A
const p: WithProp = { handle: dogOnly }; // B- Ошибки в обеих строках
- Ошибок нет
- Ошибка только в строке A
- Ошибка только в строке B
При
strictFunctionTypes (входит в strict) параметры функций проверяются контравариантно: функция, принимающая только Dog, не годится туда, где передадут любое Animal, — строка B ошибочна. Но для членов, объявленных синтаксисом метода (handle(a): void), проверка остаётся бивариантной ради совместимости, поэтому строка A проходит. Это аргумент в пользу записи handle: (a: Animal) => void в интерфейсах.Структурная типизация10
Что означает, что система типов TypeScript — структурная?
- Каждый тип хранится в рантайме как структура и проверяется при выполнении
- Типы совместимы только при совпадении имени интерфейса
- Совместимость типов определяется набором и типами членов, а не именем или местом объявления типа
- Типы совместимы, только если один явно наследует или реализует другой
В структурной («утиной») типизации важна форма: объект подходит под интерфейс, если у него есть все нужные свойства нужных типов, независимо от того, где и как он объявлен. В номинальной типизации (Java, C#) нужна явная связь через
implements/наследование. Типы TypeScript при этом стираются и в рантайме не проверяются.Скомпилируется ли этот код?
interface Point { x: number; y: number }
class Vec {
constructor(public x: number, public y: number) {}
len() { return Math.hypot(this.x, this.y); }
}
const p: Point = new Vec(3, 4);- Нет: у
Vecесть лишний методlen - Да: у
Vecестьxиyтипаnumber - Да, но только с явным приведением
as Point - Нет:
Vecне реализуетPointчерезimplements
Совместимость структурная: у экземпляра
Vec есть все члены Point, и этого достаточно — implements для этого не нужен. Лишние члены не мешают; проверка лишних свойств срабатывает только для «свежих» объектных литералов, а не для экземпляров классов и переменных.Где будет ошибка компиляции?
interface Point { x: number; y: number }
const a: Point = { x: 1, y: 2, z: 3 }; // A
const tmp = { x: 1, y: 2, z: 3 };
const b: Point = tmp; // B- Только в строке A
- Только в строке B
- Ошибок нет
- В обеих строках
Проверка лишних свойств (excess property check) применяется только к «свежему» объектному литералу, который сразу присваивается типизированной переменной или передаётся аргументом, — там лишнее
z скорее всего опечатка. Переменная tmp уже имеет свой тип { x; y; z }, и при присваивании работает обычная структурная совместимость, где лишние свойства разрешены.Что выдаст
tsc на строке A?interface Options { timeout?: number; retries?: number }
const opts = { timeuot: 1000 };
const o: Options = opts; // A- Ничего: литерал не свежий, лишние свойства разрешены
- Ошибку: не хватает обязательного свойства
timeout - Ничего: все свойства
Optionsнеобязательны, подходит любой объект - Ошибку: у
optsнет ни одного общего свойства со «слабым» типомOptions
Тип, у которого все свойства необязательны, называется «слабым» (weak type). Для него TypeScript делает отдельную проверку: присваиваемое значение должно иметь хотя бы одно общее с ним свойство, иначе ошибка «has no properties in common». Это ловит опечатки вроде
timeuot даже там, где проверка лишних свойств уже не работает.Какие вызовы
pay скомпилируются?type USD = number & { readonly __brand: 'USD' };
type EUR = number & { readonly __brand: 'EUR' };
const usd = (n: number) => n as USD;
const eur = (n: number) => n as EUR;
function pay(amount: USD) {}
pay(usd(5)); // A
pay(eur(5)); // B
pay(5); // C- Все три: в рантайме это просто числа
- A и C
- Только A
- A и B
Это «брендирование» — имитация номинальной типизации: пересечение с фиктивным полем
__brand делает USD и EUR несовместимыми, а обычный number — неприсваиваемым к USD. Получить USD можно только через функцию-конструктор с as. В рантайме поля __brand нет, это чисто типовая метка.Что произойдёт при компиляции?
class A { private x = 1; }
class B { private x = 1; }
const a: A = new B(); // C- Компилируется: формы классов совпадают
- Ошибка: у типов разные объявления приватного свойства
x - Ошибка: приватные свойства нельзя инициализировать при объявлении
- Компилируется, потому что
privateпроверяется только внутри класса
Структурная совместимость имеет исключение: члены
private и protected сравниваются по месту объявления. Два одинаковых приватных поля из разных классов считаются разными, поэтому B нельзя присвоить A («Types have separate declarations of a private property»). Будь x публичным в обоих классах, код бы скомпилировался.Какое присваивание вызовет ошибку?
let f2: (a: number, b: number) => void;
let f1: (a: number) => void;
f2 = (a: number) => {}; // A
f1 = (a: number, b: number) => {}; // B- B — функции нужны два аргумента, а по типу её вызовут с одним
- A — у функции меньше параметров, чем требует тип
- Оба
- Ни одно: количество параметров не проверяется
Функцию с меньшим числом параметров можно использовать там, где передают больше аргументов, — лишние она просто проигнорирует (как колбэк в
arr.forEach(x => ...), хотя туда передаются ещё индекс и массив). Наоборот нельзя: функции из строки B нужен b, а по типу f1 её вызовут с одним аргументом.Какая строка не скомпилируется в режиме
strict?const a: {} = 'text'; // A
const b: {} = 0; // B
const c: {} = null; // C
const d: {} = []; // D- A
- B
- C
- D
Тип
{} означает «любое значение, кроме null и undefined» — строки, числа и массивы ему подходят. Частая ловушка: {} не значит «пустой объект». Для «любого объекта» используют object, для «объекта без свойств» — Record<string, never>.В какой строке будет ошибка проверки лишних свойств?
interface P { x: number }
const a = { x: 1, y: 2 };
const p1: P = a; // A
const p2: P = { ...a }; // B
const p3: P = { x: 1, y: 2 } as P; // C
const p4: P[] = [{ x: 1, y: 2 }]; // D- A
- B
- C
- D
Литерал внутри массива тоже «свежий» и контекстно типизирован как
P, поэтому y в строке D считается лишним. В A присваивается переменная, а не литерал; в B свойства приходят через spread — их TypeScript на «лишность» не проверяет; в C утверждение as отключает проверку лишних свойств.Что выведет этот код?
class User {
constructor(public name: string) {}
}
const u: User = { name: 'Аня' };
console.log(u instanceof User);- true
- false
- TypeError в рантайме
- Ошибка компиляции: литерал не является экземпляром
User
Тип класса
User в TypeScript — это просто форма { name: string }, поэтому литерал проходит проверку. Но instanceof работает в рантайме по цепочке прототипов, а литерал не создан через new User, значит результат false. Отсюда правило: не полагаться на instanceof для данных из JSON или литералов.Классы22
Что выведет этот код?
class Account {
private balance = 100;
}
const acc = new Account();
console.log((acc as any).balance);- 100
- Ошибка компиляции
- TypeError: cannot read private member
- undefined
private в TypeScript — проверка только на этапе компиляции; в JS это обычное свойство. Через as any (или acc["balance"]) его можно прочитать. Настоящую приватность в рантайме дают #-поля JavaScript.Что выведет этот код (
target: ES2022)?class A {
private x = 1;
#y = 2;
z = 3;
}
console.log(JSON.stringify(new A()));- {"x":1,"#y":2,"z":3}
- {"z":3}
- {"x":1,"y":2,"z":3}
- {"x":1,"z":3}
Поле с
private после компиляции — обычное собственное свойство, поэтому попадает в JSON. #y — нативное приватное поле JavaScript: оно хранится вне обычных свойств объекта, не видно Object.keys и JSON.stringify, а доступ к нему извне невозможен даже в рантайме.Где будет ошибка компиляции?
class Base {
protected id = 1;
}
class Child extends Base {
show() { return this.id; } // A
}
const c = new Child();
console.log(c.show()); // B
console.log(c.id); // C- A и C
- Только A
- Только C
- Ошибок нет
protected-член доступен внутри класса и его наследников (строка A), но не снаружи через экземпляр (строка C). private закрыл бы доступ и в наследнике.Что выведет этот код?
class User {
constructor(public name: string, private age: number, city: string) {}
}
console.log(Object.keys(new User('Аня', 30, 'Минск')));- [ 'name' ]
- [ 'name', 'age' ]
- [ 'name', 'age', 'city' ]
- []
Параметр конструктора с модификатором (
public, private, protected, readonly) — это parameter property: TypeScript сам объявляет поле и присваивает ему значение. Модификатор доступа на это не влияет — age тоже станет обычным свойством. Параметр без модификатора (city) остаётся просто аргументом конструктора.Что выдаст
tsc --strict?interface Greeter {
greet(name: string): string;
}
class Hello implements Greeter {
greet(name) { return 'Hi, ' + name; } // A
}- Ошибку в строке A: параметр
nameнеявно имеет типany - Ошибку: класс не реализует метод
greet - Ничего: в классах
noImplicitAnyне действует - Ничего: тип
nameберётся из интерфейсаGreeter
implements только проверяет, что класс совместим с интерфейсом, — он не меняет и не выводит типы членов класса. Параметр name не получает тип из Greeter, поэтому при noImplicitAny будет ошибка. Типы в реализации нужно писать явно.Что произойдёт?
interface HasId { id?: number }
class Item implements HasId {}
const item = new Item();
console.log(item.id); // A- Компилируется и выводит
0 - Компилируется и выводит
undefined - Ошибка: класс
Itemне реализуетid - Ошибка в строке A: у
Itemнет свойстваid
implements не добавляет в класс членов интерфейса. Класс без id совместим с HasId, так как свойство необязательное, — поэтому объявление класса корректно. Но тип Item по-прежнему не содержит id, и обращение к нему — ошибка. Нужно явно объявить id?: number в классе.Что выдаст компилятор?
abstract class Shape {
abstract area(): number;
describe() { return 'S = ' + this.area(); }
}
class Square extends Shape { // A
constructor(public side: number) { super(); }
}- Ошибку в
describe: нельзя вызывать абстрактный метод - Ошибку: в абстрактном классе нельзя объявлять обычные методы
- Ошибку в строке A: не реализован абстрактный метод
area - Ничего:
Squareунаследует абстрактныйareaкак есть
Неабстрактный наследник обязан реализовать все абстрактные члены, иначе ошибка «Non-abstract class Square does not implement inherited abstract member area». Вызывать абстрактный метод из обычного метода базового класса можно — к моменту вызова он будет реализован в наследнике. Альтернатива — объявить абстрактным и
Square.Что выведет этот код?
class Counter {
static count = 0;
constructor() { Counter.count++; }
}
new Counter();
new Counter();
const c = new Counter();
console.log(Counter.count, (c as any).count);- 3 3
- 3 undefined
- 1 1
- 0 undefined
static-поле принадлежит самому классу (функции-конструктору), а не экземплярам: оно одно на все объекты, и каждый вызов конструктора его увеличивает. У экземпляра собственного count нет, поэтому c.count — undefined (без as any TypeScript вообще не дал бы так написать).Какие ошибки выдаст
tsc с флагом noImplicitOverride: true?class Base {
save() {}
}
class Child extends Base {
save() {} // A
override load() {} // B
}- A и B
- Ошибок нет
- Только B
- Только A
С
noImplicitOverride переопределение метода базового класса без ключевого слова override — ошибка (строка A). А override у метода, которого нет в базовом классе, — ошибка всегда, даже без флага (строка B): так ловятся опечатки и переименования в базовом классе.Где будет ошибка в режиме
strict?class Service {
conn: string; // A
url!: string; // B
name?: string; // C
init() { this.conn = 'x'; this.url = 'y'; }
}- A, B и C
- Ошибок нет: поля присваиваются в
init - A и B
- Только A
strictPropertyInitialization требует, чтобы поле было инициализировано в объявлении или в конструкторе — присваивание в обычном методе не считается. ! (definite assignment assertion) говорит компилятору «поверь, значение будет», а необязательное поле ? и так может быть undefined. Ошибка только у conn.Что произойдёт при
target: ES2022 (по умолчанию тогда useDefineForClassFields: true)?class Base {
name: string;
constructor() { this.name = 'base'; }
}
class Derived extends Base {
name!: string; // A
}
console.log(new Derived().name);- Ошибка в A: модификатор
!нельзя использовать в наследнике - Компилируется и выводит
base - Ошибка в A: поле перезапишет свойство базового класса; без проверки типов JS вывел бы
undefined - Компилируется и выводит
undefined
С
useDefineForClassFields повторное объявление поля в Derived становится настоящим полем класса: после super() оно определяется заново со значением undefined и затирает "base". TypeScript предупреждает об этом ошибкой TS2612. Чтобы только уточнить тип, не создавая поле, пишут declare name: string; при useDefineForClassFields: false объявление просто стёрлось бы и вывелось base.Где ошибка?
class Order {
readonly id: number;
constructor(id: number) {
this.id = id; // A
}
reset() { this.id = 0; } // B
}- В A и B
- Только в B
- Только в A
- Ошибок нет
Поле
readonly можно присвоить в объявлении или в конструкторе того же класса — дальше оно только для чтения. Поэтому A корректна, а B — ошибка «Cannot assign to id because it is a read-only property».Где ошибка?
class Db {
private static instance?: Db;
private constructor() {}
static get() {
return (Db.instance ??= new Db()); // A
}
}
const d1 = Db.get(); // B
const d2 = new Db(); // C- Только в C
- Ошибок нет
- В A и C
- Только в A
Приватный конструктор запрещает
new Db() вне класса — так реализуют синглтон или фабрику. Внутри класса (в статическом методе, строка A) вызывать его можно.Что выведет код? И что было бы, если бы
add возвращал тип Builder вместо this?class Builder {
parts: string[] = [];
add(p: string): this { this.parts.push(p); return this; }
}
class HtmlBuilder extends Builder {
html() { return this.parts.join(''); }
}
console.log(new HtmlBuilder().add('<b>').add('</b>').html());- Ошибка компиляции:
thisнельзя использовать как тип <b></b>; сBuilderбыла бы ошибка в рантайме<b></b>в обоих случаях<b></b>; с типомBuilderбыла бы ошибка компиляции на.html()
Полиморфный тип
this означает «тип объекта, у которого вызван метод»: у HtmlBuilder метод add возвращает HtmlBuilder, и цепочка продолжается методами наследника. С аннотацией : Builder после add тип сузился бы до Builder, где html нет, — ошибка компиляции, хотя в рантайме объект тот же.Что выведет этот код?
class Base {
#x = 1;
getBase() { return this.#x; }
}
class Child extends Base {
#x = 2;
getChild() { return this.#x; }
}
const c = new Child();
console.log(c.getBase(), c.getChild());- 2 2
- 1 1
- 1 2
- Ошибка компиляции:
#xуже объявлен вBase
#-поля лексически привязаны к классу: #x в Base и #x в Child — два разных слота одного объекта, и методы каждого класса видят только свой. С private x в обоих классах TypeScript выдал бы ошибку («Types have separate declarations of a private property x»), а в рантайме это было бы одно и то же свойство.Что выведет этот код?
class Base {
constructor() { this.init(); }
init() {}
}
class Child extends Base {
value = 1;
init() { this.value = 42; }
}
console.log(new Child().value);- undefined
- TypeError
- 42
- 1
Конструктор
Base вызывает переопределённый init, и value становится 42. Но инициализаторы полей Child выполняются после возврата из super(), и value = 1 перезаписывает значение. Поэтому вызывать переопределяемые методы из конструктора базового класса опасно.Чем абстрактный класс отличается от интерфейса в TypeScript?
- Ничем, это синонимы
- Интерфейс может содержать реализацию методов, а абстрактный класс — нет
- Абстрактный класс существует в рантайме и может содержать реализацию и состояние; интерфейс полностью стирается
- Класс может реализовать только один интерфейс, но расширить несколько абстрактных классов
Абстрактный класс компилируется в обычный JS-класс: в нём могут быть поля, конструктор, готовые методы, с ним работает
instanceof; создать его экземпляр напрямую нельзя. Интерфейс — чисто типовая конструкция без следа в JS. Наследоваться можно только от одного класса, а реализовывать — сколько угодно интерфейсов.Где ошибка?
class Temperature {
private c = 20;
get celsius() { return this.c; }
}
const t = new Temperature();
console.log(t.celsius); // A
t.celsius = 30; // B- В A и B
- Только в B: свойство только для чтения
- Ошибок нет
- Только в A: геттер нужно вызывать как
t.celsius()
Аксессор только с
get и без set TypeScript считает readonly-свойством: присваивание — ошибка «Cannot assign to celsius because it is a read-only property». Читается геттер как обычное свойство, без скобок.Какая функция не скомпилируется?
class Dog {
bark() { return 'Гав'; }
}
function create1(C: typeof Dog) { return new C(); } // A
function create2(C: Dog) { return new C(); } // B- A
- B
- Обе
- Обе скомпилируются
Имя класса в позиции типа (
Dog) означает тип экземпляра — объект с методом bark, вызвать его через new нельзя. Тип самого класса-конструктора (со статическими членами) — typeof Dog; другой вариант — new () => Dog.Что выведет этот код?
class Btn {
label = 'OK';
a() { return this?.label; }
b = () => this.label;
}
const { a, b } = new Btn();
console.log(a(), b());- OK undefined
- TypeError
- OK OK
- undefined OK
Метод
a лежит в прототипе и получает this в момент вызова; после деструктуризации он вызывается без объекта, а код классов всегда в strict mode — this равен undefined, и this?.label даёт undefined. Стрелочная функция-поле b создаётся для каждого экземпляра и захватывает this при создании. TypeScript такую потерю this не ловит.Где ошибка?
class Base {
protected x = 1;
}
class Derived extends Base {
f(other: Derived) { return other.x; } // A
g(other: Base) { return other.x; } // B
}- В A и B
- Ошибок нет
- Только в B
- Только в A
Внутри
Derived можно обращаться к protected-членам через экземпляры Derived (и его наследников), но не через произвольный Base: тот может оказаться другим наследником, и TypeScript запрещает «подглядывать» в чужую ветку иерархии — «Property x is protected and only accessible through an instance of class Derived».Что выдаст
tsc --strict?interface Checker {
check(name: string): boolean;
}
class NameChecker implements Checker {
check(s) {
return s.length > 0;
}
}- Ошибок нет:
sполучит типstringиз интерфейса - Ошибка: параметр
sнеявно имеет типany - Ошибка: класс неправильно реализует интерфейс
Checker - Ошибок нет:
sполучит типunknown
implements только проверяет, что класс совместим с интерфейсом, но не выводит и не меняет типы его членов. Поэтому параметр s без аннотации считается any, и при noImplicitAny (входит в strict) это ошибка «Parameter 's' implicitly has an 'any' type». Тип нужно указать явно: check(s: string).Индексные типы13
Почему строка A не компилируется?
interface Dict {
[key: string]: number;
count: number;
title: string; // A
}- Нельзя смешивать индексную сигнатуру с именованными свойствами
- Все строковые свойства должны соответствовать индексной сигнатуре
number - Имя
titleзарезервировано - Индексная сигнатура должна быть объявлена последней
Индексная сигнатура
[key: string]: number утверждает, что любое строковое свойство имеет тип number, — значит, и явно объявленные свойства обязаны ему соответствовать. count: number подходит, title: string — нет. Решения: расширить сигнатуру (number | string) или вынести словарь в отдельное поле.Какой тип у
v в режиме strict (без noUncheckedIndexedAccess) и что выведется?const scores: Record<string, number> = { anna: 5 };
const v = scores['boris'];
console.log(v);number, выведетсяundefinednumber, выведется0number, будет ошибка компиляцииnumber | undefined, выведетсяundefined
Для индексной сигнатуры TypeScript по умолчанию считает, что значение по любому ключу существует, и даёт
number. В рантайме ключа нет — получаем undefined, о котором тип молчит. Флаг noUncheckedIndexedAccess (не входит в strict) добавляет | undefined к таким обращениям.Что произойдёт при компиляции?
type Lang = 'ru' | 'en';
const hello: Record<Lang, string> = { ru: 'Привет' }; // A- Ошибок нет,
hello.enбудет пустой строкой - Ошибок нет:
Recordделает ключи необязательными - Ошибка: ключом
Recordможет быть толькоstring - Ошибка в A: не хватает ключа
en
Record<K, V> с объединением литералов — это объект, где каждый ключ из K обязателен: { ru: string; en: string }. Поэтому пропуск en — ошибка. Для необязательных ключей используют Partial<Record<Lang, string>>.Какой из интерфейсов не скомпилируется?
interface A {
[k: string]: string | number;
[i: number]: string;
}
interface B {
[k: string]: string;
[i: number]: number; // X
}- Оба компилируются
- Оба
- Только
B(строка X) - Только
A
В JavaScript числовые ключи всё равно превращаются в строки (
obj[1] — это obj["1"]), поэтому тип числовой индексной сигнатуры должен быть подтипом строковой. В A string — подтип string | number, всё корректно. В B number не подтип string — ошибка.Где будут ошибки?
interface Attrs {
[key: `data-${string}`]: string;
}
const a: Attrs = { 'data-id': '1' };
const b: Attrs = { 'data-id': '1', title: 'x' }; // A
const c: Attrs = { 'data-n': 5 }; // B- Только в B
- В A и B
- Ошибок нет: индексная сигнатура принимает любые ключи
- Только в A
Начиная с TS 4.4 ключом индексной сигнатуры может быть шаблонный литеральный тип: здесь подходят только ключи, начинающиеся с
data-. Ключ title под шаблон не попадает и считается лишним свойством литерала (A), а в B не тот тип значения — number вместо string.Чему равен тип
T?interface User {
id: number;
profile: { email: string; phones: string[] };
}
type T = User['profile']['phones'][number];stringnumber- Ошибка: через
[]можно получить только свойство верхнего уровня string[]
Индексный доступ
T["key"] работает как чтение свойства, но на уровне типов, и его можно цеплять: User["profile"] — объект профиля, ["phones"] — string[], а [number] достаёт тип элемента массива — string. Обратите внимание: в типе пишут User["profile"], а не User.profile.Чему равен тип
User?const users = [
{ id: 1, name: 'Аня' },
{ id: 2, name: 'Борис' },
];
type User = (typeof users)[number];- Ошибка: у массива нет индекса типа
number { id: 1; name: "Аня" } | { id: 2; name: "Борис" }{ id: number; name: string }{ id: number; name: string }[]
T[number] — индексный доступ по числовому индексу, он даёт тип элемента массива. typeof users — { id: number; name: string }[] (литералы расширены, т.к. нет as const), значит элемент — { id: number; name: string }. Удобно, когда данные уже есть, а описывать тип вручную не хочется.Чему равны
A, L и E?type T = [string, number, boolean];
type A = T[1];
type L = T[0 | 2];
type E = T[number];A = string,L = string,E = stringA = number,L = string | boolean,E = string | number | booleanA = number,L = [string, boolean],E = string | number | booleanA = number,L = string | boolean,E = [string, number, boolean]
Индексы кортежа отсчитываются с нуля, поэтому
T[1] — number. Индекс-объединение T[0 | 2] распределяется: T[0] | T[2] = string | boolean — получается объединение типов, а не кортеж. T[number] объединяет типы всех элементов.Чему равны
A и B?interface User {
id: number;
name: string;
active: boolean;
}
type A = User['id' | 'name'];
type B = User[keyof User];A = number | string,B = number | string | booleanA = number & string,B = never- Ошибка: в индексном доступе нельзя использовать объединение
A = { id: number; name: string },B = User
Индексный доступ распределяется по объединению ключей:
User["id" | "name"] = User["id"] | User["name"]. User[keyof User] — объединение типов всех свойств. Чтобы получить объект только с нужными полями, нужен не индексный доступ, а Pick<User, "id" | "name">.Чему равен
F?type Flags<T> = { [K in keyof T]: boolean };
type F = Flags<{ readonly a: string; b?: number }>;{ a: boolean; b?: boolean }{ readonly a: boolean; b: boolean | undefined }{ a: boolean; b: boolean }{ readonly a: boolean; b?: boolean }
Mapped-тип вида
{ [K in keyof T]: ... } называется гомоморфным: он сохраняет модификаторы readonly и ? исходных свойств, меняется только тип значения. Снять модификаторы можно через -readonly и -? (так устроен Required<T>).Какой тип получится у
Point?type Axis = 'x' | 'y' | 'z';
type Point = { [K in Axis]: number };number[]{ [key: string]: number }{ x: number; y: number; z: number }{ x?: number; y?: number; z?: number }
[K in Axis] перебирает каждый член объединения и создаёт свойство с таким именем — это базовая форма mapped-типа. Полученные свойства обязательные. Ровно так определён Record<K, T>: { [P in K]: T }.Что выдаст
tsc с флагом noPropertyAccessFromIndexSignature: true?interface Env {
NODE_ENV: string;
[key: string]: string;
}
declare const env: Env;
const a = env.NODE_ENV; // A
const b = env.API_KEY; // B
const c = env['API_KEY']; // C- Ошибки в B и C
- Ошибка только в B
- Ошибки в A и B
- Ошибок нет
Флаг требует, чтобы ключи, известные только через индексную сигнатуру, читались через скобки:
env["API_KEY"], — так в коде видно, что поля может не быть. Явно объявленное NODE_ENV можно читать через точку.Где ошибка?
interface Names {
readonly [i: number]: string;
}
const names: Names = ['Аня', 'Борис'];
console.log(names[0]); // A
names[1] = 'Вера'; // B- Только в B
- В A и B
- Ошибок нет
- В A: массив нельзя присвоить интерфейсу
Индексная сигнатура может быть
readonly: читать по индексу можно, записывать — нет («Index signature in type Names only permits reading»). Массив структурно подходит под { readonly [i: number]: string }. По сути так устроен ReadonlyArray<T>.Модули10
Что верно про
import type { User } from "./user"?- Он загружает модуль лениво, при первом использовании
User - Импорт сохраняется в JS, но значение
Userбудетundefined - Это то же, что
import { User }, просто подсказка для IDE - Импорт полностью удаляется из JS, а
Userможно использовать только как тип
import type гарантированно стирается при компиляции — модуль ./user не будет загружен ради этого импорта, а имя User доступно только в позициях типов. Обычный import { User } тоже удалится, если User используется только как тип, но это решение принимает компилятор (и на него влияют verbatimModuleSyntax/isolatedModules).Где ошибка?
// user.ts: export class User { name = 'Аня' }
import type { User } from './user';
const a: User = { name: 'Борис' }; // A
const b = new User(); // B- В A и B: импортирован только тип
- Ошибок нет
- Только в B
- Только в A
После
import type класс User доступен только как тип — в строке A это нормально (литерал структурно подходит). Но new User() использует класс как значение, а оно не импортировано: «User cannot be used as a value because it was imported using import type». Если нужен и тип, и конструктор, используйте обычный импорт.Какая строка не скомпилируется при
verbatimModuleSyntax: true?// types.ts: export interface User { name: string }
// export const VERSION = 1;
import { User, VERSION } from './types'; // A
import { type User as U, VERSION as V } from './types'; // B- B —
typeнельзя писать внутри фигурных скобок - A — тип
Userнужно импортировать как type-only - Обе
- Ни одна
При
verbatimModuleSyntax компилятор не удаляет импорты по своему усмотрению: всё, что без модификатора type, останется в JS как есть. Импорт интерфейса как значения тогда сломал бы рантайм, поэтому это ошибка (TS1484). Модификатор type можно ставить как на весь импорт (import type), так и на отдельные имена (import { type User, VERSION }).Что останется от этих импортов в JS при
verbatimModuleSyntax: true?import { type User } from './types';
import type { Config } from './config';
import { api, type Api } from './api';import {} from './types';иimport { api } from './api';- Все три строки без изменений
- Ничего: неиспользуемые импорты удаляются
- Только
import { api } from './api';
С
verbatimModuleSyntax правило простое: удаляется только то, что помечено type. import type {...} исчезает целиком, а import { type User } теряет лишь User — сам оператор остаётся (import {} from "./types"), и модуль выполнится ради побочных эффектов. Чтобы не загружать модуль, пишите import type.Что сегодня рекомендуется использовать для организации кода вместо
namespace (бывших «internal modules»)?declare moduleв каждом файле- Тройные слэш-директивы
/// <reference path> - Глобальные интерфейсы с
declare global - Стандартные ES-модули:
import/exportна уровне файлов
namespace — наследие времён до ES-модулей: он компилируется в IIFE и объект в общей области видимости. Современный код организуют файлами-модулями с import/export, которые понимают бандлеры, Node и tree-shaking. namespace ещё встречается в .d.ts для описания глобальных библиотек и для слияния с функциями/классами.Зачем в этом файле нужна строка
export {}?export {};
declare global {
interface Window { appVersion: string }
}
window.appVersion = '1.0';- Чтобы экспортировать
Windowнаружу - Без неё
window.appVersionбудет иметь типany declare globalразрешён только в модуле, аexport {}делает файл модулем- Она ни на что не влияет, это вопрос стиля
Файл без
import/export считается скриптом, его объявления и так глобальные, а блок declare global (расширение глобальной области) допустим только внутри модуля — иначе ошибка «Augmentations for the global scope can only be directly nested in external modules». Пустой export {} превращает файл в модуль, ничего не экспортируя.Что выдаст
tsc с isolatedModules: true?// types.ts: export interface User { name: string }
export { User } from './types'; // A
export type { User as U } from './types'; // B- Ошибок нет
- Ошибку в A: реэкспорт типа требует
export type - Ошибку в B:
export typeнельзя использовать сfrom - Ошибки в A и B
При
isolatedModules каждый файл должен транспилироваться отдельно (как в Babel, esbuild, swc). Глядя только на этот файл, транспилятор не знает, что User — интерфейс, и оставит реэкспорт в JS, а в рантайме такого экспорта нет. Поэтому реэкспорт типа нужно явно помечать export type.Что даёт объявление
declare module "*.svg"?// global.d.ts
declare module '*.svg' {
const src: string;
export default src;
}
// app.ts
import logo from './logo.svg';- Описывает тип любого импорта
*.svg: default-экспорт типаstring - Позволяет TypeScript читать и проверять содержимое SVG-файлов
- Отключает проверку типов во всех файлах, импортирующих
.svg - Генерирует модуль-заглушку для
.svgв рантайме
Объявления
declare module с шаблоном описывают типы модулей, которые TypeScript иначе не смог бы разрешить, — картинок, стилей и т.п., которые обрабатывает бандлер. Это только типы: сам файл загружает бандлер, а TypeScript лишь доверяет описанию. Сокращённая форма declare module "lib"; без тела делает все импорты из модуля типа any.Что выведет этот код?
namespace Utils {
export const version = 2;
const secret = 42;
export function double(n: number) { return n * 2; }
}
console.log(Utils.version, (Utils as any).secret, Utils.double(5));- Ошибка компиляции
- 2 null 10
- 2 42 10
- 2 undefined 10
namespace компилируется в IIFE, которая заполняет объект Utils: в него попадает только то, что помечено export. Неэкспортированная secret остаётся локальной переменной внутри функции и снаружи недоступна даже в рантайме.Что останется от строки
import в JS после компиляции (без verbatimModuleSyntax)?// types.ts: export interface User { name: string }
import { User } from './types';
const u: User = { name: 'Аня' };
console.log(u.name);const { User } = require('./types');import { User } from './types';без изменений- Ничего: импорт удаляется, так как
Userиспользуется только как тип import './types';— модуль загрузится ради побочных эффектов
По умолчанию TypeScript удаляет (elide) импорты, имена из которых используются только в позициях типов: интерфейса в JS нет, импортировать нечего. Побочные эффекты модуля при этом тоже не выполнятся. С
verbatimModuleSyntax такой импорт пришлось бы записать как import type.Дженерики20
Какой тип выведет TypeScript для
x?function first<T>(arr: T[]): T | undefined {
return arr[0];
}
const x = first([1, 'a']);anynumber | undefinedunknownstring | number | undefined
TypeScript выводит
T из аргумента: массив [1, "a"] имеет тип (string | number)[], значит T = string | number, а результат — T | undefined. Явно писать first<string | number>(...) не нужно — вывод из аргументов и есть основной способ работы с дженериками.Какой вызов не скомпилируется?
function len<T extends { length: number }>(x: T) {
return x.length;
}
len('abc'); // A
len([1, 2, 3]); // B
len(42); // C- Все скомпилируются
- A и C
- Только C
- Только B
Ограничение
T extends { length: number } разрешает любой тип с числовым свойством length: строки и массивы подходят структурно. У number свойства length нет — ошибка. Без ограничения не скомпилировалось бы уже обращение x.length внутри функции.Что выдаст компилятор?
function longest<T extends { length: number }>(a: T, b: T): T {
return a.length >= b.length ? a : b;
}
const r1 = longest([1, 2], [3]); // A
const r2 = longest('ab', [1]); // B- Ошибок нет, во втором вызове
Tвыведется какstring | number[] - Ошибка в B:
Tвыводится из первого аргумента, иnumber[]ему не подходит - Ошибка в A: массивы разной длины
- Ошибки в обеих строках
Оба параметра используют один
T, и из разных кандидатов (string и number[]) TypeScript не собирает объединение автоматически: он выбирает тип по первому аргументу (здесь даже литерал "ab") и сообщает, что number[] не подходит. В A оба аргумента — number[], всё в порядке. Если нужны разные типы, вводят два параметра или указывают longest<string | number[]>(...) явно.Что не так с этой функцией?
function makeEntity<T extends { id: number }>(): T {
return { id: 1 }; // A
}- Ошибка в A:
Tможет оказаться более узким подтипом, а литерал — лишь{ id: number } - Ограничение параметра типа не может быть объектным типом
- Ничего:
{ id: 1 }удовлетворяет ограничению - Дженерик-функция обязана принимать аргумент типа
T
Ограничение задаёт минимум, а конкретный
T выбирает вызывающий: makeEntity<{ id: number; name: string }>() ждёт объект с name, а вернётся { id: 1 }. Поэтому TypeScript пишет «is assignable to the constraint of type T, but T could be instantiated with a different subtype». Здесь дженерик не нужен — верните тип { id: number }.Где ошибка?
interface Box<T = string> {
value: T;
}
const a: Box = { value: 'ok' }; // A
const b: Box<number> = { value: 42 }; // B
const c: Box = { value: 42 }; // C- В A и C
- Ошибок нет
- В A: у
Boxнужно указать аргумент типа - Только в C
Параметр типа по умолчанию (
T = string) подставляется, когда аргумент типа не указан: Box без угловых скобок — это Box<string>. Поэтому { value: 42 } в строке C не подходит. В аннотации переменной TypeScript не выводит T из значения — он берёт значение по умолчанию.Какой тип у
n и что со строкой A?function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
const user = { id: 1, name: 'Аня' };
const n = getProp(user, 'name');
getProp(user, 'email'); // Astring; A компилируется и вернётundefinedstring | number; A компилируется и вернётundefinedstring; в A ошибка:"email"не является ключомuserany; в A ошибка
K extends keyof T ограничивает ключ существующими именами свойств, а T[K] даёт точный тип свойства для конкретного ключа: K выводится как "name", результат — string. Если бы возвращаемый тип был T[keyof T], получилось бы string | number.Что произойдёт при компиляции?
class Stack<T> {
private items: T[] = [];
push(x: T) { this.items.push(x); }
pop(): T | undefined { return this.items.pop(); }
}
const s = new Stack();
s.push(1);
s.push('a');- Ошибка на
s.push('a'):Tвыведен какnumberиз первогоpush - Компилируется:
sимеет типStack<unknown> - Компилируется:
sимеет типStack<any> - Ошибка на
new Stack(): требуется аргумент типа
Аргумент типа класса выводится только из аргументов конструктора. Здесь выводить не из чего, и
T становится unknown (не any), так что push принимает что угодно, а pop() вернёт unknown. Последующие вызовы методов на T уже не влияют. Пишите new Stack<number>().Какая сигнатура содержит лишний, ничего не дающий параметр типа?
function log<T extends string>(msg: T): voidfunction pair<A, B>(a: A, b: B): [A, B]function keys<T extends object>(o: T): (keyof T)[]function first<T>(arr: T[]): T
Правило: параметр типа полезен, если связывает хотя бы два места — например, вход и выход. В
log T встречается один раз, и сигнатура log(msg: string): void ведёт себя так же, но проще. В остальных вариантах параметры связывают аргументы с результатом.Что произойдёт?
function pair<A, B>(a: A, b: B): [A, B] {
return [a, b];
}
const p = pair<string>('x', 1); // A- Компилируется:
Bстанетunknown - Компилируется:
Bстанетstring, а на1будет ошибка - Компилируется:
Bвыведется какnumber - Ошибка: ожидалось 2 аргумента типа, а передан 1
В TypeScript нельзя указать часть аргументов типа, а остальные вывести: либо все выводятся, либо все задаются явно (кроме параметров со значением по умолчанию). Отсюда ошибка «Expected 2 type arguments, but got 1». Решение —
pair("x", 1) без угловых скобок или pair<string, number>(...).Какой тип у
t (TypeScript 5.x)?function tuple<const T extends readonly unknown[]>(x: T) {
return x;
}
const t = tuple(['a', 1]);(string | number)[][string, number]readonly ["a", 1]readonly (string | number)[]
Модификатор
const у параметра типа (TS 5.0) заставляет выводить T так, будто аргумент записан с as const: литеральные типы элементов и кортеж вместо массива. Ограничение readonly unknown[] нужно, чтобы readonly-кортеж ему удовлетворял. Без const получилось бы (string | number)[].Какой тип у
r?function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {
const res = {} as Pick<T, K>;
for (const k of keys) res[k] = obj[k];
return res;
}
const r = pick({ a: 1, b: 'x', c: true }, ['a', 'c']);{ a: number; b: string; c: boolean }{ a: number; c: boolean }Partial<{ a: number; b: string; c: boolean }>{ a: number | boolean; c: number | boolean }
Из массива
["a", "c"] TypeScript выводит K = "a" | "c" — благодаря ограничению K extends keyof T элементы не расширяются до string. Pick<T, K> оставляет только эти ключи с их исходными типами.Какие типы у
a и b?function identity<T>(x: T): T {
return x;
}
const a = identity('hi');
let b = identity('hi');a: "hi",b: stringa: string,b: stringa: "hi",b: "hi"a: unknown,b: unknown
Для
identity("hi") T выводится как литеральный тип "hi", но это «расширяемый» литерал. const сохраняет его, а let расширяет до string — точно так же, как при let b = "hi". Поведение совпадает с обычными переменными.Где ошибка?
type Fn1 = <T>(x: T) => T;
type Fn2<T> = (x: T) => T;
const f: Fn1 = (x) => x; // A
const g: Fn2 = (x) => x; // B
const h: Fn2<number> = (x) => x; // C- В B и C
- Только в A
- Ошибок нет
- Только в B
Fn1 — тип обобщённой функции: T выбирается при каждом вызове (f(1), f("a")). Fn2 — обобщённый псевдоним: T фиксируется при использовании типа, и без аргумента типа (и без значения по умолчанию) его использовать нельзя — «Generic type Fn2 requires 1 type argument(s)». Fn2<number> — обычная функция number → number.Что выдаст TypeScript 5.4+?
function createLight<C extends string>(colors: C[], def: NoInfer<C>) {}
createLight(['red', 'green'], 'green'); // A
createLight(['red', 'green'], 'blue'); // B- Ошибок нет:
Cвыведется как"red" | "green" | "blue" - Ошибки в A и B
- Ошибка только в B
- Ошибка:
NoInferнельзя использовать в параметрах
Без
NoInfer TypeScript собрал бы кандидатов из обоих аргументов и вывел C = "red" | "green" | "blue" — опечатка прошла бы. NoInfer<C> (TS 5.4) исключает этот параметр из вывода: C определяется только по colors, а def лишь проверяется.Что выдаст компилятор?
class Store<T> {
private data = new Map<string, T>();
static empty: T; // A
get(k: string): T | undefined { return this.data.get(k); }
}- Ошибка в A: статическое поле не инициализировано
- Ошибка в A: статические члены не могут ссылаться на параметр типа класса
- Ошибка:
Mapнельзя параметризовать черезT - Ошибок нет
Статические члены принадлежат самому классу, который один на все варианты
Store<string>, Store<number> и т.д., поэтому T в них не определён: «Static members cannot reference class type parameters». Экземплярные члены (data, get) параметр типа использовать могут.Чем
function wrap<T>(x: T): T[] лучше, чем function wrap(x: any): any[]?- Сохраняется связь типов: для
wrap(1)результат —number[], а неany[] - Только дженерик позволяет передавать объекты
- Ничем: после компиляции обе функции одинаковы
- Дженерик работает быстрее в рантайме
Дженерик сохраняет информацию о типе:
T выводится из аргумента и переносится в результат, так что дальше работают автодополнение и проверки. С any проверка типов фактически отключается. В JS обе функции действительно одинаковы — типы стираются, — но разница в том, что поймает компилятор.В файле
.tsx какая строка вызовет ошибку разбора?const id = <T>(x: T) => x; // A
const id2 = <T,>(x: T) => x; // B- B — висячая запятая в параметрах типа запрещена
- Обе
- Ни одна
- A —
<T>разбирается как начало JSX-тега
В
.tsx запись <T>(x: T) => ... начинается как JSX-элемент <T>, и парсер ломается. Висячая запятая <T,> (или <T extends unknown>) однозначно указывает на список параметров типа. В .ts-файлах обе формы корректны, а у обычных function этой проблемы нет.Какой вызов не скомпилируется?
function keysOf<T extends object>(o: T) {
return Object.keys(o);
}
keysOf({ a: 1 }); // A
keysOf([1, 2]); // B
keysOf(() => 1); // C
keysOf('str'); // D- B и D
- C и D
- Только D
- Все скомпилируются
object — это любой непримитивный тип: обычные объекты, массивы, функции. Строка — примитив, поэтому keysOf("str") не проходит ограничение. Не путайте с {}, которому строка как раз подходит.Чему равны
A и B?type ToArray<T> = T extends unknown ? T[] : never;
type ToArrayBox<T> = [T] extends [unknown] ? T[] : never;
type A = ToArray<string | number>;
type B = ToArrayBox<string | number>;A=(string | number)[],B=string[] | number[]A=string[] | number[],B=(string | number)[]- Оба равны
(string | number)[] - Оба равны
string[] | number[]
Условный тип вида
T extends ..., где T — «голый» параметр типа, дистрибутивен: для объединения он применяется к каждому члену отдельно, и результаты объединяются — string[] | number[]. Если обернуть параметр в кортеж ([T] extends [unknown]), распределения нет, и объединение проверяется целиком — получается (string | number)[].Чему равны
A и B?type A = Awaited<Promise<Promise<string>>>;
type B = Awaited<number>;A = Promise<string>,B = neverA = string,B = numberA = string,B = never- Ошибка компиляции:
Awaitedпринимает толькоPromise
Awaited<T> моделирует await: рекурсивно разворачивает вложенные промисы (и любые thenable), поэтому Promise<Promise<string>> превращается в string. Ограничения на T у него нет: для не-промиса тип возвращается как есть, как и await 5 даёт number.keyof и typeof15
Чему равен
K?type Dict = { [key: string]: boolean };
type K = keyof Dict;stringstring | numberneverstring | number | symbol
Для строковой индексной сигнатуры
keyof даёт string | number, потому что в JS числовые ключи — тоже строки: dict[0] эквивалентно dict["0"]. Для { [key: number]: T } keyof дал бы только number. А string | number | symbol — это keyof any.Чему равны
K1 и K2?type A = { id: number; a: string };
type B = { id: number; b: string };
type K1 = keyof (A | B);
type K2 = keyof (A & B);K1 = "id",K2 = "id" | "a" | "b"- Оба равны
"id" | "a" | "b" - Оба равны
"id" K1 = "id" | "a" | "b",K2 = "id"
О значении типа
A | B известно лишь то, что есть у обоих вариантов, поэтому keyof объединения — общие ключи ("id"). Значение A & B имеет все свойства обоих типов, и keyof пересечения — объединение ключей. Звучит «наоборот», но логично: keyof (A | B) = keyof A & keyof B.Чему равен тип
Config?const config = { port: 3000, host: 'localhost', debug: false };
type Config = typeof config;"object"{ readonly port: 3000; readonly host: "localhost"; readonly debug: false }{ port: 3000; host: "localhost"; debug: false }{ port: number; host: string; debug: boolean }
typeof в позиции типа берёт выведенный тип переменной. Свойства объектного литерала изменяемы, поэтому литералы расширяются: 3000 → number, "localhost" → string. Литеральные readonly-типы получились бы с as const. А строку "object" вернул бы JS-оператор typeof в выражении.Чему равен тип
Role?const roles = ['admin', 'editor', 'user'] as const;
type Role = (typeof roles)[number];["admin", "editor", "user"]string"admin" | "editor" | "user"readonly string[]
as const делает массив readonly-кортежем литералов, typeof roles даёт его тип, а [number] — тип любого элемента, т.е. объединение литералов. Без as const массив был бы string[], и Role стал бы просто string. Стандартный приём: один массив и для рантайма, и для типа.Какая строка корректна?
function createUser(name: string) {
return { name, createdAt: new Date() };
}
type U1 = ReturnType<createUser>; // A
type U2 = ReturnType<typeof createUser>; // B- Обе строки корректны
- Только B
- Только A
- Обе ошибочны:
ReturnTypeработает только с объявленными типами функций
createUser — значение (функция), а дженерику нужен тип. typeof createUser превращает значение в тип (name: string) => { name: string; createdAt: Date }, и ReturnType извлекает из него тип результата. Строка A даёт ошибку «createUser refers to a value, but is being used as a type here».Какой вызов не скомпилируется?
const colors = { red: '#f00', green: '#0f0' };
type Color = keyof typeof colors;
function paint(c: Color) {}
paint('red'); // A
paint('blue'); // B- Только B
- Оба: нужно передавать значения вроде
"#f00" - Оба:
keyof typeof— неверный синтаксис - Оба скомпилируются:
Color— этоstring
typeof colors даёт тип объекта, а keyof от него — объединение имён ключей: "red" | "green". Это ключи, а не значения: значения получают через (typeof colors)[keyof typeof colors], и для литеральных значений нужен ещё as const.Почему строка A не компилируется в режиме
strict?const user = { id: 1, name: 'Аня' };
Object.keys(user).forEach((k) => {
console.log(user[k]); // A
});kимеет типnever- Внутри колбэка
userнедоступен из-за замыкания forEachнельзя вызывать у результатаObject.keysObject.keysвозвращаетstring[], а произвольную строку нельзя использовать как ключuser
Object.keys намеренно типизирован как string[]: из-за структурной типизации у объекта могут быть свойства сверх объявленных, так что (keyof T)[] было бы неправдой. Обращение user[k] со string даёт неявный any — ошибка при noImplicitAny. Обходят приведением k as keyof typeof user или через Object.entries.Чему равен
R?function parse(x: string): number;
function parse(x: number): string;
function parse(x: any): any {
return x;
}
type R = ReturnType<typeof parse>;number | stringnumberstringany
У перегруженной функции
typeof parse содержит несколько сигнатур, а ReturnType (как и любой вывод через infer) берёт последнюю перегрузку — (x: number): string. Сигнатура реализации (any) снаружи не видна вовсе.Чему равен
K?class User {
id = 1;
private secret = 'x';
protected role = 'user';
#token = 't';
greet() {}
}
type K = keyof User;"id" | "secret" | "role" | "greet""id" | "greet""id" | "greet" | "#token""id"
keyof от типа экземпляра класса возвращает только публичные члены — поля и методы. private/protected члены в него не попадают, а #-поля вообще не считаются свойствами на уровне типов. Статические члены тоже не входят: они в keyof typeof User.Что выведет этот код?
const user = { id: 1 };
type U = typeof user;
const t = typeof user;
console.log(t);objectUundefined{ id: number }
typeof работает двояко: в позиции типа (type U = typeof user) это оператор TypeScript, который стирается при компиляции, а в выражении — обычный JS-оператор, возвращающий строку вроде "object", "string", "function".Что верно про эти строки?
function getUser() {
return { id: 1, name: 'Аня' };
}
type U1 = typeof getUser(); // A
type U2 = ReturnType<typeof getUser>; // B- A корректна, B — ошибка
- Обе — ошибки
- Обе корректны и дают одинаковый тип
- A — ошибка, B корректна
typeof в позиции типа принимает только имя или цепочку доступа к свойствам (typeof obj.a.b), но не выражение с вызовом — «выполнить» функцию на уровне типов так нельзя. Тип результата получают через ReturnType<typeof getUser>.Чему равен
K?const obj = { 1: 'a', b: 'c' };
type K = keyof typeof obj;number | "b""1" | "b"1 | "b"string
Числовые ключи в объектном литерале TypeScript сохраняет как числовые литеральные типы, поэтому
keyof даёт 1 | "b", хотя в рантайме Object.keys(obj) вернёт ["1", "b"]. Это одна из причин, почему keyof T в общем случае — не только string.Чему равен
K?type K = keyof any;neverstring | number | symbolstring | numberstring
Ключом свойства в JS может быть строка, число (преобразуется в строку) или символ, поэтому
keyof any — string | number | symbol. Встроенный тип PropertyKey — то же самое; его используют в ограничениях вроде K extends PropertyKey (так объявлен Record).Чему равен тип
Status и скомпилируется ли код?const Status = {
Active: 'active',
Banned: 'banned',
} as const;
type Status = (typeof Status)[keyof typeof Status];
let s: Status = 'active';"active" | "banned"; компилируется — значение и тип могут называться одинаково"Active" | "Banned"; компилируетсяstring; компилируется"active" | "banned"; ошибка: дублирующийся идентификаторStatus
keyof typeof Status — ключи "Active" | "Banned", а индексный доступ по ним даёт объединение значений; благодаря as const это литералы, а не string. Значения и типы живут в разных пространствах имён, поэтому константа и тип Status могут называться одинаково — популярная альтернатива enum.Что выдаст компилятор?
function toUpper<T>(key: keyof T) {
const s: string = key; // A
return s.toUpperCase();
}- Ошибку:
keyofнельзя применять к параметру типа - Ошибку: у
keyof Tнет методаtoUpperCase - Ничего: ключи объектов всегда строки
- Ошибку в A:
keyof Tможет включатьnumberиsymbol
Для произвольного
T keyof T — подтип string | number | symbol, а не только string. Нужно сузить: Extract<keyof T, string>, K & string или String(key).Как проходить тест
- Выберите темы и уровень — Junior проверяет основы, Middle — повседневные детали, Senior — тонкости и неочевидное поведение языка.
- Отвечайте касанием или с клавиатуры: 1–4 или A–D, Enter — следующий вопрос.
- Читайте объяснения — после ошибки разбор открывается сразу, после верного ответа его можно раскрыть кнопкой «Почему».
- Работайте над ошибками — «Повторить ошибки» в конце теста или режим «Только мои ошибки» потом: ответы запоминаются в этом браузере.
Незавершённый тест сохраняется — после перезагрузки страницы можно продолжить с того же вопроса.
Темы теста
- Базовые типы 14
- Вывод типов 13
- Объединения и пересечения 14
- Сужение типов 17
- any, unknown и never 15
- Функции 17
- Перечисления и кортежи 17
- Интерфейсы и type 13
- Структурная типизация 10
- Классы 22
- Индексные типы 13
- Модули 10
- Дженерики 20
- keyof и typeof 15
Другие тесты
Тест по Ruby414 вопросовТест по SQL410 вопросовТест по JavaScript440 вопросовТест по jQuery110 вопросовТест по PHP410 вопросовТест по Symfony64 вопросаТест по Laravel30 вопросовТест по Python410 вопросовТест по Go410 вопросовТест по React410 вопросовТест по Java115 вопросовТест по C#65 вопросовТест по HTML210 вопросовТест по CSS210 вопросовТест по ООП50 вопросовТест по Git50 вопросовТест по QA40 вопросовТест по Zig115 вопросов
