JavaScript variables declare outside or inside loop?

JavaScript variables declare outside or inside loop?

In AS3 I believe you should initialise all variables outside loops for increased performance. Is this the case with JavaScript as well? Which is better / faster / best-practice?
var value = 0;

for (var i = 0; i < 100; i++) { value = somearray[i]; } or for (var i = 0 ; i < 100; i++) { var value = somearray[i]; }


Solution 1:

There is absolutely no difference in meaning or performance, in JavaScript or ActionScript.

var is a directive for the parser, and not a command executed at run-time. If a particular identifier has been declared var once or more anywhere in a function body(*), then all use of that identifier in the block will be referring to the local variable. It makes no difference whether value is declared to be var inside the loop, outside the loop, or both.

Consequently you should write whichever you find most readable. I disagree with Crockford that putting all the vars at the top of a function is always the best thing. For the case where a variable is used temporarily in a section of code, it’s better to declare var in that section, so the section stands alone and can be copy-pasted. Otherwise, copy-paste a few lines of code to a new function during refactoring, without separately picking out and moving the associated var, and you’ve got yourself an accidental global.

In particular:

for (var i; i<100; i++)
    do something;

for (var i; i<100; i++)
    do something else;

Crockford will recommend you remove the second var (or remove both vars and do var i; above), and jslint will whinge at you for this. But IMO it’s more maintainable to keep both vars, keeping all the related code together, instead of having an extra, easily-forgotten bit of code at the top of the function.

Related:  google.setOnLoadCallback with jQuery $(document).ready(), is it OK to mix?

Personally I tend to declare as var the first assignment of a variable in an independent section of code, whether or not there’s another separate usage of the same variable name in some other part of the same function. For me, having to declare var at all is an undesirable JS wart (it would have been better to have variables default to local); I don’t see it as my duty to duplicate the limitations of [an old revision of] ANSI C in JavaScript as well.

(*: other than in nested function bodies)

Solution 2:

In theory it shouldn’t make any difference in JavaScript, since the language does not have block scope, but only function scope.

I’m not sure about the performance argument, but Douglas Crockford still recommends that the var statements should be the first statements in the function body. Quoting from Code Conventions for the JavaScript Programming Language:

JavaScript does not have block scope, so defining variables in blocks can confuse programmers who are experienced with other C family languages. Define all variables at the top of the function.

I think he has a point, as you can see in the following example. Declaring the variables at the top of the function should not confuse readers into thinking that the variable i is held in the scope of the for loop block:

function myFunction() {
  var i;    // the scope of the variables is very clear

  for (i = 0; i < 10; i++) {
    // ...

Solution 3:

The ECMA-/Javascript language hoists any variable which is declared anywhere to the top of a function. That is because this language does have function scope and does not have block scope like many other C-like languages.
That is also known as lexical scope.

If you declare something like

var foo = function(){
    for(var i = 0; i < 10; i++){

This gets hoisted to:

var foo = function(){
    var i;
    for(i = 0; i < 10; i++){

So it does not make any difference in performance (But correct me if I’m totally wrong here).
A much better argument for not declaring a variable somewhere else than at the top of a function is readability. Declaring a variable within a for-loop might lead to the wrong assumption that this variable can only be accessed within the loop body, which is totally wrong. Infact you can access that variable anywhere within the current scope.

Related:  chart.js load totally new data

Solution 4:

Next year, all browsers will have JS engines that precompile the code so the performance difference (which comes from parsing the same block of code again and again plus executing the assignment) should become negligible.

Also, never optimize for performance unless you have to. Keeping variables close to the place where you need them the first time keeps your code clean. On the negative side, people who are used to languages with block scopes might be confused.

Solution 5:

I just did a simple test in Chrome. Try the fiddle in your browser and see the results

  var count = 100000000;
    var a = 0;
    console.log(new Date());

    for (var i=0; i<count; i++) {
      a = a + 1

    console.log(new Date());

    var j;
    for (j=0; j<count; j++) {
      a = a + 1;

    console.log(new Date());

    var j;
    for (j=0; j<count; j++) {
        var x;
        x = x + 1;

    console.log(new Date());

Result is that the last test takes ~8 seconds and the previous 2 are only ~2 seconds. Very repeatably and regardless of order.

Related:  Difference between console.log and sys.puts in node.js?

So, this proves to me, that one should always declare the vars outside of the loop. Curious case to me is the first one where I declare i in the for() statement. This one appears to be just as fast as the 2nd test where I pre-declare the index.

Solution 6:

Another consideration, now that we have let and const in ES2015, is that you can now scope variables specifically to the loop block. So unless you will need the same variable outside the loop (or if each iteration depends on an operation done to that variable in the previous iteration), it’s probably preferable to do this:

for (let i = 0; i < 100; i++) {
    let value = somearray[i];
    //do something with `value`