One way to express this in ES6 is

reverse = (arr) => arr.map(arr.pop, [... arr]);

If you want to utilize Array.prototype.reduceright, consider reversing it for your needs.

Take a look at this example:

var array = ([1, 2, 3, 4, 5, 6, 7]).reduceRight(function(previous, current) {
  previous.push(current);
  return previous;
}, []);

console.log(array);

Instead of using the pop method, you can achieve the same result by iterating through the existing array in reverse order to create a new one.

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

    return output;
}

console.log(reverseArray([1,2,3,4,5,6,7]));

Edit after answer was accepted:

A comment with a link on your original post motivated me to compare my approach against the accepted answer. Surprisingly, my method consistently proved to be faster in my tests. Although the difference was minimal, my way outpaced the other every time.

Below is the code snippet I used to conduct the comparison (tested in Firefox developer scratch pad):

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

    return output;
}

function reverseTheirMethod(array) {
  var output = [];
  while (array.length) {
    output.push(array.pop());
  }

  return output;
}

function RunningSpeedTest(){
    console.log("Testing their method")
    var start = new Date().getTime();
    for(var p = 0; p < 10000; p++)
        {
            console.log(reverseTheirMethod([7,6,5,4,3,2,1]))
        }
    var end = new Date().getTime();
    console.log("Total runtime: " + (end - start) + " ms");
    console.log("Finished testing their method")

}


function RunningSpeedTestMyWay(){
    console.log("Testing my method")
    var startingTime = new Date().getTime();
    for(var p = 0; p < 10000; p++)
        {
            console.log(reverseMyMethod([7,6,5,4,3,2,1]))
        }
    var endingTime = new Date().getTime();
    console.log("Total runtime: " + (endingTime - startingTime) + " ms");
    console.log("Finished testing my method")
}

RunningSpeedTest();
RunningSpeedTestMyWay();

Here is a simple technique to reverse an array without relying on any pre-built functions or additional memory space.

let arr = [1, 2, 3, 4, 5, 6, 7];
let n = arr.length-1;

for(let i=0; i<=n/2; i++) {
  let temp = arr[i];
  arr[i] = arr[n-i];
  arr[n-i] = temp;
}
console.log(arr);

To achieve the desired outcome, consider implementing a reverse method that preserves the original array length by avoiding using .pop() directly.

function reverseArray(arr){
    var result = [];
    for (var i = arr.length; i > 0; i--){
        result.push(arr.pop());
    }
    return result;
}

console.log(reverseArray([1,2,3,4,5,6,7]));

Another approach is to store the array's length in a separate variable before modifying it:

function reverseArray(arr){
    var result = [];
    for (var i = 0, len= arr.length; i < len; i++){
        result.push(arr.pop());
    }

    return result;
}

console.log(reverseArray([1,2,3,4,5,6,7]));

When using the reverse function on an array, be cautious as it modifies the existing array and affects array.length.

Instead of removing items from the array with pop, consider accessing each item individually and adding them to a new array in reverse order using unshift:

function reverseArray(arr){
  var output = [],
      i;
  for (i = 0; i < arr.length; i++){
    output.unshift(arr[i]);
  }

  return output;
}

console.log(reverseArray([1,2,3,4,5,6,7]));

If you wish to reverse the array in-place similar to how Array.prototype.reverse works (though it is not recommended due to side-effects), try splicing the array and adding items back at the beginning using unshift:

function reverseArrayInPlace(arr) {
  var i,
      tmp;
  for (i = 1; i < arr.length; i++) {
    tmp = arr.splice(i, 1)[0];
    arr.unshift(tmp);
  }
  return arr;
}

var a = [1, 2, 3, 4, 5];
console.log('Reversed result:', reverseArrayInPlace(a));
console.log('Original array:', a);

This code snippet demonstrates a method to reverse an array in place without using pop, splice, or push operations.

let numbers = [10, 20, 30, 40, 50];
function reverseArrayInPlace(arr) {
  let half = Math.floor(arr.length / 2);
  for (let i = 0; i < half; i++) {
    let temp = arr[arr.length - 1 - i];
    arr[arr.length - 1 - i] = arr[i];
    arr[i] = temp;
  }
  return arr;
}

In order to correctly reverse an array without losing elements, it is essential to cache the original length of the array. As elements are popped off the initial array, the length changes which would affect the loop count and potentially result in missing elements. By storing the original length beforehand, you ensure that the loop runs the correct amount of times.

function reverse(array){
    var output = [];
    var len = array.length;
    for (var i = 0; i< len; i++){
        output.push(array.pop());
    }

    return output;
}

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

Instead of using a for loop to modify the original array and change its size, you can utilize a while loop.

function reverse(array){
var output = [];
while(array.length){
//this removes the last element making the length smaller
output.push(array.pop());
}

return output;
}

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

              const backward = (arr)=>{
              var result = [];
              for(let j=arr.length; j>0; j--){
                result.push(arr.pop());
              }
                console.log(result);
              }

              backward([10, 20, 30, 40, 50, 60, 70, 80]);

