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

Функциональный стиль в JavaScript

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

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

⏱ --:--

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

Вопрос 1 из 30

Что вернёт makeAdder(2)(5)?

const makeAdder = x => y => x + y;
console.log(makeAdder(2)(5));

undefined 10 5 7 2

Вопрос 2 из 30

Чем частичное применение отличается от каррирования?

const partial = (fn, ...fixed) => (...rest) => fn(...fixed, ...rest);
const add3 = (a, b, c) => a + b + c;
const add1 = partial(add3, 1);

Оба термина всегда обозначают одну и ту же форму вызова Каррирование требует, чтобы исходная функция принимала аргументы одного типа Каррированная функция обязательно выполняет внешний I/O Partial фиксирует часть аргументов, curry создаёт цепочку унарных функций Частичное применение не может использовать замыкания

Вопрос 3 из 30

Почему Array.prototype.map ожидает чистый callback не формально, а практически?

let total = 0;
const prices = items.map(item => {
  total += item.price;
  return item.price;
});

Наличие побочного эффекта внутри map приводит к SyntaxError map автоматически откатывает любые эффекты после построения массива Чистая функция гарантированно выполняется быстрее нечистой Эффекты зависят от порядка и повторов, усложняя проверку преобразования Callback map не может замыкать значения из внешней области

Вопрос 4 из 30

Какой comparator нарушает контракт Array.prototype.sort?

const values = [3, 1, 2];
values.sort(/* выберите comparator из вариантов */);

(a, b) => b - a (a, b) => Math.random() - 0.5 (a, b) => a - b (a, b) => String(a).localeCompare(String(b)) (a, b) => (a === b ? 0 : a < b ? -1 : 1)

Вопрос 5 из 30

Когда функция высшего порядка ухудшает дизайн?

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

Вопрос 6 из 30

Изменится ли исходный user?

const user = { name: "A", address: { city: "Riga" } };
const next = { ...user };
next.address.city = "Tallinn";
console.log(user.address.city);

Только имя Возникнет TypeError Только при strict mode Да, address остаётся общей вложенной ссылкой Нет, spread сделал глубокую копию

Вопрос 7 из 30

Как обновить city, сохранив остальные ссылки там, где данные не менялись?

function renameCity(user, city) {
  // Выберите неизменяемое обновление только пути address.city.
}

return Object.freeze(user) return JSON.parse(JSON.stringify(user)) return structuredClone(user) всегда return { ...user, address: { ...user.address, city } } user.address.city = city; return user

Вопрос 8 из 30

Что защищает Object.freeze(user)?

const user = Object.freeze({ tags: [] });
user.tags.push("new");

Прототип user и все объекты в его цепочке Чтение свойств через ссылки из других модулей Весь граф вложенных объектов и массивов Только собственные свойства объекта user верхнего уровня Вложенные массивы, но не вложенные обычные объекты

Вопрос 9 из 30

Почему JSON-клонирование не универсальная глубокая копия?

Способ непригоден главным образом потому, что выполняется слишком быстро JSON-клонирование сохраняет prototype каждого вложенного объекта JSON.parse и stringify доступны только в Node.js Теряются undefined, Date, Map, функции и циклические связи Полученная копия автоматически становится глубоко замороженной

Вопрос 10 из 30

Какой плюс структурного разделения?

При разделении структуры сборщик мусора полностью отключается Любое обновление структуры выполняется за постоянное время O(1) Структурное разделение автоматически устраняет циклические ссылки Новая версия структуры получает независимые копии изменённой ветви и всех её соседей Неизменённые ветви сохраняют ссылки, уменьшая копии и проверки

Вопрос 11 из 30

Каков порядок вызовов в pipe(f,g,h)(x)?

const pipe = (...fns) => value => fns.reduce((v, fn) => fn(v), value);
pipe(f, g, h)(x);

Только h Все параллельно h, g, f f, g, h Порядок случайный

Вопрос 12 из 30

Почему эта композиция сломается?

const read = pipe(JSON.parse, value => value.trim());
read("{\"name\":\"Ada\"}");

trim не является функцией Стрелочные функции не компонуются pipe запрещает два шага parse возвращает объект, а trim ожидает строку JSON.parse возвращает Promise

Вопрос 13 из 30

Как написать async pipe, чтобы каждый шаг получил развёрнутое значение?

const pipeAsync = (...fns) => value => {
  // Выберите реализацию, которая последовательно ожидает каждый шаг.
};

reduce((p,fn)=>p.then(fn), Promise.resolve(value)) map(fn=>fn(value)) reduce((v,fn)=>fn(v), value) Promise.race(fns) JSON.stringify(fns)

Вопрос 14 из 30

Когда именованная промежуточная переменная лучше длинной композиции?

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

Вопрос 15 из 30

Почему универсальный compose с автоматическим catch может быть опасен?

Он стирает виды ошибок и может превратить отказ в тихое значение Compose принципиально несовместим с функциями, возвращающими Promise Catch меняет порядок позиционных аргументов всех функций Оператор catch нельзя использовать внутри функций композиции Автоматический catch опасен только тем, что ускоряет выполнение

Вопрос 16 из 30

Какая версия проще тестируется детерминированно?

const isExpired = (expiresAt, now) => expiresAt <= now;
console.log(isExpired(deadline, fixedNow));

Функция пишет localStorage Функция использует Math.random дважды Функция напрямую вызывает Date.now Функция принимает now как зависимость Функция читает глобальный document

