Изменяет ли функция .sort оригинальный массив?

Когда вы используете метод sort() на массиве, он изменяет оригинальный массив. Например:

var arr = [{time: 4}, {time: 3}, {time: 6}];

arr.sort(function (a, b) {
  return a.time - b.time;
});

В результате сортировки оригинальный массив arr изменится, и вы получите:

[ { time: 3 }, { time: 4 }, { time: 6 } ]

Поэтому, если вы выполните console.log(arr), вы увидите:

[ { time: 3 }, { time: 4 }, { time: 6 } ]

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

var arr = [{time: 4}, {time: 3}, {time: 6}];
arr.slice().sort(function (a, b) {
  return a.time - b.time;
});

Этот код отсортирует копию массива, и результат будет:

[ { time: 3 }, { time: 4 }, { time: 6 } ]

Однако оригинальный массив arr останется неизменным, и вызов console.log(arr) вернет:

[ { time: 4 }, { time: 3 }, { time: 6 } ]

Таким образом, использование slice() перед sort() позволяет сортировать массив, не modifying исходный массив.

Это неплохой вопрос, и давайте ответим на него корректно:

const a = [1, 2, 3];
const b = a.sort();
console.log(a === b); // true

Вот ваш ответ. Оператор === для объектов будет сравнивать расположение в памяти, поэтому это один и тот же объект в памяти.

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

Таким образом, если вы хотите, чтобы массив был неизменяемым, вы можете сделать следующее:

const a = [1, 2, 3];
const b = a.slice(0).sort();

Да, sort() изменяет оригинальный массив.

В приведённом вами коде массив a сортируется с помощью метода sort(), который, как указано, изменяет исходный массив. Вот объяснение:

const a = [1, 2, 3]; // Исходный массив
const b = a.sort(); // Сортируем массив a, b ссылается на a
const c = [...a].sort(); // Создаём новый массив с помощью операторов расширения и сортируем его
console.log(a === b); // true, поскольку b ссылается на тот же массив, что и a
console.log(a === c); // false, поскольку c - это новый массив, и ссылки на них разные

Таким образом, b и a указывают на один и тот же отсортированный массив, а c - это новый отсортированный массив, созданный на основе копии a.

Ваша запись использует оператор расширения (spread operator) и метод sort() для сортировки массива. Вот что происходит в этом коде:

const a = [1, 2, 3]; // Инициализируем массив a
const b = [...a].sort(); // Создаем новый массив b, используя оператор распространения, и сортируем его

Как работает код:

1. ...a создает новый массив, который является копией массива a. Это важно, потому что метод sort() сортирует массив "на месте", т.е. изменяет исходный массив. Используя оператор наложения, вы избегаете изменения оригинального массива a.
2. Метод sort() сортирует элементы нового массива в порядке возрастания. Поскольку массив a уже отсортирован, b будет содержать те же значения [1, 2, 3].

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

const a = [3, 1, 2];
const b = [...a].sort((x, y) => x - y); // b будет равен [1, 2, 3]

Таким образом, если требуется сортировка по числам, используйте функцию (x, y) => x - y.