TS TypeScript · 25 вопросов · ~70 мин · ⏱ Таймер 10:00 · Средний ·

Отображаемые типы

Разбирает тему «Отображаемые типы» на практических сценариях: поиск дефектов, сравнение решений и оценка последствий. Вопросы требуют читать код, сопоставлять статические гарантии с поведением JavaScript и выбирать решение, которое не рассыплется при развитии проекта.

Отвечено: 0 из 25

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 25 вопросов отведено 70 минут. Код читайте построчно: часть заданий проверяет не результат JavaScript, а то, что TypeScript способен доказать до запуска.

Вопрос 1 из 25

Что создаёт mapped type Flags<T>?

type Flags<T> = { [K in keyof T]: boolean };
type UserFlags = Flags<{ id: string; active: boolean }>;

keyof T { id: boolean; active: boolean } boolean[] { id: string; active: boolean } { K: boolean }

Вопрос 2 из 25

Почему K можно использовать для T[K]?

type Clone<T> = { [K in keyof T]: T[K] };

В каждой итерации K — конкретный ключ T Mapped type копирует значения объекта T[K] всегда unknown keyof создаёт массив ключей K является runtime-переменной

Вопрос 3 из 25

Какой тип делает каждое поле getter-функцией?

type Getters<T> = {
  [K in keyof T]: () => T[K]
};

Тип удаляет optional-поля всегда Для каждого K создаётся функция () => T[K] Все поля становятся () => T Функции выполняются при компиляции Ключи превращаются в числа

Вопрос 4 из 25

Когда mapped type лучше ручного перечисления полей?

Когда нужен runtime-объект Когда поля имеют независимые предметные правила Когда исходный тип неизвестен внешним данным Когда достаточно одного поля Когда контракт механически следует всем ключам исходного

Вопрос 5 из 25

Почему mapped type не создаёт объект значений?

Потому что keyof запрещает объекты Потому что значения автоматически undefined Потому что type alias выполняется один раз Он существует только в системе типов Потому что mapped types работают только с interfaces

Вопрос 6 из 25

В показанном фрагменте что делает -readonly?

type Mutable<T> = { -readonly [K in keyof T]: T[K] };
type A = Mutable<{ readonly id: string }>;

Добавляет readonly Делает id optional Преобразует id в never Снимает readonly: id становится изменяемым Удаляет поле id

Вопрос 7 из 25

Что делает -? в Concrete<T>?

type Concrete<T> = { [K in keyof T]-?: T[K] };
type A = Concrete<{ name?: string }>;

Превращает тип в tuple Удаляет undefined из любых union автоматически Делает поле readonly Удаляет имя свойства Удаляет optional-модификатор, делая name обязательным

Вопрос 8 из 25

Как одновременно сделать поля readonly и optional?

type Snapshot<T> = /* ? */;

{ [K: string]: never } Readonly<T> & Required<T> { -readonly [K in keyof T]-?: T[K] } { readonly [K in keyof T]?: T[K] } T[keyof T][]

Вопрос 9 из 25

Почему Required<T> не всегда делает значение фактически присутствующим в runtime?

Он меняет статический контракт Он запрещён с exactOptionalPropertyTypes Он работает только с классами Он удаляет все undefined-значения во время выполнения Required выполняет Object.assign

Вопрос 10 из 25

Какой риск у массового Mutable<T> в API?

Он работает только с массивами Он удаляет методы Он делает типы номинальными Mutable замедляет JavaScript Он обещает изменяемость фактически readonly-данных

Вопрос 11 из 25

Какие ключи создаёт Getters<T>?

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};
type UserGetters = Getters<{ name: string; age: number }>;

Только getName Ключи удаляются getName и getAge getstring и getnumber name и age без изменений

Вопрос 12 из 25

Как отфильтровать ключ kind?

type RemoveKind<T> = {
  [K in keyof T as K extends "kind" ? never : K]: T[K]
};

Сделать kind optional Использовать K | never Преобразовать нежелательный ключ в never Назначить его значению never Добавить readonly

Вопрос 13 из 25

