Сортировка массивов в TypeScript

Сортировка означает расстановку элементов коллекции в определённом порядке.

У некоторых типов есть естественный порядок. Числа упорядочены по значению: 1 идёт перед 2. Строки упорядочены по алфавиту: "four" идёт перед "one". Для всего остального или когда вам нужен другой порядок, вы задаёте собственный порядок: функцию сравнения, которая смотрит на два элемента и говорит, какой из них идёт первым.

У массивов есть один метод сортировки, sort(), и две вещи о нём легко упустить:

• sort() меняет массив на месте и возвращает тот же самый массив, поэтому исходный порядок теряется. Чтобы сохранить его, сортируйте копию: [...words].sort().
• Без функции сравнения sort() сравнивает строковую форму значений. Для слов это нормально, но [10, 9, 2] получается как [ 10, 2, 9 ], потому что текст "10" идёт перед "2". Для чисел всегда передавайте функцию сравнения.

Функция сравнения получает два элемента, a и b, и возвращает число: отрицательное, когда первым идёт a, положительное, когда первым идёт b, и 0, когда они равны. a - b делает это для чисел, а a.localeCompare(b) — для строк.

sort() устойчива: элементы, которые функция сравнения считает равными, сохраняют свой исходный порядок.

В более новых версиях Node.js есть также toSorted() и toReversed(), которые возвращают новый массив и оставляют оригинал нетронутым. В примерах ниже массив копируется вручную через [...words], что работает везде.

В примерах ниже используются слова one, two, three, four.

Естественный порядок — это порядок, который есть у типа сам по себе: числа по значению, строки буква за буквой.

[...words].sort() даёт новый массив в алфавитном порядке. Для убывающего порядка отдельного метода нет: сначала отсортируйте, затем переверните массив с помощью reverse(). Для чисел функция сравнения (a, b) => b - a делает это за один шаг.

У ваших собственных типов объектов естественного порядка нет. Вы задаёте его, написав функцию сравнения, которая возвращает отрицательное число, ноль или положительное число — то же правило, что и для любой другой функции сравнения. Затем вы можете передать её в sort() или использовать напрямую, чтобы сравнить два значения.

[...words].sort() сортирует копию, поэтому сам words выводится после этого без изменений. Последние две строки показывают, зачем числам нужна функция сравнения: без неё [10, 9, 2] становится [ 10, 2, 9 ]; с (a, b) => a - b получается [ 2, 9, 10 ].

Копия сортируется, затем reverse() переворачивает её, поэтому слова идут от "two" вниз до "four". Числа показывают более короткий путь для значений, которые можно вычитать: (a, b) => b - a сортирует [10, 9, 2] сразу в [ 10, 9, 2 ].

У Version есть числа major и minor. compareVersion() сравнивает сначала major; только когда этот результат равен 0, решает minor, потому что || берёт первый результат, который не равен 0. Проверка compareVersion(...) > 0 отвечает на вопрос «больше ли первая версия?».

Собственный порядок — это любой порядок, который вы описываете функцией сравнения.

sort() принимает эту функцию как свой единственный аргумент. Поскольку sort() устойчива, элементы, которые функция считает равными, остаются в своём исходном порядке — именно это вам и нужно при сортировке слов по длине.

Частое желание — отсортировать по одному свойству каждого элемента. Специального метода для этого нет: напишите функцию сравнения, которая сравнивает это свойство, с - для чисел или localeCompare() для строк.

Для убывающего порядка поменяйте местами a и b в сравнении.

Чтобы отсортировать по одному признаку, а затем по другому, соедините два сравнения с помощью ||. Он берёт первый результат, который не равен 0, поэтому, когда первое сравнение считает элементы равными, спор решает второе.

Функция сравнения возвращает a.length - b.length. Отрицательный результат означает, что a короче и идёт первым, поэтому слова в итоге идут от самого короткого к самому длинному: [ 'c', 'bb', 'aaa' ].

Слова сравниваются с помощью a.length - b.length. "one" и "two" оба длиной 3 буквы; поскольку sort() устойчива, "one" остаётся перед "two".

a[a.length - 1] — это последняя буква слова. Буквы b и a сравниваются в обратном порядке, поэтому слово с самой большой последней буквой идёт первым: "four" (r), затем "two" (o), затем два слова, оканчивающиеся на «e», в их исходном порядке.

|| сначала сравнивает длины. Когда два слова одинаково длинные, он переходит к localeCompare(), который упорядочивает их по алфавиту. Результат выводится через join(' '), в одну строку: a b c aa bb aaa ccc.

Иногда вы хотите лишь узнать, отсортирован ли массив уже, не сортируя его.

Встроенной проверки нет, но every() пишет её в одну строку: каждый элемент должен идти после предыдущего элемента. Небольшой помощник isSorted() ниже принимает функцию сравнения, поэтому один и тот же помощник может проверять возрастающий порядок, убывающий порядок или порядок по одному свойству. Для убывающего порядка вы передаёте функцию сравнения с поменянными местами a и b.

isSorted() подтверждает, что 1, 2, 3, 4 возрастают. Тот же помощник с (a, b) => b - a подтверждает, что 4, 3, 2, 1 убывают. Элемент с индексом 0 принимается всегда, потому что перед ним нет элемента.

Пользователи — это Alice (24), Bob (31) и Charlie (29). Функция сравнения смотрит только на age. Bob старше, чем Charlie, поэтому массив не отсортирован по возрасту и ответ — false.

Переворачивание ставит последний элемент первым, а первый элемент — последним.

reverse() переворачивает массив на месте, точно так же, как это делает sort(). Чтобы вместо этого получить перевёрнутую копию, переверните копию: [...words].reverse(). Оригинал сохраняет свой порядок.

Копия переворачивается и выводится, затем выводится оригинал, чтобы показать, что он не изменился.

Перемешивание ставит элементы в случайном порядке.

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

Math.random() давал бы другой порядок при каждом запуске. Поэтому в этом примере создаётся собственный генератор: две строки арифметики, которые превращают seed в поток чисел от 0 до 1. Один и тот же seed всегда даёт один и тот же порядок, что полезно для тестов и для примеров вроде этого.

Генератор с seed 9 перемешивает копию слов и выводит [ 'two', 'four', 'three', 'one' ]. Повторный запуск программы выводит тот же порядок, потому что генератор стартует с того же seed.