虽然不是最好的解决方案，但确实有效 Array.prototype.myNonMutableReverse = function () { const reversedArr = []; 对于(let I = this。)长度- 1;I >= 0;我——)reversedArr.push(这[我]); 返回reversedArr; }; Const a = [1,2,3,4,5,6,7,8]; const b = a.myNonMutableReverse(); console.log(“a”); console.log ("////////") console.log (b, b);

进入2022年，这是当今最高效的解决方案(性能最高，并且没有额外的内存占用)。

对于任何ArrayLike类型，逻辑上最快的反转方法是将其包装为反转迭代对象:

function reverse<T>(input: ArrayLike<T>): Iterable<T> {
    return {
        [Symbol.iterator](): Iterator<T> {
            let i = input.length;
            return {
                next(): IteratorResult<T> {
                    return i
                        ? {value: input[--i], done: false}
                        : {value: undefined, done: true};
                },
            };
        },
    };
}

通过这种方式，你可以反向迭代任何数组，字符串或缓冲区，而不需要任何额外的复制或处理反向数据:

for(const a of reverse([1, 2, 3])) {
    console.log(a); //=> 3 2 1
}

这是最快的方法，因为你不复制数据，也不做任何处理，你只是在逻辑上反向。

虽然不是最好的解决方案，但确实有效 Array.prototype.myNonMutableReverse = function () { const reversedArr = []; 对于(let I = this。)长度- 1;I >= 0;我——)reversedArr.push(这[我]); 返回reversedArr; }; Const a = [1,2,3,4,5,6,7,8]; const b = a.myNonMutableReverse(); console.log(“a”); console.log ("////////") console.log (b, b);

es6:

const reverseArr = [1,2,3,4].sort(()=>1)

试试这个递归解决方案:

const reverse = ([head, ...tail]) => 
    tail.length === 0
        ? [head]                       // Base case -- cannot reverse a single element.
        : [...reverse(tail), head]     // Recursive case

reverse([1]);               // [1]
reverse([1,2,3]);           // [3,2,1]
reverse('hello').join('');  // 'olleh' -- Strings too!                              

你可以使用slice()来复制，然后reverse()它

var newarray = array.slice().reverse();

Var array = ['a'， 'b'， 'c'， 'd'， 'e']; Var newarray = array.slice().reverse(); console.log (a、数组); console.log(“na”,newarray);