I was browsing around and I found this:
var i, len; for(i = 0, len = array.length; i < len; i++) { //... } My first thoughts are:
Do normal loops (the ones that don't cache the length) check the array.length each time?
A loop consisting of three parts is executed as follows:
for (A; B; C) A - Executed before the enumeration B - condition to test C - expression after each enumeration (so, not if B evaluated to false) So, yes: The .length property of an array is checked at each enumeration if it's constructed as for(var i=0; i<array.length; i++). For micro-optimisation, it's efficient to store the length of an array in a temporary variable (see also: What's the fastest way to loop through an array in JavaScript?).
Equivalent to for (var i=0; i<array.length; i++) { ... }:
var i = 0; while (i < array.length) { ... i++; } 
B, its necesarry to have one lookup on the object/Array for each iteration, that is slower than having a lookup with the local scope. Its always the fastest possible way to lookup something if it can get found in the local scope, that is why you would store the length in the current scope by using var foo =.
Is it worth it? (obviously yes, why else he will do it this way?)
Absolutely yes. Because, as you say, loop will calculate array length each time. So this will cause an enormous overhead. Run the following code snippets in your firebug or chrome dev tool vs.
// create an array with 50.000 items (function(){ window.items = []; for (var i = 0; i < 50000; i++) { items.push(i); } })(); // a profiler function that will return given function's execution time in milliseconds var getExecutionTime = function(fn) { var start = new Date().getTime(); fn(); var end = new Date().getTime(); console.log(end - start); } var optimized = function() { var newItems = []; for (var i = 0, len = items.length; i < len; i++) { newItems.push(items[i]); } }; var unOptimized = function() { var newItems= []; for (var i = 0; i < items.length; i++) { newItems.push(items[i]); } }; getExecutionTime(optimized); getExecutionTime(unOptimized); Here is the approximate results in various browsers
Browser optimized unOptimized Firefox 14 26 Chrome 15 32 IE9 22 40 IE8 82 157 IE7 76 148
So consider it again, and use optimized way :)
Note: I tried to work this code on jsPerf but I couldn't access jsPerf now. I guess, it is down when I tried.
I always thought in JavaScript length was just a property of the array object, pre-calculated by previous array operations - creation, addition, removal - or overridden by the user, so you're just looking up a variable anyway? I must admit I had just assumed that because of the lack of parenthesis, but looking at the MDN page for array.length, it seems to say the same thing.
In languages where length is a method or length is calculated by a standard library function, then you should pre-calculate the length before running the loop so The array isn't calculated every iteration, particularly for large datasets. Even then, in modern high level languages like Python, len() just returns the length property of the array object anyway.
So unless I'm mistaken, the complexity is just O(1), and from that standpoint, even if the variable were slightly faster than a property to lookup each pass, it wouldn't be worth the potential trouble of creating/reusing additional variables outside of the protective for loop scope.
However, I suspect that in this case the reason the example's programmer chose this approach is simply just a habit they picked up in another language and carried forwards JavaScript.
One reason to do this would be to iterate only over the initial length of an array while new elements are being added. For example, this loop appends a copy of an array to itself, turning [0, 1, 2] into [0, 1, 2, 0, 1, 2]:
const initialLength = items.length; for (let i = 0; i < initialLength; ++i) { items.push(items[i]); } If we did not store the length and instead compared i to items.length on every iteration, it would cause an infinite loop.
Otherwise, if you find loops written like this for no apparent reason, it is probably a naive attempt at optimization. Modern JavaScript engines know how to optimize common tasks such as array iteration, so this is entirely unnecessary.
Yes Its check the array.length every time, but if we don't want to run our loop for increased array then, in that case, we can use forEach method.
forEach is a javascript in build method which is does like for loop, but forEach only iterative the elements in an array which are before the loop start.
Let's understand this from below snippet:
array = [1,2,3,4] for(i=0;i<=array.length;i++){ console.log(array[i]); array.push(array[i]+1); }output like 1 2 3 4 5 6 ...so on (infinite) while its checking array.length each time
let's check with forEach method
array = [1,2,3,4] array.forEach((element) => { console.log(element); array.push(element+1); }) console.log("array elements after loop",array);it only processes for 4 elements which are present in array before iteration start.
**but in forEach case, it will affect on array.length if we pop out the element from array.
lets see this by an example:
array = [1,2,3,4] array.forEach((element) => { console.log(element); array.pop() }) console.log("array elements after loop",array);Here are a number of performance tests for different approaches
