The legacy system had script blocks that did an object check before creating the object:

if(typeof objectName != undefined){
objectName = {};
}

Throw in a Dojo provide before that and suddenly you’ve got vanishing objects all through your system.

I’m still confused why doing:

var test = {};

instead of

this['test'] = {};

Solves the problem. That seems to fly in the face of the ascertain that what it’s doing is correct. That said the quoted stuff above is very interesting, and opens a whole new light on it.

Maybe next time I’ll spend my time with the Big Bang instead :) or even better… coding!

From EcmaScript specs 10.1.3 – Variable Instantiation:

For each VariableDeclaration or VariableDeclarationNoIn in the code, create a property of the variable object whose name is the Identifier in the VariableDeclaration or VariableDeclarationNoIn, whose value is undefined and whose attributes are determined by the type of code. If there is already a property of the variable object with the name of a declared variable, the value of the property and its attributes are not changed. Semantically, this step must follow the creation of the FormalParameterList and FunctionDeclaration properties. In particular, if a declared variable has the same name as a declared function or formal parameter, the variable declaration does not disturb the existing property.

Yes, you caught it!

@Trevis: I suppose you are running the code in a page in the browser. So yes, “this == window == global scope”, and this global scope is certainly shared by all scripts running in that window.

If that’s true, wouldn’t that be a bug? As you said, “this” is “window”, the global scope. Is there a global scope for each script?

Now, the code in both script blocks has the global object as its execution context, right? The first block is parsed and executed, then the second block is parsed and executed, right?

In the first block, “test” is created. Now the second block executes. The “var” declaration should not have any effect (that is: not create and declare test as undefined), as “test” is already created.

From 12.2 – Variable statement:

If the variable statement occurs inside a FunctionDeclaration, the variables are defined with function-local scope in that function, as described in s10.1.3. Otherwise, they are defined with global scope (that is, they are created as members of the global object, as described in 10.1.3) using property attributes.

In your case, “this” is “window”, the global scope. So, “var test” is the same as window['test'], or even this['test'].

Then, from the specs again:

Variables are created when the execution scope is entered.

Opps… it’s saying that all variables defined in the scope are created at the start of the code execution, not at the declaration point.

Now, right after it:

Variables are initialised to undefined when created. A variable with an Initialiser is assigned the value of its AssignmentExpression when the VariableStatement is executed, not when the variable is created.

Well… it sounds like IE’s behavior reflects the specs perfectly.

At first look, it stills sounds bizarre, but well… probably the bug is the script code instead.

One exception are variables, which are declared in the global scope (outside of any function). They are always global even if they are declared using “var”.

The strange thing about the example above, as happygiraffe pointed out, is just that IE seems to treat each script tag as it’s own function.

What? You mean the JS engine evaluates code within an if statement that evaluates false? And that’s “correct” behavior? Scope doesn’t enter into it, code that is in an if statement that evaluates false should never run.

It’s also worth pointing out that jslint would have warned you about this behaviour.