У JavaScript уже есть метод reverse () в Array, поэтому вам не нужно этого делать!

Представьте, что у вас есть массив ниже:

var arr = [1, 2, 3, 4, 5];

Теперь просто просто выполните это:

arr.reverse();

, и вы получите это как результат:

[5, 4, 3, 2, 1];

Но это в основном изменит исходный массив, вы можете написать функцию и использовать ее для возврата новый массив вместо этого, что-то вроде этого:

function reverse(arr) {
  var i = arr.length, reversed = [];
  while(i) {
    i--;
    reversed.push(arr[i]);
  }
  return reversed;
}

Или просто редактирование встроенных методов JavaScript для Array следующим образом:

function reverse(arr) {
  return arr.slice().reverse();
}

, и вы можете вызвать его следующим образом:

reverse(arr); //return [5, 4, 3, 2, 1];

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

function reverseArray(arr) {
    let reversed = [];
    for (i = 0; i < arr.length; i++) { 
    reversed.push((arr[arr.length-1-i]))
    }
  return reversed;
}

20 байт

let reverse=a=>[...a].map(a.pop,a)

53 байта

function reverse(a){
    for(i=0,j=a.length-1;i<j;)a[i]=a[j]+(a[j--]=a[i++],0)
}

Просто для удовольствия, вот альтернативная реализация, которая быстрее, чем собственный .reverse метод.

Самый короткий обратный метод, который я видел, следующий:

let reverse = a=>a.sort(a=>1)

array.reverse() 

Выше будет изменен ваш массив, но будет изменен оригинал. Если вы не хотите изменять исходный массив, вы можете сделать это:

var arrayOne = [1,2,3,4,5];

var reverse = function(array){
    var arrayOne = array
    var array2 = [];

    for (var i = arrayOne.length-1; i >= 0; i--){
      array2.push(arrayOne[i])
    } 
    return array2
}

reverse(arrayOne)

Как насчет без использования push ()!

Решение с использованием XOR!

var myARray = [1,2,3,4,5,6,7,8];

function rver(x){
    var l = x.length;
    for(var i=0; i<Math.floor(l/2); i++){

        var a = x[i];
        var b = x[l-1-i];

        a = a^b;
        b = b^a;
        a = a^b;

        x[i] = a;
        x[l-1-i] = b;
    }

    return x;

}

console.log(rver(myARray));

Чистые функции для обращения к массиву с использованием функционального программирования:

```
var a = [3,5,7,8];

// ES2015
function immutableReverse(arr) {
  return [ ...a ].reverse();
}

// ES5
function immutableReverse(arr) {
  return a.concat().reverse()
}
```

Я провел несколько испытаний решений, которые не только решают массив, но и делают его копию. Вот тестовый код. Метод reverse2 является самым быстрым в Chrome, но в Firefox метод reverse является самым быстрым.

var array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

var reverse1 = function() {
  var reversed = array.slice().reverse();
};

var reverse2 = function() {
  var reversed = [];
  for (var i = array.length - 1; i >= 0; i--) {
    reversed.push(array[i]);
  }
};

var reverse3 = function() {
  var reversed = [];
  array.forEach(function(v) {
    reversed.unshift(v);
  });
};

console.time('reverse1');
for (var x = 0; x < 1000000; x++) {
  reverse1();
}
console.timeEnd('reverse1'); // Around 184ms on my computer in Chrome

console.time('reverse2');
for (var x = 0; x < 1000000; x++) {
  reverse2();
}
console.timeEnd('reverse2'); // Around 78ms on my computer in Chrome

console.time('reverse3');
for (var x = 0; x < 1000000; x++) {
  reverse3();
}
console.timeEnd('reverse3'); // Around 1114ms on my computer in Chrome

Это функциональный способ сделать это.

const array = [1,2,3,4,5,6,"taco"];

function reverse(array){
  return array.map((item,idx) => array[array.length-1-idx])
}

> var arr = [1,2,3,4,5,6];
> arr.reverse();
  [6, 5, 4, 3, 2, 1]

Вы можете сделать

var yourArray = ["first", "second", "third", "...", "etc"]
var reverseArray = yourArray.slice().reverse()

console.log(reverseArray)

Вы получите

["etc", "...", "third", "second", "first"]

var myArray = [1,2,3,4,5,6,7,8];

var revMyArr = [].concat(myArray).reverse();

Это то, что вы хотите:

array.reverse();

DEMO

Я просто переписал реализацию haskell в js.

const rev = (list, reversed) => {
    if (list.length == 0) return reversed

    reversed.unshift(list[0])
    return rev(list.slice(1), reversed)
}

const reverse = (list) => rev(list, [])

Как насчет этого?:

  function reverse(arr) {
    function doReverse(a, left, right) {
      if (left >= right) {
        return a;
      }
      const temp = a[left];
      a[left] = a[right];
      a[right] = temp;
      left++;
      right--;
      return doReverse(a, left, right);
    }

    return doReverse(arr, 0, arr.length - 1);
  }

  console.log(reverse([1,2,3,4]));

https://jsfiddle.net/ygpnt593/8/

Обратный с помощью метода сортировки

• Это гораздо более сжатый метод.

const resultN = document.querySelector('.resultN');
const resultL = document.querySelector('.resultL');

const dataNum = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
const dataLetters = ['a', 'b', 'c', 'd', 'e'];

const revBySort = (array) => array.sort((a, b) => a < b);

resultN.innerHTML = revBySort(dataNum);
resultL.innerHTML = revBySort(dataLetters);

<div class="resultN"></div>
<div class="resultL"></div>

Вот версия, которая не требует массива temp.

function inplaceReverse(arr) {
  var i = 0;
  while (i < arr.length - 1) {
    arr.splice(i, 0, arr.pop());
    i++;
  }
  return arr;
}

// Useage:
var arr = [1, 2, 3];
console.log(inplaceReverse(arr)); // [3, 2, 1]