CODEWITHSUNDEEP
javascript
William Smith
William Smith

Reputation: 852

Javascript, moving elements in an array from front to back

I have an array that contains variables and functions. The array is 80 elements long. The first 20 elements are used together in a for loop. When the loop has completed, the first twenty elements are moved to the back of the array, and the for loop starts again.

I am rebuilding the array this way:

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

So I am basically indexing the (new) sliced array, re-indexing the (original) array after the splice, indexing a (new) array after the concat, and re-indexing the original again when I set it equal to the concat. This seems like it is too inefficient. Is there a more established approach to this?

Upvotes: 3

Views: 2519

Answers (2)

Travis J
Travis J

Reputation: 82267

You wanted efficiency, so here it is: 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;
  }
 }
}

EDIT

I had assumed that by swapping in place instead of creating more arrays time would be saved, but in fact I do not think it is. Although this may have a smaller footprint on memory, it does not run faster than the accepted answer. Here is a jsperf showing the difference: http://jsperf.com/array-modifications

Upvotes: 1

Travesty3
Travesty3

Reputation: 14469

You don't need to slice() and then splice(). Splice() returns the removed elements, so you just need to do that:

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

To be completely clear, JavaScript's splice() method returns the removed elements, not the remaining elements.

Also, using globals is generally a bad idea, but you are also kinda mixing them in a weird way. If you are going to keep the variable global, I would either pass the original in as a parameter and return the result from the function:

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

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

OR

don't pass it in at all and just reference the global from the get-go:

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

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

Upvotes: 7

Related Questions