Matrice inversa in Javascript senza mutare la matrice originale

Array.prototype.reverse inverte il contenuto di un array in atto (con mutazione) ...

Esiste una strategia altrettanto semplice per invertire un array senza alterare il contenuto dell'array originale (senza mutazione)?

È possibile utilizzare slice () per effettuare una copia poi invertire () è

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

Un'altra variante ES6:

Possiamo anche usare .reduceRight()per creare un array invertito senza effettivamente invertirlo.

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

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

console.log(B);

Risorse utili:

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

Prova questa soluzione ricorsiva:

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!                              

Un'alternativa ES6 usando .reduce()e diffondendo.

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

Fondamentalmente quello che fa è creare un nuovo array con l'elemento successivo in foo e diffondere l'array accumulato per ogni iterazione dopo b.

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

In alternativa, .reduceRight()come menzionato sopra qui, ma senza la .push()mutazione.

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

Esistono diversi modi per invertire un array senza modificarlo. Due di loro lo sono

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 delle prestazioni http://jsben.ch/guftu

INTO Javascript semplice:

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

  return newArray;
}

Inversione in atto con scambio variabile solo a scopo dimostrativo (ma è necessaria una copia se non si desidera mutare)

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)