Метод sort() в JavaScript изменяет исходный массив, упорядочивая его элементы по определённому критерию. По умолчанию сортировка выполняется в лексикографическом порядке, что может привести к неожиданным результатам при работе с числами. Например, [10, 2, 5].sort() вернёт [10, 2, 5], поскольку элементы сравниваются как строки.
Чтобы отсортировать числовой массив по возрастанию, необходимо передать в sort() функцию сравнения: arr.sort((a, b) => a - b). Для убывания – (a, b) => b - a. Эта функция должна возвращать отрицательное значение, если a меньше b, положительное – если больше, и 0, если равны.
Сортировка объектов по полю требует явного указания логики сравнения. Пример: users.sort((a, b) => a.age - b.age) упорядочит пользователей по возрасту. Если поле строковое, стоит использовать localeCompare(): arr.sort((a, b) => a.name.localeCompare(b.name)).
Метод toSorted() из ECMAScript 2023 возвращает отсортированную копию массива без изменения оригинала. Это решение предпочтительно при работе с неизменяемыми данными: const sorted = numbers.toSorted((a, b) => a - b).
Как работает метод sort() без параметров
Метод sort() без аргументов сортирует элементы массива как строки в порядке возрастания кодов Unicode. Это означает, что сортировка не учитывает числовые значения элементов и может привести к неожиданным результатам при работе с числами.
Пример:
const arr = [10, 1, 5];
arr.sort();
console.log(arr); // [1, 10, 5]В этом случае числа преобразуются в строки: «10», «1», «5». Затем сортировка выполняется по символам слева направо, поэтому «10» оказывается перед «5».
Метод изменяет исходный массив, возвращая отсортированный массив в той же ссылке.
Сравнение строк происходит по порядковым номерам символов Unicode:
const arr = ['яблоко', 'банан', 'груша'];
arr.sort();
console.log(arr); // ['банан', 'груша', 'яблоко']Регистр влияет на порядок сортировки:
const arr = ['a', 'B', 'c'];
arr.sort();
console.log(arr); // ['B', 'a', 'c']Чтобы избежать некорректной сортировки чисел, необходимо передать функцию сравнения. Без неё sort() применим только к строкам или массивам, элементы которых должны интерпретироваться как строки.
Сортировка чисел по возрастанию и убыванию
Метод sort() по умолчанию сортирует элементы как строки, что приводит к ошибкам при работе с числами. Для корректной сортировки необходимо передать функцию сравнения.
- Сортировка по возрастанию:
const numbers = [4, 12, 1, 9, 21];
numbers.sort((a, b) => a - b);
console.log(numbers); // [1, 4, 9, 12, 21]
- Сортировка по убыванию:
const numbers = [4, 12, 1, 9, 21];
numbers.sort((a, b) => b - a);
console.log(numbers); // [21, 12, 9, 4, 1]
Функция сравнения принимает два аргумента. Если результат меньше нуля – a помещается перед b, если больше – наоборот. Результат 0 сохраняет порядок.
Для создания нового отсортированного массива без изменения исходного используйте slice():
const original = [7, 2, 5];
const sorted = original.slice().sort((a, b) => a - b);
console.log(original); // [7, 2, 5]
console.log(sorted); // [2, 5, 7]
Не использовать localeCompare() для чисел – он предназначен для строк. Также не следует сравнивать числа через String(a).localeCompare(String(b)), это приведёт к некорректной сортировке.
Сортировка строк с учётом регистра и локали
Метод sort() в JavaScript по умолчанию сортирует строки в порядке кодов Unicode, что приводит к неожиданным результатам при наличии символов разного регистра и языков. Для корректной сортировки используют localeCompare().
Пример без учёта локали:
const words = ['яблоко', 'Ананас', 'банан'];
words.sort();
console.log(words); // ['Ананас', 'банан', 'яблоко']Сортировка с учётом локали и регистра:
const words = ['яблоко', 'Ананас', 'банан'];
words.sort((a, b) => a.localeCompare(b, 'ru', { sensitivity: 'variant' }));
console.log(words); // ['Ананас', 'банан', 'яблоко']Параметр 'ru' указывает на использование русской локали. Опция sensitivity: 'variant' различает как регистр, так и акценты. Для игнорирования регистра используется sensitivity: 'base'.
Пример с игнорированием регистра:
const words = ['яблоко', 'Ананас', 'банан'];
words.sort((a, b) => a.localeCompare(b, 'ru', { sensitivity: 'base' }));
console.log(words); // ['Ананас', 'банан', 'яблоко']Для сортировки в обратном порядке умножают результат на -1:
words.sort((a, b) => -a.localeCompare(b, 'ru', { sensitivity: 'base' }));Метод localeCompare() также учитывает особенности алфавита конкретной локали. Для сортировки списков, содержащих строки на разных языках, допустимо указание массива локалей, например ['ru', 'en'].
Сортировка массива объектов по числовому полю
Для сортировки массива объектов по числовому полю применяется метод sort() с функцией сравнения. Предположим, есть массив пользователей, каждый из которых имеет числовое поле age:
const users = [
{ name: 'Анна', age: 28 },
{ name: 'Иван', age: 21 },
{ name: 'Мария', age: 35 }
];Чтобы отсортировать этот массив по возрастанию возраста, используйте:
users.sort((a, b) => a.age - b.age);Для сортировки по убыванию:
users.sort((a, b) => b.age - a.age);Функция сравнения должна возвращать отрицательное значение, если a должно быть раньше b, положительное – если позже, и ноль – если равны. Метод sort() изменяет исходный массив.
Если поле может быть нечисловым или отсутствовать, добавляется проверка:
users.sort((a, b) => {
const ageA = typeof a.age === 'number' ? a.age : 0;
const ageB = typeof b.age === 'number' ? b.age : 0;
return ageA - ageB;
});Это предотвратит ошибки при некорректных данных. Для неизменяемости исходного массива используйте slice() или оператор расширения:
const sorted = [...users].sort((a, b) => a.age - b.age);Сортировка массива объектов по строковому полю
Для сортировки массива объектов по строковому полю используется метод sort() с пользовательской функцией сравнения. Стандартное сравнение строк в JavaScript производится с учётом регистра символов, что может привести к неожиданному порядку элементов.
Пример: необходимо отсортировать список пользователей по имени:
const users = [
{ name: 'Анна', age: 28 },
{ name: 'елена', age: 34 },
{ name: 'Борис', age: 23 }
];
users.sort((a, b) => a.name.localeCompare(b.name, 'ru', { sensitivity: 'base' }));
Метод localeCompare() учитывает правила локали. В данном случае указана русская локаль 'ru', параметр sensitivity: 'base' отключает учёт регистра, что позволяет избежать ситуаций, когда заглавные буквы сортируются отдельно от строчных.
Если нужно выполнить сортировку в обратном порядке, достаточно поменять аргументы местами:
users.sort((a, b) => b.name.localeCompare(a.name, 'ru', { sensitivity: 'base' }));Для сортировки по нескольким строковым полям применяются вложенные сравнения:
const people = [
{ firstName: 'Иван', lastName: 'Сидоров' },
{ firstName: 'Иван', lastName: 'Алексеев' },
{ firstName: 'Пётр', lastName: 'Иванов' }
];
people.sort((a, b) => {
const firstNameComparison = a.firstName.localeCompare(b.firstName, 'ru', { sensitivity: 'base' });
if (firstNameComparison !== 0) return firstNameComparison;
return a.lastName.localeCompare(b.lastName, 'ru', { sensitivity: 'base' });
});
Такой подход обеспечивает стабильную и корректную сортировку даже при совпадении значений в основном поле.
Стабильность сортировки и порядок элементов с равными значениями
Метод sort() в JavaScript стабилен в большинстве современных браузеров, включая Chrome, Firefox и Safari, начиная с определённых версий. Однако, важно помнить, что спецификация ECMAScript не гарантирует стабильность сортировки, и в старых версиях браузеров эта особенность может не поддерживаться.
Когда элементы имеют одинаковые значения, порядок их расположения после сортировки зависит от алгоритма сортировки. Например, в случае стабильно работающего метода, если массив содержит объекты с одинаковыми значениями, их относительный порядок останется неизменным. Это особенно важно, если сортировка выполняется по нескольким критериям. Например, сортировка сначала по возрасту, а затем по имени, где имена одинаковы, но возраст различен. В таком случае, если сортировка стабильна, объекты с одинаковыми именами будут располагаться в том же порядке, в котором они были до сортировки.
Если требуется нестабильная сортировка, можно использовать альтернативные методы, такие как вручную реализованные алгоритмы или сторонние библиотеки. Однако в большинстве случаев стабильная сортировка является предпочтительной, так как она позволяет избежать неожиданных изменений порядка элементов.
Создание копии массива перед сортировкой без изменения оригинала
При работе с массивами в JavaScript важно помнить, что многие методы, такие как sort(), изменяют оригинальный массив. Чтобы избежать нежелательных изменений исходных данных, следует создать их копию перед сортировкой.
Для этого можно использовать несколько подходов. Один из самых простых способов – использование метода slice(). Этот метод создаёт поверхностную копию массива, которая не зависит от оригинала.
const originalArray = [3, 1, 4, 1, 5];
const copiedArray = originalArray.slice();
copiedArray.sort();
console.log(originalArray); // [3, 1, 4, 1, 5]
console.log(copiedArray); // [1, 1, 3, 4, 5]Другим способом является использование оператора распространения ..., который также создаёт копию массива:
const originalArray = [3, 1, 4, 1, 5];
const copiedArray = [...originalArray];
copiedArray.sort();
console.log(originalArray); // [3, 1, 4, 1, 5]
console.log(copiedArray); // [1, 1, 3, 4, 5]Для глубокого копирования, когда массив содержит вложенные объекты, необходимо использовать методы, которые создают новые экземпляры этих объектов. Один из таких методов – использование JSON.parse() и JSON.stringify():
const originalArray = [{id: 1}, {id: 2}];
const copiedArray = JSON.parse(JSON.stringify(originalArray));
copiedArray[0].id = 10;
console.log(originalArray); // [{id: 1}, {id: 2}]
console.log(copiedArray); // [{id: 10}, {id: 2}]Важно помнить, что методы slice() и [...] создают только поверхностную копию, и изменения в глубоко вложенных объектах могут повлиять на оригинальный массив. Для глубокого копирования стоит использовать JSON.parse() и JSON.stringify() или специализированные библиотеки для работы с глубокой копией.
Вопрос-ответ:
Что такое сортировка массива в JavaScript и для чего она используется?
Сортировка массива в JavaScript — это процесс упорядочивания элементов массива по определенному принципу (например, по возрастанию или убыванию). Этот процесс помогает организовать данные в нужном порядке, что полезно, например, при обработке и отображении информации. Для сортировки часто используют встроенные методы, такие как `sort()`, который изменяет оригинальный массив.
Загрузка...
