Array in Javascript umkehren, ohne das ursprüngliche Array zu mutieren

Array.prototype.reverse kehrt den Inhalt eines Arrays um (mit Mutation) ...

Gibt es eine ähnlich einfache Strategie zum Umkehren eines Arrays, ohne den Inhalt des ursprünglichen Arrays zu ändern (ohne Mutation)?

Sie können Slice () verwenden , um eine Kopie zu erstellen, und diese dann umkehren ()

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

var array = ['a', 'b', 'c', 'd', 'e'];
var newarray = array.slice().reverse();

console.log('a', array);
console.log('na', newarray);

In ES6:

const newArray = [...array].reverse()

Eine weitere ES6-Variante:

Wir können auch .reduceRight()ein umgekehrtes Array erstellen, ohne es tatsächlich umzukehren.

let A = ['a', 'b', 'c', 'd', 'e', 'f'];

let B = A.reduceRight((a, c) => (a.push(c), a), []);

console.log(B);

Nützliche Ressourcen:

• Array.prototype.reduceRight()
• Arrow Functions
• Comma Operator

Versuchen Sie diese rekursive Lösung:

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!                              

Eine ES6-Alternative zur Verwendung .reduce()und Verbreitung.

const foo = [1, 2, 3, 4];
const bar = foo.reduce((acc, b) => ([b, ...acc]), []);

Grundsätzlich wird ein neues Array mit dem nächsten Element in foo erstellt und das akkumulierte Array für jede Iteration nach b verteilt.

[]
[1] => [1]
[2, ...[1]] => [2, 1]
[3, ...[2, 1]] => [3, 2, 1]
[4, ...[3, 2, 1]] => [4, 3, 2, 1]

Alternativ .reduceRight()wie hier oben erwähnt, jedoch ohne die .push()Mutation.

const baz = foo.reduceRight((acc, b) => ([...acc, b]), []);

Es gibt mehrere Möglichkeiten, ein Array umzukehren, ohne es zu ändern. Zwei von ihnen sind

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]);
}

Leistungstest http://jsben.ch/guftu

IN einfaches Javascript:

function reverseArray(arr, num) {
  var newArray = [];
  for (let i = num; i <= arr.length - 1; i++) {
    newArray.push(arr[i]);
  }

  return newArray;
}

Umkehren mit variablem Tausch nur zu Demonstrationszwecken (Sie benötigen jedoch eine Kopie, wenn Sie nicht mutieren möchten).

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]] 
}

es6:

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