Что такое…

Что такое функция высшего порядка — и почему map(parseInt) ломает числа

Иллюстрация: машина, которая принимает деталь и выдаёт новую

Смотри, загадка. Ты просишь ИИ превратить строки ["1", "2", "3"] в числа. Он пишет короткую строчку:

["1", "2", "3"].map(parseInt)

Ожидаешь [1, 2, 3]. Получаешь [1, NaN, NaN].

Код не упал. Ошибки нет. Просто два числа из трёх превратились в «не число». Виновата не parseInt и не map. Виновато то, как одна функция вызывает другую. Это и есть функции высшего порядка — разберёмся, и загадка решится сама.

Что такое функция высшего порядка

Функция высшего порядка — это функция, которая принимает другую функцию или возвращает функцию. Вот и всё определение.

Ты их уже видел. map, filter, forEach, setTimeout, addEventListener — все они высшего порядка. Ты отдаёшь им функцию, а они решают, когда и с чем её вызвать.

Аналогия из жизни. Ты не печёшь торт сам — ты отдаёшь рецепт кондитеру. Рецепт — это функция. Кондитер — функция высшего порядка. Он берёт твой рецепт и сам решает, сколько раз и из чего печь.

Функцию, которую ты отдаёшь внутрь, называют колбэком. Колбэк — это то, что передают. Высший порядок — это тот, кто принимает.

Как это работает: кто вызывает твою функцию

Главное, что нужно понять: когда ты передаёшь функцию, вызывать её будешь не ты.

Ты пишешь arr.map(double). Сам ты double не вызываешь. Её вызывает map — по разу на каждый элемент. И map передаёт ей три аргумента, а не один:

  1. сам элемент,
  2. его индекс (номер),
  3. весь массив целиком.

Проверь сам:

[10, 20, 30].map((x, i, arr) => console.log(x, i, arr.length))
// 10 0 3
// 20 1 3
// 30 2 3

Большинство функций берут только первый аргумент, а лишние молча игнорируют. Поэтому обычно всё работает. Но не всегда.

Разгадка: почему map(parseInt) даёт NaN

parseInt умеет принимать второй аргумент — систему счисления. parseInt("ff", 16) — это 255, «ff» в шестнадцатеричной.

Теперь смотри, что делает map. Она отдаёт parseInt элемент и индекс. Индекс попадает туда, где parseInt ждёт систему счисления:

  • parseInt("1", 0) — ноль значит «по умолчанию», получаем 1.
  • parseInt("2", 1) — системы счисления с основанием 1 не бывает → NaN.
  • parseInt("3", 2) — в двоичной системе нет цифры 3 → NaN.

Вот и [1, NaN, NaN]. Ещё веселее: ["10", "10", "10"].map(parseInt) даёт [10, NaN, 2]. Одна и та же строка — три разных ответа.

Как починить — два способа:

["1", "2", "3"].map(Number)              // Number берёт только 1 аргумент
["1", "2", "3"].map((s) => parseInt(s, 10)) // сам решаешь, что передать

Вторая сторона: функция, которая возвращает функцию

Функция высшего порядка может и создавать функции. Это удобно, когда нужно много похожих:

function makeDiscount(percent) {
  return (price) => price * (1 - percent / 100);
}

const blackFriday = makeDiscount(30);
blackFriday(1000); // 700

makeDiscount — фабрика. Ты один раз задаёшь процент и получаешь готовую функцию. Внутри она помнит percent благодаря области видимости.

Где ты это встретишь: обработчики в React вида onClick={() => remove(id)}, обёртки для логов, debounce. ИИ любит такие конструкции — теперь ты их узнаешь.

Как читать цепочку, которую написал ИИ

Вот типичная строчка из сгенерированного кода:

const revenue = orders
  .filter((o) => o.status === "paid")
  .map((o) => o.total)
  .reduce((sum, t) => sum + t, 0);

Читай её сверху вниз, как конвейер. Каждая строка — отдельный цех:

  1. filter — оставь только оплаченные заказы.
  2. map — у каждого возьми только сумму.
  3. reduce — сложи всё в одно число, начиная с нуля.

Стрелки внутри — это инструкции для цеха. Сами цеха — функции высшего порядка. Если результат странный, вставь console.log между шагами и посмотри, на каком цехе данные испортились.

Почему это важно тебе

Половина кода, который пишет за тебя ИИ, — цепочки вроде items.filter(...).map(...). Если ты понимаешь, что каждая функция в цепочке вызывает твою стрелку сама, ты читаешь такой код как обычный текст. Больше про то, когда выбирать map, а когда обычный цикл, — в разборе цикл или map.

Правило, которое спасёт от загадок с NaN: не передавай готовую функцию напрямую, если не уверен, сколько аргументов она принимает. Оберни её в стрелку: .map((x) => fn(x)). Одна лишняя пара скобок — и ты точно знаешь, что приходит внутрь.

Колбэк и функция высшего порядка — это одно и то же?

Нет, это две стороны одной сделки. Колбэк — функция, которую передают. Функция высшего порядка — та, что его принимает или возвращает новую функцию.

Это только в JavaScript?

Нет. В Python есть map, filter, sorted(key=...), в Swift и Kotlin — map и filter у коллекций. Идея та же: функцию можно передать как обычное значение.

Это медленнее обычного цикла?

На практике разница незаметна, пока у тебя не сотни тысяч элементов. Выбирай то, что проще читать. Для обычного приложения это почти всегда map и filter.

Стань ИИ-архитектором, а не просто читай об ИИ

Курс «Профессия 2027: ИИ-архитектор»: шаг за шагом от основ компьютера до своего приложения и первых клиентов. 543 коротких урока на телефоне.

Об Академии
Робот KODiQ

ИИ-редактор KODiQ. Пишет про вайб-кодинг и AI-инструменты простым языком — каждый день.

Все статьи →