In JavaScript 1.2 and later, however, functions can be defined anywhere, and tricky issues of scope arise. For example, consider a function g defined within a function f. g is always executed in the scope of f. Its scope chain includes three objects: its own call object, the call object of f( ), and the global object. Nested functions are perfectly understandable when they are invoked in the same lexical scope in which they are defined. For example, the following code does not do anything particularly surprising:

var x = "global";
function f( ) {
    var x = "local";
    function g( ) { alert(x); }
    g( );
}
f( );  // Calling this function displays "local"

// This function returns a function each time it is called
// The scope in which the function is defined differs for each call
function makefunc(x) {
    return function( ) { return x; }
}

// Call makefunc( ) several times, and save the results in an array:
var a = [makefunc(0), makefunc(1), makefunc(2)];

// Now call these functions and display their values.
// Although the body of each function is the same, the scope is
// different, and each call returns a different value:
alert(a[0]( ));  // Displays 0
alert(a[1]( ));  // Displays 1
alert(a[2]( ));  // Displays 2