Javascript, déplacement des éléments d'un tableau de l'avant vers l'arrière

Question

J'ai un tableau qui contient des variables et des fonctions. Le tableau compte 80 éléments. Les 20 premiers éléments sont utilisés ensemble dans une boucle for. Lorsque la boucle est terminée, les vingt premiers éléments sont déplacés à l'arrière du tableau, et la boucle for recommence.

Je reconstruis le tableau de cette façon :

var a2=[the array with 80 elements];
run(a2);
function run(array){
  var n=array.slice(0,20); array.splice(0,20);
  var con=array.concat(n); a2=con;
  }

Je suis donc en train d'indexer le (nouveau) tableau découpé, de réindexer le tableau (original) après le découpage, d'indexer un (nouveau) tableau après le concat, et de réindexer à nouveau l'original lorsque je l'égalise au concat. Cela semble trop inefficace. Existe-t-il une approche plus établie ?

Answer 1

Vous n'avez pas besoin de slice() et ensuite splice() . Splice() renvoie à les éléments retirés, donc vous devez juste faire ça :

var n = array.splice(0, 20);
a2 = array.concat(n);

---

Pour être tout à fait clair, JavaScript splice() La méthode retourne les éléments retirés et non les autres éléments.

De plus, l'utilisation de globaux est généralement une mauvaise idée, mais vous les mélangez aussi d'une manière étrange. Si vous voulez garder la variable globale, je passerais l'original en tant que paramètre et retournerais le résultat de la fonction :

var a2=[the array with 80 elements];
a2 = run(a2);

function run(array){
    var n = array.splice(0, 20);
    return array.concat(n);
}

OU

ne pas le passer du tout et juste faire référence au global dès le départ :

var a2=[the array with 80 elements];
run();

function run(){
    var n = a2.splice(0, 20);
    a2 = a2.concat(n);
}

Answer 2

Vous vouliez de l'efficacité, alors la voici : http://jsfiddle.net/Hvcbj/

//This is tightly coupled to work for the first 20 of an 80 length array
function swapTwenty( array )
{
 for( var i = 0, max = 20; i < max; i++ )
 {
  var temp = array[i];
  for( var n = 1, len = 4; n < len; n++)
  {
   var base = (i + 20 * (n - 1)) % 80;
   var tar = (i + 20 * n) % 80;
   array[base] = array[tar];
   array[tar] = temp;
  }
 }
}

EDITAR

J'avais supposé qu'en échangeant à la place au lieu de créer plus de tableaux, on gagnerait du temps, mais en fait je ne pense pas que ce soit le cas. Bien que cela puisse avoir une empreinte plus petite sur la mémoire, cela ne fonctionne pas plus vite que la réponse acceptée. Voici un jsperf qui montre la différence : http://jsperf.com/array-modifications