Declaring variables without var keyword

Question

At w3schools there is written:

If you declare a variable, without using "var", the variable always becomes GLOBAL.

Is it useful to declare global variable inside the function? I can imagine to declare some global variables in some event handler, but what is it good for? Better usage of RAM?

Solution 1

No, there's no RAM benefit or anything like that.

What w3schools is talking about is something I call The Horror of Implicit Globals. Consider this function:

function foo() {
    var variable1, variable2;

    variable1 = 5;
    varaible2 = 6;
    return variable1 + variable2;
}

Seems simple enough, but it returns NaN, not 11, because of the typo on the varaible2 = 6; line. And it creates a global variable with the typo'd name:

function foo() {
    var variable1, variable2;

    variable1 = 5;
    varaible2 = 6;
    return variable1 + variable2;
}
console.log(foo());     // NaN
console.log(varaible2); // 6?!?!?!

This is because the function assigns to varaible2 (note the typo), but varaible2 isn't declared anywhere. Through the mechanics of the scope chain in JavaScript, this ends up being an implicit assignment to a (new) property on the global object (which you can access as window on browsers).

That's just a "feature" of loose-mode JavaScript, assigning to a completely undeclared identifier isn't an error; instead, it creates a propertly on the global object, and properties on the global object are global variables. (Up through ES5, all globals were properties of the global object. As of ES2015, though, a new kind of global was added that isn't a property of the global object. Global-scope let, const, and class create the new kind of global.)

My example is a typo, but of course, you could do it on purpose if you wanted. It's a clearly-defined part of the language, after all. So:

myNewGlobal = 42;

...anywhere that myNewGlobal isn't declared will create the new global.

But I would strongly recommend never doing it in purpose: It makes the code hard to read and maintain, and that code will be incompatible with JavaScript modules when they become more common and widespread. If you really need to create a global variable from within a function at runtime (already a red flag, but there are valid reasons for it), do it explicitly by assigning to a property on window (or whatever refers to the global object in your environment; it's window on browsers):

window.myNewGlobal = 42;

In fact, I'd suggest using ES5's strict mode. Strict mode makes assigning to an undeclared identifier an error rather than silently creating a global. If we'd been using strict mode, the problem with foo above would have been much easier to diagnose:

"use strict"; // Turns on strict mode for this compilation unit

function foo() {
    var variable1, variable2;

    variable1 = 5;
    varaible2 = 6;                 // <=== ReferenceError
    return variable1 + variable2;
}
console.log(foo());

---

Somewhat tangential, but in general I'd recommend avoiding globals wherever possible. The global namespace is already very, very cluttered on browsers. The browser creates a global for every element in the DOM with an id, for most elements with a name, and has several predefined globals of its own (like title) which can easily conflict with your code.

Instead, just define yourself a nice scoping function and put your symbols in it:

(function() {
    var your, symbols, here, if_they_need, to_be_shared, amongst_functions;

    function doSomething() {
    }

    function doSomethingElse() {
    }
})();

And if you do that, you might want to enable strict mode:

(function() {
    "use strict";
    var your, symbols, here, if_they_need, to_be_shared, amongst_functions;

    function doSomething() {
    }

    function doSomethingElse() {
    }
})();

...which, as mentioned, has the advantage of turning assignments to undeclared identifiers into errors (along with various other helpful things).

Note that in a JavaScript module (added in ES2015, but only now beginning to find their way into the wild), strict mode is enabled by default. (This is also the case with class definitions, also new in ES2015.)

Solution 2

Side Effects When Forgetting var

There’s one slight difference between implied globals and explicitly defined ones. The difference is in the ability to undefine these variables using the delete operator:

• Globals created with var (those created in the program outside of any function) cannot be deleted.

• Implied globals created without var (regardless if created inside functions) can be deleted.

This shows that implied globals are technically not real variables, but they are properties of the global object. Properties can be deleted with the delete operator whereas variables cannot:

// define three globals
var global_var = 1;
global_novar = 2; // antipattern
(function () {
   global_fromfunc = 3; // antipattern
}());
// attempt to delete
delete global_var; // false
delete global_novar; // true
delete global_fromfunc; // true
// test the deletion
typeof global_var; // "number"
typeof global_novar; // "undefined"
typeof global_fromfunc; // "undefined"

In ES5 strict mode, assignments to undeclared variables (such as the two antipatterns in the preceding snippet) will throw an error.

JavaScript Patterns, by Stoyan Stefanov (O’Reilly). Copyright 2010 Yahoo!, Inc., 9780596806750.

Solution 3

The only use of global variables is if you need to access them globally. In that case you should declare them using the var keyword outside the functions, to make it clear that you really want to create global variables, and didn't just forget the var when trying to declare a local variable.

Generally you should try to scope your code so that you need as little as possible in the global scope. The more global variables you use in your script, the less is the chance that you can use it along side another script.

Normally variables in a function should be local, so that they go away when you exit the function.

Solution 4

Declaring a variable inside of a function without the use of var, let, or const is no more useful inside the function than is declaring that variable with var, let, or const. And, as noted in previous answers to this question, function-local, implicit global declarations can be confusing and problematic outside the scope of the function where they were declared.

I'd like to speak to some subtleties that are missing from the w3schools quote, and from previous answers to this question.

First of all, if you never call the function that generates implicit globals, you won't generate any implicit globals. This is a subtle difference from the w3schools quote because it defies the "always" section of their statement.

function generateImplicitGlobals(){
  x = "x";
  window.y = "y";
}

// before calling the generateImplicitGlobals function, we can safely see that the x and y properties of the window object are both undefined:
console.log("before calling the generateImplicitGlobals function, properties x and y of the window object are: " + window.x + " and " + window.y);

// before calling the generateImplicitGlobals function, we can test for the existence of global variables x and y; note that we get errors instead of undefined for both.
try{
  console.log("before calling the generateImplicitGlobals function, x is: " + x);
}
catch(e){
  console.log("before calling the generateImplicitGlobals function, an attempt to reference some global variable x produces " + e);
}

try{
  console.log("before calling the generateImplicitGlobals function, y is: " + y);
}
catch(e){
  console.log("before calling the generateImplicitGlobals function, an attempt to reference the global variable b also produces " + e);
}

Admittedly, I am sure that w3schools is aware that the implicit global declaration inside a function isn't made before the function is called, but, for folks who are new to javascript, it may not be clear from the given information.

Regarding subtleties of previous answers, once the generateImplicitGlobals function has been called, we can see that attempts to access either the window.x property or the global variable x return the same values (and that the window.y property and the global y variable return the same values). These statements are true when called from inside or outside the generateImplicitGlobals function.

function generateImplicitGlobals(){
  x = "x";
  window.y = "y";
  console.log("inside the function, x and window.x are: " + x + " and " + window.x);
  console.log("inside the function, y and window.y are: " + y + " and " + window.y);
}

// now, call the generator, and see what happens locally and globally.
generateImplicitGlobals();
console.log("after calling the generateImplicitGlobals function, x, window.x, y, and window.y are: " + x + ", " + window.x + ", " + y + ", and " + window.y);

Solution 5

Sometimes its useful to create new globally accessible properties inside functions which can later be easily accessed by referencing the window object (all globally declared properties are attached to the window object).

However as it usually is with declaring anything to be globally accessible it can lead to problems later because those properties can be easily overwritten etc. Its far better to simply pass values to functions as arguments and retrieve their results.

View more solutions

Comments

[xralf]

That is strange that javascript allows constructs that aren't useful, but only can cause troubles when we mistype.

[QuentinUK]

"Someone else", could be you but you've forgotten that you've already used that name somewhere else.

[T.J. Crowder]

@xralf: All languages allow constructs that can be misused. while (true); comes to mind.

[T.J. Crowder]

Or even that you have an element on your page using that id, since all of those get chucked on the window object by nearly all browsers. (I think Firefox is the only holdout.)

[Anurag_BEHS]

slight modification needed in //type of variable result When i tried to run above variable declaration in w3school compiler i got alert(typeof global_var); //number alert(typeof global_novar); //number alert(typeof global_fromfunc);//undefined

[Roland]

Although I agree that I don't LIKE globals, there is no bug. Your code just returns x + y as 11, as intended.

[T.J. Crowder]

@Roland: The word "bug" doesn't appear in the answer, not quite sure what you're referring to. But implicit globals are often created accidentally (misspelling), which definitely leads to bugs. That's part of why I use strict mode (and/or lint tools).

[Roland]

If there is no bug, the program runs just fine. The problem with globals is a mental one. I came here while debugging an actual problem, and wondering if an undeclared variable caused it, now I know that was not the problem.

[T.J. Crowder]

@Roland: Well, I'm glad your problem wasn't this. For many people, it is, because they accidentally assign to ietm instead of item or similar and there's no indication of that anywhere (except for the code not working).

[Roland]

It took me a lot of mental power to figure that the long answer and the w3schools link do NOT say that the undeclared var is a bug in itself. Your observation of the misspelling and the likelyhood of mistakes (bugs) should be the sufficient answer.

[T.J. Crowder]

@Roland: I decided to revise the answer in light of comments over the last several years, including yours.

[Roland]

You underlined the "Horror of Typos". BTW, I once had to maintain code where someone combined both horrors by deliberately introducing a typo to disable a line of code, instead of commenting-out.

[ToolmakerSteve]

@Anurag_BEHS - not sure exactly what code you entered into w3schools tryit, to get "number" for global_novar, but I just tested there, and got same result as shown in answer. I recommend alert(delete global_novar); - does that return true or false? If it returns false, then you've done something different than is shown in this answer.

[ToolmakerSteve]

Re "implied globals are technically not real variables, but they are properties of the global object". I would describe it differently. Both "var used at global scope" and "implied globals" attach properties to the window object. The only difference (if the var declaration is in global scope, not inside a function), is that, using var, the property has configurable: false. MDN delete Operator.

[Ben Aston]

That is not the only difference though. Variables declared using var in the global context behave as variables (eg hoisting), whereas properties on the global object behave... well, like properties. They are two different things.