Вопрос 17 из 30

Почему Math.random внутри расчёта мешает повторяемости?

function choose(items, random = Math.random) {
  return items[Math.floor(random() * items.length)];
}

В стандартной реализации random всегда возвращает ноль Math.random запрещён внутри функций строгого режима Math.random возвращает Promise и требует await Вызов random изменяет prototype встроенного Number Один вход даёт разные выходы; генератор надо передать как зависимость

Вопрос 18 из 30

Что означает «functional core, imperative shell»?

Требование полностью исключить эффекты из всего приложения Правило, по которому каждая функция обязана возвращать функцию Полный запрет Promise и любых асинхронных операций Архитектура, в которой допускаются только классы Чистое ядро считает правила, а тонкая оболочка управляет I/O

Вопрос 19 из 30

Когда повтор чистой функции безопасен?

Если исходный код функции короче десяти строк Если вызов помещён после await и выполняется в новой микрозадаче При одинаковом входе результат тот же и внешний мир не меняется Повтор чистой функции всегда создаёт новое внешнее действие Только при первом вызове функции после загрузки модуля

Вопрос 20 из 30

Почему отправка письма не должна происходить внутри selector состояния?

Selector не способен возвращать строковые значения Отправка письма внутри вычисления нарушает формат JSON Selector могут пересчитать много раз, неожиданно повторяя эффект Операция отправки почты всегда синхронна Любой selector по контракту обязан быть async-функцией

Вопрос 21 из 30

Как tap помогает диагностировать pipe?

const tap = fn => value => { fn(value); return value; };
pipe(parse, tap(console.log), validate)(input);

Останавливает композицию после первого наблюдаемого значения Заменяет переданное значение на undefined перед следующим шагом Показывает промежуточное значение и возвращает его без изменения Автоматически мемоизирует результат каждого шага pipe Создаёт глубокую копию объекта для безопасной диагностики

Вопрос 22 из 30

Какое свойство у корректного reverse для массива?

const reverseCopy = xs => [...xs].reverse();
assert.deepEqual(reverseCopy(reverseCopy(xs)), xs);

reverse(reverse(xs)) эквивалентен xs по значениям Первый элемент исчезает Длина уменьшается на один Функция обязана мутировать вход reverse(xs) всегда равен xs

Вопрос 23 из 30

Почему toEqual важнее toBe для новой неизменяемой структуры?

const next = { ...state, count: state.count + 1 };
expect(next).toEqual({ ...state, count: state.count + 1 });
expect(next).not.toBe(state);

Матчер toBe всегда возвращает true для объектов Между toBe и toEqual нет различий для ссылочных значений toBe выполняет глубокое сравнение всех полей объекта toBe сравнивает ссылку, а равная новая структура имеет другую ссылку toEqual поддерживает только примитивные числовые значения

Вопрос 24 из 30

Как минимизировать ошибку reduce?

Найти минимальный вход, на котором нарушается ожидаемое свойство Оставить только большой production dump без сокращения Заменить reduce выполнением строки через eval Удалить initialValue без проверки поведения пустого массива Добавить больше элементов, чтобы ошибка проявилась сильнее

Вопрос 25 из 30

Почему snapshot большой цепочки недостаточен?

Снимки не могут храниться в системе контроля версий Большой snapshot всегда записывается как пустая строка Создание снимка автоматически выполняет внешние эффекты Snapshot нельзя применять к объектам и массивам Он фиксирует один итог, но не свойства шагов и крайние случаи

Вопрос 26 из 30

Почему три последовательных map создают лишнюю работу?

const result = items
  .map(read)
  .map(normalize)
  .map(format);

map не обходит массив Каждый шаг создаёт новый массив и отдельный проход Map удаляет элементы Все callbacks выполняются параллельно Третий map работает на исходном массиве

Вопрос 27 из 30

Когда memoize возвращает неверные данные?

const price = memoize(productId => api.currentPrice(productId));

Для чистой функции, чей примитивный ключ определяет результат Когда скрытые время или состояние не входят в ключ кэша Когда внутренний Map пока не содержит ни одного значения Если мемоизированная функция возвращает строку При единственном вызове функции за всё время процесса

Вопрос 28 из 30

Какой риск у бесконечного Map-кэша memoize?

const cache = new Map();
const memo = key => cache.has(key) ? cache.get(key) : cache.set(key, compute(key)).get(key);

Ключи и результаты удерживаются без границы и накапливают память Все сохранённые значения автоматически становятся immutable Map не принимает объекты и поэтому выбрасывает исключение Map сам очищает старую запись после каждого нового вызова После заполнения кэша функция полностью перестаёт возвращать значения

Вопрос 29 из 30

Когда обычный for-цикл оправдан вместо цепочки filter/map/reduce?

Когда цепочка методов содержит reduce и поэтому не может быть объединена в один проход Если входной массив пуст и цикл ни разу не выполнится Только для поддержки устаревшего браузера без Array.map Когда профиль показал цену проходов, а единый цикл остаётся ясным Всегда: цепочки методов следует заменять циклом заранее

Вопрос 30 из 30

Что ухудшает сопровождение функционального кода сильнее всего?

Объявление локальных связываний через const Отсутствие классов в отдельном модуле вычислений Применение стандартного метода Array.map Непривычные термины и плотные абстракции, непонятные команде Сам факт использования функций как значений

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

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

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

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