Как поменять порядок всех элементов массива на обратный?

Разворот массива: методы и подходы

Это классический вопрос, проверяющий знание встроенных методов JavaScript и понимание работы с массивами. Есть несколько способов, каждый с преимуществами и недостатками.

1. Встроенный метод reverse()

Самый простой и быстрый способ:

const array = [1, 2, 3, 4, 5];
array.reverse();
console.log(array); // [5, 4, 3, 2, 1]

Важно: reverse() модифицирует исходный массив! Если нужно сохранить оригинал:

const original = [1, 2, 3, 4, 5];
const reversed = [...original].reverse(); // Копируем сначала
console.log(original); // [1, 2, 3, 4, 5] - не изменился
console.log(reversed); // [5, 4, 3, 2, 1]

2. Использование spread оператора и reverse()

Создаёт новый массив:

const array = [1, 2, 3, 4, 5];
const reversed = [...array].reverse();
// или
const reversed = Array.from(array).reverse();

Это лучший вариант, если нужно не менять исходный массив.

3. Метод reduceRight() - функциональный подход

const array = [1, 2, 3, 4, 5];
const reversed = array.reduceRight((acc, item) => {
  acc.push(item);
  return acc;
}, []);
console.log(reversed); // [5, 4, 3, 2, 1]

Более элегантно:

const array = [1, 2, 3, 4, 5];
const reversed = array.reduceRight((acc, item) => [...acc, item], []);

Но это медленнее, так как создаёт новые массивы на каждой итерации.

4. Классический цикл с двумя указателями

Понимание алгоритма:

function reverseArray(arr) {
  let left = 0;
  let right = arr.length - 1;
  
  while (left < right) {
    // Обмениваем элементы местами
    [arr[left], arr[right]] = [arr[right], arr[left]];
    left++;
    right--;
  }
  
  return arr;
}

const array = [1, 2, 3, 4, 5];
reverseArray(array);
console.log(array); // [5, 4, 3, 2, 1]

Это O(n) по времени, O(1) по памяти - оптимально для больших массивов.

5. Использование цикла for с вставкой в начало

Неэффективно, но показывает логику:

const array = [1, 2, 3, 4, 5];
const reversed = [];

for (let i = array.length - 1; i >= 0; i--) {
  reversed.push(array[i]);
}
console.log(reversed); // [5, 4, 3, 2, 1]

6. Рекурсивный подход

function reverseRecursive(arr, start = 0, end = arr.length - 1) {
  if (start >= end) return arr;
  
  [arr[start], arr[end]] = [arr[end], arr[start]];
  return reverseRecursive(arr, start + 1, end - 1);
}

const array = [1, 2, 3, 4, 5];
reverseRecursive(array);
console.log(array); // [5, 4, 3, 2, 1]

Внимание: может вызвать stack overflow на больших массивах.

Сравнение производительности

const array = Array.from({ length: 1000000 }, (_, i) => i);

// 1. reverse() - самый быстрый
console.time("reverse");
[...array].reverse();
console.timeEnd("reverse"); // ~2-3ms

// 2. reduceRight - медленнее
console.time("reduceRight");
array.reduceRight((acc, item) => [...acc, item], []);
console.timeEnd("reduceRight"); // ~100-200ms

// 3. Два указателя - быстро, без копирования
console.time("two pointers");
const copy = [...array];
let left = 0, right = copy.length - 1;
while (left < right) {
  [copy[left], copy[right]] = [copy[right], copy[left]];
  left++;
  right--;
}
console.timeEnd("two pointers"); // ~5-10ms

Рекомендация

Для фронтенда используй [...array].reverse() - это:

• Понятно и читаемо
• Не мутирует исходный массив
• Достаточно производительно для UI

Если работаешь с огромными массивами (более 100k элементов), рассмотри алгоритм с двумя указателями для лучшей производительности.