Here is an alternative approach you can consider:

def reverse_list(lst):
  left = 0
  right = len(lst) - 1
  while left < right:
    lst[left], lst[right] = lst[right], lst[left]
	print(lst)
    left += 1
    right -= 1
  return lst

print(reverse_list([1, 4, 7, 9, 2])) # [2, 9, 7, 4, 1]

The reason behind this behavior is that when you use array.pop(), it not only retrieves the last element of the array but also deletes it from the array. As a result, the length of the array changes dynamically during each iteration of the loop. Consequently, the function returns an array that decreases in length with every iteration.

This code snippet demonstrates a clever way to reverse an array without the need for a second array. It utilizes the built-in method splice.

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

Let's start by defining a new function

function reverseArray(inputArray) {
  const newArray = [];
  for (let j=0; j<inputArray.length; j++) {
    newArray.push(inputArray[inputArray.length-j])
  }
  return newArray;
}

If we have an array called 'xyz' with elements ['x','y','z','1','2','3'],

We can then use the function like this:

var reversedArray = reverseArray(xyz)

This will result in 'reversedArray' containing ['3','2','1','z','y','x']. I hope this explanation was helpful!

If you're looking for a concise solution, consider using the .map method which works perfectly in this scenario and can be accomplished in just one line of code:

const reverseArray = arr => { let index = arr.length; return arr.map(item => arr[index -= 1]) }

This function will iterate through the array and rearrange each element based on its position relative to the opposite side of the array.

Implementing reverse functionality using a for loop

let names = ["John", "Lisa", "Michael"]

    len = names.length
    reversedNames = [];
    for (let j = len-1; j >= 0; j--) {

        reversedNames.push(names[j])

    }

    console.log(reversedNames)

Check this out:

function reverseArray(arr) { 
    let start = 0;
    let end = arr.length - 1;
    let temp = 0;
    
    while (end - start >= 1) {
        temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
}

function reverseArray(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    arr.splice(i, 0, arr.pop())
  }
  return arr;
}
console.log(reverseArray([10, 20, 30, 40, 50]))
//no additional array needed

reverseArray = arr => arr.map((elem, index) => arr[arr.length - 1 - index])

reverseArray = arr => arr.map((elem, index) => arr[arr.length - 1 - index])

console.log(reverseArray(["Fantastic","Is","This","Practice"]))

This code snippet is a concise way to reverse an array:

let reverseArray = arr.map(arr.pop, [...arr])

Although this question is dated, it could still be beneficial for someone seeking assistance.

There are two primary methods to achieve this:

The first approach involves creating a new array and pushing elements from the original array in reverse order:

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

arrReverse([0,1,2,3,4,5,6,7,8,9]);

The second method is an in-place reversal technique where you mentally hold the first and last objects of the array and swap them systematically while incrementing and decrementing the positions at both ends:

function reverseArr(arr) {
    let lh;
        
    for(let i = 0; i<arr.length/2; i++){
    
            lh = arr[i];
        arr[i] = arr[arr.length -i -1];
        arr[arr.length -i -1] = lh;
        
    }
    return arr;
}

reverseArr([0,1,2,3,4,5,6,7,8,9]);

A variable 'lh' (short for "left hand") can enhance the comprehension of this process.

Mastery over arrays is crucial as understanding their functionality not only simplifies complex operations like this but also enhances one's grasp on fundamental data concepts!

I stumbled upon a clever method to reverse an array:

function backwards(arr){
  for (let j = arr.length-1; j >= 0; j--){ 
    arr.splice(j, 0, arr.shift());
    }
  return arr;
}

Achieve Array Reversal without using Built-in Functions

const reverseArrayManually = (arr) => {
  for (let x = 0; x < Math.floor(arr.length / 2); x++) {
    [arr[x], arr[arr.length - x - 1]] = [
      arr[arr.length - x - 1],
      arr[x]
    ];
  }
  return arr;
};

let nums = [6, 5, 4, 3, 2, 1];

const reverseArray = (nums) => {

let reversedNums = [];

for(let x = nums.length - 1; x >= 0; x--){
    reversedNums[nums.length - x] = nums[x];
}

return reversedNums;

}

console.log(reverseArray(nums))

    const word = ['h', 'a', 'p', 'p', 'y'];
    const reversedWord = [];

    word.map((letter, index) => {
        const reverseIndex = word.length - (index + 1);
        reversedWord[reverseIndex] = letter;
    })

An easy method that leverages array.map() and avoids the use of additional arrays

const numbers = [1, 2, 3, 4, 5];
numbers.map((num, idx) => {
    return numbers[numbers.length - idx - 1];
})

Pythonic 🐍 approach to In-place algorithm:

function reverseList(arr) {
    let [start, end] = [0, arr.length - 1];

    while (start < end) {
        [arr[start], arr[end]] = [arr[end], arr[start]];
        
        start += 1;
        end -= 1;
    }
    return arr;
}