Почему string & K используется в Capitalize?

type Events<T> = {
  [K in keyof T as `on${Capitalize<string & K>}`]: (value: T[K]) => void
};

Чтобы получить intersection значений Чтобы сделать K optional Чтобы удалить все string-ключи Чтобы выполнить приведение в runtime Чтобы оставить строковую часть ключей

Вопрос 14 из 25

Какой риск у сложного автоматического переименования ключей?

Имена становятся непредсказуемыми, ошибки — длинными Ключи исчезают из JavaScript Все методы становятся async Mapped type изменяет исходный объект Переименование запрещает export

Вопрос 15 из 25

Как проверить key remapping при добавлении symbol-ключа?

Считать, что Capitalize поддерживает symbol Зафиксировать судьбу symbol: сохранить, убрать или отделить Привести keyof T к any Проверить только runtime Object.keys Игнорировать symbol без решения

Вопрос 16 из 25

В показанном фрагменте что описывает Patch<T>?

type Patch<T> = {
  [K in keyof T]?: T[K]
};

Runtime-функцию обновления Union всех значений T Объект с необязательными полями T Полную копию T Массив ключей

Вопрос 17 из 25

Как сделать только выбранные ключи optional?

type OptionalKeys<T, K extends keyof T> =
  Omit<T, K> & Partial<Pick<T, K>>;

Сделать результат union Заменить K на string Применить Partial<T> ко всем полям Partial только для K, остальные поля без изменений Использовать T[K] как объект

Вопрос 18 из 25

Почему Events<T> сохраняет тип аргумента каждого обработчика?

type Events<T> = {
  [K in keyof T as `on${Capitalize<string & K>}`]: (value: T[K]) => void
};

Все обработчики получают T целиком T[K] сохраняет тип исходного поля Capitalize определяет тип значения Mapped type запускает обработчики Аргумент всегда string

Вопрос 19 из 25

Когда производный mapped-контракт может стать опасным?

Когда mapped type имеет имя Когда исходник содержит непубличные поля Когда поля readonly Когда используется interface Когда в исходном типе меньше трёх ключей

Вопрос 20 из 25

Как удержать производный контракт понятным?

Не писать type tests Скрыть его за буквой M Дать предметное имя, ограничить вход и показать ключи Экспортировать все промежуточные helpers Добавить несколько any

Вопрос 21 из 25

Какой результат нужно зафиксировать для Mutable<Readonly<User>>, чтобы тест проверял снятие модификатора readonly?

type Mutable<T> = { -readonly [K in keyof T]: T[K] };
type User = { readonly id: string; readonly name: string };

Ключи становятся optional id и name становятся изменяемыми без смены типов Тип превращается в Record<string, unknown> Свойства удаляются из типа Все значения превращаются в string

Вопрос 22 из 25

Какой ключ должен отсутствовать в типе PublicUser после переименования ключей через as?

type PublicUser<T> = {
  [K in keyof T as K extends "passwordHash" ? never : K]: T[K]
};

displayName passwordHash keyof PublicUser createdAt id

Вопрос 23 из 25

Почему тест mapped type должен включать optional и readonly свойства одновременно?

Optional-свойство меняет порядок ключей Readonly-свойства существуют только во время выполнения TypeScript проверяет модификаторы только парами Одно свойство всегда становится any Чтобы увидеть, какие модификаторы сохраняются или меняются

Вопрос 24 из 25

После рефакторинга key remapping два исходных ключа стали отображаться в один новый ключ. Что должен проверить тест?

Порядок ключей совпадает с исходным объектом Сгенерированный JavaScript содержит два свойства Компилятор выбирает первый ключ по алфавиту Как разрешается столкновение двух ключей в одном новом Один из ключей автоматически удаляется без изменения типа

Вопрос 25 из 25

Какой набор примеров лучше проверяет производный контракт Update<T>?

Разрешить patch полей, запретить readonly id и чужой ключ Передать объект через any Сравнить Update<T> с исходным T по имени Запустить один runtime-тест без компиляции Проверить только пустой объект

Ответьте на все 25 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу