JS JavaScript · 30 вопросов · ~85 мин · ⏱ Таймер 25:00 · Сложный ·

Proxy, Reflect и метапрограммирование

Профессиональный тест о ловушках Proxy, Reflect API, языковых инвариантах и практических ограничениях метапрограммирования. Вопросы требуют предсказать receiver, поведение private fields, перечисление ключей и причины TypeError при нарушении правил целевого объекта.

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

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. В тесте 30 вопросов и 85 минут; код лучше читать построчно, не полагаясь на первое впечатление. После завершения откроются общий процент, 6 тематических шкал и объяснение каждого решения.

Вопрос 1 из 30

Какой trap вызывается выражением key in proxy?

const proxy = new Proxy(target, {
  has(target, key) { return Reflect.has(target, key); }
});
console.log("id" in proxy);

ownKeys defineProperty get has apply

Вопрос 2 из 30

Какой результат даст get с запасным 0?

const p = new Proxy({}, {
  get(target, key, receiver) {
    return Reflect.has(target, key) ? Reflect.get(target, key, receiver) : 0;
  }
});
console.log(p.missing);

false 0 TypeError Свойство создастся на target undefined

Вопрос 3 из 30

Что должен вернуть set trap при успешной записи?

"use strict";
const p = new Proxy({}, {
  set(target, key, value, receiver) {
    Reflect.set(target, key, value, receiver);
    return false;
  }
});
p.x = 1;

true Дескриптор target Записанное значение undefined обязательно

Вопрос 4 из 30

Как перехватить вызов proxy как функции?

const logged = new Proxy(sum, {
  apply(target, thisArg, args) {
    console.log(args);
    return Reflect.apply(target, thisArg, args);
  }
});

call construct apply getPrototypeOf has

Вопрос 5 из 30

Какой trap отвечает за Object.keys и Reflect.ownKeys?

const proxy = new Proxy(target, {
  ownKeys(target) { return Reflect.ownKeys(target); }
});
Object.keys(proxy);

has setPrototypeOf isExtensible get ownKeys

Вопрос 6 из 30

Почему в get trap лучше Reflect.get(target,key,receiver), а не target[key]?

const target = { get total() { return this.price * this.count; }, price: 2, count: 3 };
const p = new Proxy(target, { get: Reflect.get });

receiver сохраняет корректный this getter и наследование через proxy Reflect.get автоматически кэширует результат каждого свойства Метод создаёт глубокую копию возвращаемого значения Reflect.get преобразует любой строковый ключ в Symbol Синтаксис target[key] запрещён внутри trap get

Вопрос 7 из 30

Что возвращает Reflect.defineProperty при невозможной операции?

const frozen = Object.freeze({ x: 1 });
console.log(Reflect.defineProperty(frozen, "x", { value: 2 }));

Старый дескриптор Всегда бросает исключение false, позволяя вызывающему решить реакцию Новый объект undefined

Вопрос 8 из 30

Чем Reflect.construct(Target,args,NewTarget) полезен?

const handler = {
  construct(target, args, newTarget) {
    return Reflect.construct(target, args, newTarget);
  }
};

Он вызывает конструктор без создания нового объекта Метод клонирует класс вместе со всеми статическими полями Reflect.construct поддерживает только встроенный Date Создаёт как new Target и позволяет отдельно задать NewTarget Reflect.construct вызывает функцию как обычную, обходя new

Вопрос 9 из 30

Что вернёт Reflect.deleteProperty для non-configurable свойства?

const target = {};
Object.defineProperty(target, "id", { value: 7, configurable: false });
console.log(Reflect.deleteProperty(target, "id"));

TypeError всегда null false Дескриптор true и удалит

Вопрос 10 из 30

Почему Reflect.apply безопаснее target.apply в универсальной обёртке?

Любой вызов через Reflect автоматически становится async Обычные функции JavaScript не имеют метода apply Свойство target.apply может быть подменено, Reflect вызывает операцию напрямую Reflect.apply копирует функцию перед каждым вызовом Метод запрещает передавать thisArg вызываемой функции

Вопрос 11 из 30

Что произойдёт, если get trap солжёт о non-writable non-configurable data property?

const target = {};
Object.defineProperty(target, "x", { value: 1, writable: false, configurable: false });
const p = new Proxy(target, { get() { return 2; } });
console.log(p.x);

Будет TypeError Свойство автоматически станет configurable Ложь допустима только в strict mode Target изменится Вернётся ложное значение

Вопрос 12 из 30

Можно ли ownKeys скрыть non-configurable ключ?

const target = {};
Object.defineProperty(target, "fixed", { configurable: false });
const p = new Proxy(target, { ownKeys() { return []; } });
Reflect.ownKeys(p);

Да, если trap возвращает только перечислимые ключи объекта Да, если get возвращает undefined Нет, движок проверит список и бросит TypeError Только если ключ Symbol Скрытие подействует на Object.keys, а Reflect.ownKeys восстановит исходный список

Вопрос 13 из 30

Что нельзя сообщить isExtensible trap?

true для расширяемого target Фактическое значение Reflect.isExtensible(target) Значение, противоположное фактическому состоянию target Boolean false после preventExtensions

Вопрос 14 из 30

Может ли defineProperty trap вернуть true, не создавая новое свойство на non-extensible target?

Да, Proxy виртуален полностью Да, если ключ строковый и дескриптор не содержит value Нет, это нарушит инвариант и вызовет TypeError Да в sloppy mode Только если value undefined

Вопрос 15 из 30

Почему нельзя сделать non-configurable свойство configurable через getOwnPropertyDescriptor trap?

Свойство configurable всегда true у всех собственных свойств Изменять configurable разрешено только для ключей Symbol Trap getOwnPropertyDescriptor не перехватывается объектом Proxy При несовпадении descriptor trap возвращает null без ошибки Это нарушит необратимое ограничение target и приведёт к TypeError

Вопрос 16 из 30

Почему метод с #private может упасть на proxy?

class Counter {
  #n = 1;
  value() { return this.#n; }
}
const p = new Proxy(new Counter(), {});
p.value();

Proxy удаляет методы класса при первом чтении свойства Private fields поддерживаются только Node.js, но не браузером Любое поле с # автоматически является статическим this становится proxy без private brand исходного экземпляра Reflect API блокирует методы классов с private fields

Вопрос 17 из 30

Почему Map.prototype.get может сообщить incompatible receiver на proxy?

const map = new Map([["x", 1]]);
const p = new Proxy(map, {});
console.log(p.get("x"));

Методы Map требуют внутренние слоты, которых нет у proxy-receiver Proxy не позволяет передавать строковые ключи в Map Map работает только после Object.freeze экземпляра Коллекция Map не является объектом JavaScript У Proxy отсутствует trap get для чтения методов

Вопрос 18 из 30

Равен ли proxy своему target через ===?

const target = {};
const p = new Proxy(target, {});
console.log(p === target);

Только без handler Зависит от get trap Только после Object.freeze Нет, это отдельная объектная идентичность Да

Вопрос 19 из 30

Можно ли узнать target произвольного Proxy стандартным API?

Да через valueOf всегда Да через JSON.stringify Да, Reflect.unwrap Да, Proxy.target Нет, если код сам не сохранил связь

Вопрос 20 из 30

Как JSON.stringify взаимодействует с Proxy?

JSON.stringify читает target напрямую, но вызывает trap get для метода toJSON JSON.stringify игнорирует все свойства, доступные через Proxy Сериализация автоматически снимает Proxy и берёт только target Handler и target сериализуются как два отдельных объекта Обычные чтения и перечисление вызывают соответствующие traps

Вопрос 21 из 30

Почему get trap вызывает бесконечную рекурсию?

const p = new Proxy({}, {
  get(target, key, receiver) {
    return receiver[key];
  }
});
p.x;

Чтение receiver[key] снова запускает тот же get trap console.log запрещено вызывать из get trap Ключ свойства обязан быть числом, а не строкой Reflect.get всегда рекурсивно обращается к тому же Proxy Причина в том, что target автоматически равен null

Вопрос 22 из 30

Что делает Proxy.revocable после revoke?

const { proxy, revoke } = Proxy.revocable({ x: 1 }, {});
revoke();
console.log(proxy.x);

Переключает handler на пустой Удаляет только новые свойства Большинство операций через proxy бросают TypeError Возвращает target Замораживает handler

Вопрос 23 из 30

Как проверить, что readonly proxy действительно закрывает запись?

expect(() => { readonly.user = "Ada"; }).toThrow();
expect(target.user).toBe("Lin");

Проверить только чтение одного свойства через get Сериализовать объект JSON.stringify и сравнить строку Сравнить число свойств в handler до и после записи Проверить set, defineProperty, deleteProperty и вложенность по контракту Проверить лишь p.x = 1 в sloppy mode без результата

Вопрос 24 из 30

Почему логирование всех get само создаёт шум и искажение?

Инспекторы читают служебные свойства, а logger может снова трогать proxy Console API не принимает ключи свойств типа Symbol Trap get вызывается только при явном чтении пользовательским кодом Proxy автоматически отключает DevTools при активном handler Записи консоли откладываются, поэтому порядок чтений свойств в журнале меняется

Вопрос 25 из 30

Какой тест нужен для ownKeys trap кроме Reflect.ownKeys?

Сделать один fetch-запрос после перечисления ключей Проверить только результат оператора instanceof Сложить числовые значения всех собственных свойств Выполнить единственный await перед вызовом Reflect.ownKeys Проверить Object.keys, spread/assign и descriptors с их фильтрацией

Вопрос 26 из 30

Почему Proxy в горячем доступе может замедлить код?

for (let i = 0; i < 10_000_000; i++) {
  sum += proxiedPoint.x;
}

Любой trap всегда отправляет сетевой запрос Handler выполняется в отдельном системном процессе Наличие Proxy полностью отключает сборщик мусора Динамический перехват затрудняет JIT предсказывать форму объекта Trap get создаёт новый дескриптор свойства при каждом чтении

Вопрос 27 из 30

Когда обычный метод setName лучше set trap?

Когда предметное изменение должно быть явным, тестируемым и анализируемым Когда изменение имени выполняется до передачи объекта внешнему коду Когда имя изменяемого свойства хранится только в Symbol Никогда: set trap во всех случаях понятнее обычного метода Когда метод не содержит ни одной исполняемой инструкции

Вопрос 28 из 30

Как избежать создания нового proxy для одного target много раз?

Использовать global array без удаления Записывать proxy в JSON Вызывать revoke сразу Сравнивать handler по строке Хранить кэш target→proxy в WeakMap

Вопрос 29 из 30

Почему глубокое ленивое проксирование требует кэша вложенных объектов?

Все вложенные объекты JavaScript всегда неизменяемы Стандарт запрещает вкладывать один Proxy в другой Кэш нужен, чтобы строки и числа не оборачивались повторно при чтении Reflect автоматически создаёт WeakMap-кэш вложенных объектов Иначе повторное чтение даёт новые proxy-ссылки и лишний мусор

Вопрос 30 из 30

Как ограничить риск метапрограммирования в проекте?

Удалить типы и статический анализ вокруг Proxy-кода Глобально оборачивать все объекты приложения одним handler Использовать traps напрямую и не делегировать через Reflect Изолировать Proxy в малом модуле с тестами инвариантов и обычным API Не документировать метапрограммирование, чтобы скрыть сложность

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

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

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

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