array .prototype.reverse将数组的内容反向(带有突变)…
是否有类似的简单策略来反转数组而不改变原始数组的内容(不发生突变)?
你可以使用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);
ES6的另一个变体:
我们也可以使用. reduceright()来创建一个反向数组，而不是真正地将它反向。
let A = [' A '， 'b'， 'c'， 'd'， 'e'， 'f']; 让B = A.reduceRight ((a、c) = > (a.push (c), a), []); console.log (B);
有用的资源:
Array.prototype.reduceRight () 箭头功能 逗号操作符
使用.reduce()和spread的ES6替代方案。
const foo = [1, 2, 3, 4];
const bar = foo.reduce((acc, b) => ([b, ...acc]), []);
基本上，它所做的是用foo中的下一个元素创建一个新数组，并在b之后的每次迭代中扩展累积的数组。
[]
[1] => [1]
[2, ...[1]] => [2, 1]
[3, ...[2, 1]] => [3, 2, 1]
[4, ...[3, 2, 1]] => [4, 3, 2, 1]
或者如上所述的. reduceright()，但没有.push()突变。
const baz = foo.reduceRight((acc, b) => ([...acc, b]), []);
有多种方法可以在不修改的情况下反转数组。其中两个是
var array = [1,2,3,4,5,6,7,8,9,10];
// Using Splice
var reverseArray1 = array.splice().reverse(); // Fastest
// Using spread operator
var reverseArray2 = [...array].reverse();
// Using for loop
var reverseArray3 = [];
for(var i = array.length-1; i>=0; i--) {
reverseArray.push(array[i]);
}
性能测试http://jsben.ch/guftu
试试这个递归解决方案:
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!
进入纯Javascript:
function reverseArray(arr, num) {
var newArray = [];
for (let i = num; i <= arr.length - 1; i++) {
newArray.push(arr[i]);
}
return newArray;
}
仅出于演示目的，使用变量交换进行反向(但如果不想发生变化，则需要一个副本)
const myArr = ["a", "b", "c", "d"];
const copy = [...myArr];
for (let i = 0; i < (copy.length - 1) / 2; i++) {
const lastIndex = copy.length - 1 - i;
[copy[i], copy[lastIndex]] = [copy[lastIndex], copy[i]]
}
const arrayCopy = Object.assign([], array).reverse()
这个解决方案:
-成功复制array
-不会改变原始数组
-看起来它在做它该做的事
const originalArray = [a, b, c, d, e, f); const newArray = Array.from(originalArray).reverse(); console.log (newArray);
有一个新的tc39提案，它向Array添加了一个toReversed方法，该方法返回数组的副本，而不修改原始数组。
提案示例:
const sequence = [1, 2, 3];
sequence.toReversed(); // => [3, 2, 1]
sequence; // => [1, 2, 3]
由于它目前处于第3阶段，可能很快就会在浏览器引擎中实现，但与此同时，polyfill可以在这里或core-js中使用。
是否有类似的简单策略来反转数组而不改变原始数组的内容(不发生突变)?
是的，有一种方法可以通过使用to[Operation]来实现这一点，它返回一个带有应用操作的新集合(目前处于第3阶段，很快就会可用)。
实现方式如下:
const arr = [5, 4, 3, 2, 1];
const reversedArr = arr.toReverse();
console.log(arr); // [5, 4, 3, 2, 1]
console.log(reversedArr); // [1, 2, 3, 4, 5]
进入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);
