current community

your communities

more stack exchange communities

company blog
Stack Exchange Inbox Reputation and Badges
tour help
Join the Stack Overflow Community
Stack Overflow is a community of 6.5 million programmers, just like you, helping each other.
Join them; it only takes a minute:
Sign up
up vote 31 down vote favorite
7

I commonly see developers use an expression like the following in JavaScript:

arr = []
arr[arr.length] = "Something"
arr[arr.length] = "Another thing"

Wouldn't push be more appropriate?

arr = []
arr.push("Something")
arr.push("Another thing")
share|improve this question
1  
I realise I'm only a hobbyist, but I do use push(), and now I feel like I'm missing some hitherto secret contraindication for such usage... – David Thomas Mar 27 '13 at 0:27
    
I frequently use it, although I prefer an indexer where it makes more logical sense (like a for loop). – Tim Medora Mar 27 '13 at 0:28
    
People do sometimes think it's faster. See Why is array.push sometimes faster than array[n] = value? and Using the push method or .length when adding to array? - results vary so wide that it's actually irrelevant. Use what is better to understand. – Bergi Mar 27 '13 at 1:16
    
What is faster is to increment a variable for the index, rather than using push or reading the growing array.length every iteration. Not that the difference is measurable by a human. – kennebec Mar 27 '13 at 6:59
    
Regarding this benchmark, push is faster in Chrome: jsben.ch/#/rGPv3 – EscapeNetscape Oct 21 '16 at 10:24
up vote 40 down vote accepted

I actually asked myself the same question at the start of this year. UPDATED with new test cases http://jsperf.com/array-push-vs-unshift-vs-direct-assignment/2

It appears that push is much faster in chrome, and about equal in FF. Also direct is faster in IE9, but I would be interested to see how it performs in IE10.

I would say that most developers would assume setting the length of the array, and then using direct assignment is faster, as is the case with most programming languages. But JavaScript is different. Javascript arrays aren't really arrays, they're just key/value maps just like all other JavaScript objects. So the pre-allocation is essentially falling on deaf ears.

Personally I prefer push (:

share|improve this answer
1  
+1 - added a few IE 10 runs for you. – Tim Medora Mar 27 '13 at 1:14
    
My assumption was performance too. And at one point, it certainly may have been faster to avoid push(). Certainly not anymore though though! +1 – svidgen Mar 27 '13 at 15:07
4  
Direct assignment has become considerably faster in newer versions of Chrome. Direct assignment (even using .length) is now almost twice as fast as using push. – AgDude Feb 4 '14 at 16:30
up vote 7 down vote

It's all about performance - but it does not really matters I guess http://www.scottlogic.co.uk/2010/10/javascript-array-performance/

share|improve this answer
1  
Wow, I set up this JS Perf thinking, "no, there's no way it'll be significant!" +1, and thank you for drawing it to my attention! – David Thomas Mar 27 '13 at 0:31
1  
+1. My guess is that it comes down to the fact that array.Push(something) is probably just an implementation of arr[arr.length] = something or similar anyway, but has the additional overhead of a function call, passing parameters, returning the new index as the result etc. If this was the case though, I would've expected the compiler/JIT/runtime would just in-line it so it was equivalent - but these results suggest not! – Sepster Mar 27 '13 at 0:37
1  
@DavidThomas Try it with a few more entries jsperf.com/approaches-for-array-population/2 – gkiely Mar 27 '13 at 1:01
up vote 3 down vote

I believe that it's mostly habit.

Some developers use it simply because it's the way they are used to do it, and haven't considered that push would be an alternative.

Some developers have learned once upon a time that one method is much faster than another, and haven't reviewed this in light of the recent performance improvements of the Javascript engines.

Personally I use push frequently. Most of the time readability and maintainability is more important than performance, at least when the performance impact is small enough. The performance tests posted in the answers here show that the performance difference between various methods isn't very big.

share|improve this answer
    
+1, it definitely is. And not only is the performance difference small, but changing between every test case and browser version :-) – Bergi Mar 27 '13 at 1:18
up vote 1 down vote

It's a way to limit nested braclets. If you have enough of them you cant see howmany there are or howmany you need (when later looking at the code). I would use a var, one should only have to count things one time.

bar = foo.length;
foo[ bar++ ] = "new item 0";
foo[ bar++ ] = "new item 1";
foo[ bar++ ] = "new item 2";
foo[ bar++ ] = "new item 3";

http://jsfiddle.net/vEUU3/

share|improve this answer
up vote 1 down vote

Very often when I'm pushing an object into an array, I want the reference to that object to be returned to me. For example:

// Returns object
function createAndAdd(arr) {
  return arr[arr.length] = { id: 1 };
} 
var obj = createAndAdd(arr);

Now I have the new object and I've added it to an array. If I'd used push then I would have been returned the length of the array. It would look like the following: 

function createAndAdd(arr) {
  var obj = { id: 1 };
  arr.push(obj);
  return obj;
}

or even uglier, especially if the object gets big:

function createAndAdd(arr) {
  return arr[arr.push({ id: 1 }) -1];
}

Personally, I love functions with immediate return statements. Keeps it simple and easy to look at. Love the question. Thanks for asking it.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.