Агрегатные операции над массивами в TypeScript

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

Массивы дают часть этого напрямую. numbers.length считает элементы. Math.max() и Math.min() находят наибольшее и наименьшее число; элементы передаются им так: Math.max(...numbers). Для суммы или среднего метода нет: элементы объединяются с помощью reduce().

Будьте внимательны с пустыми массивами. Math.max() без значений возвращает -Infinity, а Math.min() возвращает Infinity, поэтому проверяйте numbers.length > 0, если массив может оказаться пустым.

Во многих языках есть отдельные методы fold и reduce для пошагового объединения элементов. Здесь это один и тот же метод, reduce(), и разница только в том, передаёте ли вы начальное значение. reduceRight() делает тот же проход, но от последнего элемента к первому.

Самые частые агрегаты — количество, минимум, максимум, сумма и среднее.

• numbers.length даёт количество.
• Math.max(...numbers) и Math.min(...numbers) дают наибольшее и наименьшее число. Они работают только с числами.
• Сумма — это reduce(), который прибавляет каждый элемент к накопленному итогу. Среднее — это сумма, делённая на количество; деление сохраняет дробную часть, поэтому 62 / 4 равно 15.5.

Иногда наименьший или наибольший элемент нужно выбирать по правилу, а не по самому значению. reduce() умеет и это: на каждом шаге вы оставляете лучший из двух элементов. Это работает и для слов, и для объектов, где Math.min() уже не поможет.

Иногда каждый элемент сначала нужно превратить в число, а результаты сложить. Это тоже один reduce(): прибавляйте вычисленное значение вместо самого элемента.

Для чисел 6, 42, 10 и 4 программа выводит количество через length, наибольшее и наименьшее через Math.max() и Math.min(), а сумму — через reduce(). Среднее равно 62 / 4 = 15.5.

Первый reduce() оставляет элемент с меньшим остатком от деления на 3. Остатки чисел 5, 42, 10 и 4 равны 2, 0, 1 и 1, поэтому побеждает 42. Второй оставляет более длинное слово и находит "three".

Колбэк прибавляет к итогу вычисленное значение вместо самого элемента. Удвоение чисел 5, 42, 10 и 4 даёт 122. Деление их пополам даёт 30.5, потому что деление сохраняет дробную часть.

Fold и reduce шаг за шагом объединяют все элементы в одно значение. Они хранят текущее значение, которое называется аккумулятором. Для каждого элемента они вызывают функцию с аккумулятором и элементом, а функция возвращает новый аккумулятор.

Здесь это один и тот же метод. Разница — во втором аргументе reduce():

• reduce(fn, initial) — это fold. Он начинает с начального значения, которое вы передали, поэтому функция выполняется для каждого элемента.
• reduce(fn) — это reduce. Он начинает с первого элемента, поэтому функция работает начиная со второго элемента, а первый элемент через неё никогда не проходит.

Это важно, когда функция изменяет элемент. Если она удваивает каждый элемент, то reduce(fn) оставляет первый элемент как есть.

Это важно и для пустых массивов. reduce(fn, initial) просто возвращает начальное значение, а у reduce(fn) нет ничего, с чего начать, и он выбрасывает TypeError.

Чтобы объединять с другого конца, используйте reduceRight(): тот же метод, но проход идёт от последнего элемента к первому.

reduce() без начального значения берёт 5 как старт и прибавляет к нему 2, 10 и 4, поэтому результат равен 21. Тот же вызов на пустом массиве выбрасывает ошибку, и программа выводит сообщение, которое она несёт: Reduce of empty array with no initial value.

Здесь reduce() получает начальное значение 0 и прибавляет каждый элемент, умноженный на 2. Удваивается каждый элемент: 10 + 4 + 20 + 8 = 42.

Оба вызова используют одну и ту же функцию: сумма плюс элемент, умноженный на 2. Без начального значения результат равен 37, потому что первый элемент 5 является стартом и не удваивается. С начальным значением 0 результат равен 42.

reduceRight() проходит массив от последнего элемента к первому. Сложению порядок не важен, поэтому результат снова равен 42.

Иногда важна позиция элемента, а не только его значение.

Колбэк reduce() получает индекс третьим аргументом, после аккумулятора и элемента. Условие на этот индекс затем решает, что делать с элементом. reduceRight() передаёт те же индексы; он лишь проходит их с конца.

Складываются только элементы с чётными индексами: по индексу 0 стоит 5, а по индексу 2 стоит 10, поэтому сумма равна 15.

То же правило с reduceRight(). Колбэк видит индекс 3 первым, а индекс 0 последним, и результат по-прежнему равен 15.

reduce() без начального значения нуждается в первом элементе, с которого можно начать. На пустом массиве он выбрасывает TypeError и останавливает программу.

Один выход — начальное значение. Другой — честно сказать «результата нет»: сначала проверить длину и вернуть undefined. Тип возвращаемого значения тогда — number | undefined, что заставляет вызывающий код подумать о случае пустого массива, а ?? за один шаг подставляет запасное значение вместо undefined.

sumOrUndefined() возвращает 21 для чисел 5, 2, 10 и 4 и undefined для пустого массива. sumOrUndefined(empty) ?? 0 превращает этот undefined в 0.

Накопительный fold или reduce не выбрасывает промежуточные шаги. Он сохраняет аккумулятор после каждого элемента, поэтому результатом становится массив всех промежуточных значений.

Метода для этого нет. Вы храните переменную с суммой и внутри цикла добавляете её в массив результата через push(). Для накопительного reduce результат начинается с первого элемента. Для накопительного fold он начинается с начального значения, поэтому содержит на один элемент больше, чем исходный массив.

Числа от 0 до 5 складываются одно за другим. Массив результата хранит каждую промежуточную сумму и выводится на одной строке с помощью join(' '): 0 1 3 6 10 15.

То же самое с начальным значением 10. Результат начинается с самого числа 10 и содержит на один элемент больше, чем исходный массив: 10 10 11 13 16 20 25.