Inverser le tableau en Javascript sans muter le tableau d'origine

Array.prototype.reverse inverse le contenu d'un tableau en place (avec mutation) ...

Existe-t-il une stratégie tout aussi simple pour inverser un tableau sans modifier le contenu du tableau d'origine (sans mutation)?

Vous pouvez utiliser slice () pour faire une copie puis inverse () il

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

Dans ES6:

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

Une autre variante ES6:

Nous pouvons également utiliser .reduceRight()pour créer un tableau inversé sans réellement l'inverser.

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

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

console.log(B);

Ressources utiles:

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

Essayez cette solution récursive:

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!                              

Une alternative ES6 utilisant .reduce()et épandant .

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

Fondamentalement, il crée un nouveau tableau avec l'élément suivant dans foo, et répartit le tableau accumulé pour chaque itération après b.

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

Alternativement .reduceRight()comme mentionné ci-dessus ici, mais sans la .push()mutation.

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

Il existe plusieurs façons d'inverser un tableau sans le modifier. Deux d'entre eux sont

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

Test de performance http://jsben.ch/guftu

EN Javascript brut:

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

  return newArray;
}

Inverser en place avec échange de variables juste à des fins de démonstration (mais vous avez besoin d'une copie si vous ne voulez pas muter)

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)