The Global object is unique and is created before any code is executed. In an ECMAScript compliant implementation it is where variables, methods, functions and properties are stored if you don't explicitly attach them to another object yourself. The member properties, methods, functions, and variables are globally available because the Global object is placed into the scope chain of every execution context.

In a web browser, the Global object is also the Window object. In a server-side implementation, the Global object is probably the Response object but this is not mandatory. Other implementations will one of the host objects as the Global object but there is no defined and standard choice.

Since you don't ever use the keyword Global and can avoid using the keyword Window the properties and methods look as if they are part of the core language rather than members of an object. Web browsers are becoming more ECMAScript compliant as new versions are released.

The Global object is added to the scope chain of a program when it commences execution. Other built in objects are accessible as initial properties of the global object. Some of these are added as core functionality and are available in all implementations. Others are added as host objects defined differently for each implementation.

When the Global object is created, it always has at least the following properties:

• Object object

• Function object

• Array object

• String object

• Boolean object

• Number object

• Date object

• Math object

• Value properties

• Utility function properties

• Additional host defined properties

Most of the properties initially provided by the Global object cannot be enumerated as their DontEnum attribute is set (at least in ECMA-compliant implementations).

The initial properties soon change and are added to when the flow of control enters execution contexts and begins to process scripts.

The value properties that are initially set up in the Global object are listed in this table:

Refer to the discussion on each of value properties for more details.

Some host implementations create aliases for the Global object and store those self referring aliases in the global object when it is initialized. An example of this behavior is the Window object created in some web browser host implementations of JavaScript.

There is one Global object for each window in a web browser. There is also one for each frame in a frame-set. This means that you can have Global objects that have global variables that are not shared with one another.

However, you can access them by referring to the parent object. This goes to an object context that contains the current frame. You can also access the top or outer window of a frame-set hierarchy directly.

Whether you can truly access objects in other windows or frames comes down to some basic security issues. Generally the security policy prevents access to code that arrives from different servers. You can legally get at values in pages served from the same host as your page was served from. It is unreasonable to be able to access variables in a page served from another host. This can lead to difficulties if you serve your site from multiple hosts. It isn't as limiting as all that though and there are ways to grant permission via the security policy in the browser.

Global objects support different sub-sets of the complete range of properties according to the context in which they are used. Server-side JavaScript won't support anything to do with window display and client side (browser) JavaScript does not need to know about request-response handling.

If you want to access a Global object in another context, perhaps in a different window, you need to assign it to a variable. In the syntax listing this is illustrated by assigning references to Global objects to the myGlobal variable.

Warnings:

• You cannot use the Global object with the new operator to make a copy.

• You cannot call the Global object as a function.

• The value of the internal Prototype property of the Global object is implementation-dependent. Since it contains the Object object as one of its children, it could not inherit its Prototype from there since that could set up an endlessly recurring loop of Prototype inheritors. It is likely that the Prototype of the Global object is null. If it is important that you know the value of this, then you should test it with a debugging script first. However, you may be writing non-portable code if you depend on the value that it indicates.

• In a web browser, the Window object serves as the Global object. It owns all the properties that you would expect the global object to have in a core implementation. The hosting environment adds the other window-based properties.

Cross-references:

ECMA 262 edition 2 - section - 10.1.5

ECMA 262 edition 2 - section - 15

ECMA 262 edition 3 - section - 10.1.5

ECMA 262 edition 3 - section - 15.1