5

In JavaScript I am filling array elements by traditional way, such as:

myArray[12] = 123;
myArray[13] = 432;
myArray[14] = 233;
myArray[15] = 98;

Is it possible to do this faster by one command?

For example to put numbers [123, 432, 233, 98] to myArray[12-15] ... somehow? Not one by one.

And how can be optimized this kind of scenario:

newArray[12] = oldArray[30];
newArray[13] = oldArray[31];
newArray[14] = oldArray[32];
newArray[15] = oldArray[33];

when n elements (4 in the above example) next each to other from one array need to be moved to another array?

Please advice.

Improve this question
1
  • Where are the values coming from? Commented Jul 6, 2012 at 19:41

6 Answers 6

Reset to default
10 
var myArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 
               12, 13, 14, 15, 16, 17, 18, 19, 20];
myArray.splice(12, 4, 123, 432, 233, 98);

// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 
//  123, 432, 233, 98, 16, 17, 18, 19, 20]

The first parameter to splice is the index to start with, the second is the number of elements to remove, the remainder are elements to insert. So if you insert the same number as were removed, you end up replacing them.

If you do want this to come from another array, you could try this, although it is not as clean:

var oldArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
               12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
               22, 23, 24, 25, 26, 27, 28, 29, 123, 
               432, 233, 98, 34, 35]
var newArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 
               12, 13, 14, 15, 16, 17, 18, 19, 20];

[].splice.apply(newArray, [12, 4].concat(oldArray.slice(30, 30 + 4)));

// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
// 123, 432, 233, 98, 16, 17, 18, 19, 20]

This is probably less efficient than PointedEars suggestion but it's quite simple and would probably serve for many use cases.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

4

The closest you can come is to use splice to set the input position.

The first argument is the index to at which to begin, the second argument is how many items to remove, and the next arguments are the values....

Here is some output I get messing around in a console.

myArray = new Array(15)
myArray.splice(12, 4, 123, 432, 223, 98)
myArray.forEach(function(v, i){console.log(v, i)})
123 12
432 13
223 14
98 15
undefined
myArray[12]
123
myArray[13]
432
myArray[14]
223
myArray[15]
98

Of course this has several deficiencies: you can't pass an array of values you want to insert, the array needs to be large enough (i.e you cant insert at index 12 unless the array is at least 12 long).

For transferring values at one set of indexes in one array to another set of indexes in another array, I think you have to loop. splice takes the values to add individually, not as an array. You could of course write a single method with the loop, and reuse it.

Improve this answer

4 Comments

Good idea, but Array.prototype.splice() will insert the elements, not replace existing ones. To work around that, you will have to remove as many elements as you are inserting. I think the best solution here is to use a loop, but it would be nice if ECMAScript implementations would support slice-replace as Python does. Maybe in Harmony (ES 6).
just did, you are SOL, you have to loop.
SOL = Sht out of luck. As in, "you can't do it without looping, you are SOL, sorry"
I see. However, you can do it without a loop: var items = [123, 432, 223, 98]; myArray.splice.apply(myArray, [12, items.length].concat(items));. The question is, would you want to? It is more than twice as expensive than the ordinary, perhaps generalized, loop. And I am not even talking about memory here. See also my answer.
4

Latest Method: Use Spread with Splice

Here is the latest and easiest way to do this.

Use ... (spread) operator along with splice method used in previous examples.

This removes 4 elements starting from index 12 and then inserts your required array into positions 12 to 15.

Try Sample Code

const myArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 
               12, 13, 14, 15, 16, 17, 18, 19, 20];

console.log('Before:', JSON.stringify(myArray));

myArray.splice(12, 4, ...[123, 432, 233, 98]);

console.log('After: ', JSON.stringify(myArray));

Further Reference: ECMAScript (ECMA-262)

Improve this answer

1 Comment

An interesting drawback of any approach with spread function params involves unexpected stack-overflow errors - this is because javascript passes argument via the stack. For arr.splice(1, 2, ...[ /* a million items */ ]) you will encounter stack-overflow issues.
2

You should use .concat(), as follows: 

myArray = myArray.concat([123, 432, 233, 98])

Or use .push() as follows:

myArray.push(123,432,233,98)
Improve this answer

Comments

2

Array.prototype.push() and Array.prototype.splice() are nice ideas, but push() always appends to the end of the array (that is, starting from the index specified by the length property), and splice() requires you to remove as many elements as you are inserting before you are inserting (which is twice as expensive as it needs to be).

Therefore, you should use a loop:

 for (var i = 12; i < 16; ++i)
 {
   _new[i] = old[i + 18];
 }

(new is a keyword, thus reserved; your example code is not executable. I have used _new here to work around that.)

This can be generalized:

function putValues(array1, array2, start1, start2, num)
{
  if (typeof start1 == "undefined") start1 = 0;
  if (typeof start2 == "undefined") start2 = 0;
  var max = (typeof num == "undefined") ? array2.length : start2 + num;

  for (var i = start1, j = start2; j < max; ++i, ++j)
  {
    array1[i] = array2[j];
  }
}

putValues(newArray, oldArray, 12, 30, 4);

More sophisticated generalizations are conceivable, such as passing one or two arrays of indexes, so that the indexes do not have to be successive.

(Resist the temptation to make this a method of Array.prototype, unless you want to have to use Object.prototype.hasOwnProperty() when iterating efficiently with for-in in an unordered fashion over sparse arrays.)

Next time, try something first.

Improve this answer

5 Comments

splice does not require you to remove any particular number of elements. If you want to replace a certain set of them in this manner, you should remove that number. But that doesn't seem much of a limitation.
@ScottSauyet Read the question again.
And thanks for the downvotes. Just because you do not understand or like an answer it does not mean it is wrong or not useful.
I reread the question and saw "Is it possible to do this faster by one command?". When I saw your, probably efficient, but far from succinct code, I down-voted. That was hasty, though, and I removed it.
Also, I don't believe the addition of the source of the old data was in the question when I answered it. (I may be wrong about it.) But the basic question is quite simple, and answered quite simply.
1

you can use push function:

myarray.push([123, 432, 233, 98]);

to add whole array to your array or to add individual items:

myarray.push(123, 432, 233, 98);

To add to specific location, you would need to use splice() function.

Docs:

Improve this answer

2 Comments

@Blaster Pushing an array onto an array isn't going to do what you expect
@Ωmega: I have also added splice function which allows you to put items at specified position.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.