B. Why? It is perfectly valid to refer to the variable x before you assign it a value provided that you have declared it somewhere in the function. The Javascript interpreter actually rewrites the above as:

function foo() { var x; alert(x); x = 10; } foo(); Try it

D. Why? x was created as an implicit global, meaning that it springs into existence when first encountered and continues to exist in the global space, even outside of the foo function.

Try it

A. Without the var keyword, what you are attempting to define is an "implicit global" (yes, a real thing in Javascript). But the implicit global only springs into existence when that line is encountered. Since you attempted to reference the variable, y, before it was declared, it will result in a runtime error.

Try it (Hint: use Firebug to see the error)

A. Javascript rewrites the above as:

function bar() { var foo; foo(); foo = function() { alert(99); } } bar();

Javascript recognizes the varible foo as having been declared staright away, but it doesn't get assigned a value until that line of code is encountered. Thus, foo is undefined when the call, foo() attempts to execute.

Try it (Hint: use Firebug to see the error)

B. This time, foo was declared using a subtly different syntax. The Javascript interpreter sees it as:

function bar() { function foo() { alert(99); } foo(); } Try it

D. Loops and if-statements do not have scope in Javascript. The variable, i, is scoped to the function foo, but not to the for loop. It continues to exist even after the for loop is finished. Therefore, the recommended syntax is:

var i; for (i = 0; i < 5; i++) { ... }

This makes more explicit, what the Javascript interpreter is already doing for you anyway.

Try it

B. False Each instance of a Foo has its own .tellMe function.

Try it

A. True Using prototype means that the every instance of a Foo shares the same .tellMe function

Try it

A. X is not fully initialized until the final curly brace, } is reached. But the proeprty foo attempts to access a property of X, before X is fully initialized.

Try it (Hint: Use Firebug to see the error)

D. "this" does not refer to X, and this.x is therefore undefined. The undefined type multiplied by 9 returns in NaN (which is toxic by the way). In this case, "this" would refer to the Window, so something like this would be acceptable:

var X = { x: 10, y: 20, foo: this.location.href }; Try it

D. The while loop will executes 5 times (until i is 0). The variable, i, will then be decremented one additional time. Each iteration in the loop queues up a setTimeout call, but those calls are non-blocking, so the while loop essentially finishes "immediately" and when it does, the value of i is -1.

Try it

var i = 5; while (i--) { setTimeout(function(x) { return function() { alert(x); } }(i+1), 100); }

Why it works: The while loop will execute 5 times. Each iteration makes a call to setTimeout, passing in a function that is executed immediately and which returns a new function reference. The outer function takes an argument, x, which is given the value of i+1 as the loop iterates. The inner function now has access to x, even after it has seemingly gone out of scope. It's like creating a "snapshot" of i as we loop and storing it away for later use.

Try it

var i = 5; while (i--) { setTimeout(function(x) { return function() { alert(x); } }(5-i), i*2000); }

Why it works: Because it is essentially the equivalent of:

function fn(x) { return function() { alert(x); } } setTimeout(fn(5-4), 8000); setTimeout(fn(5-3), 6000); setTimeout(fn(5-2), 4000); setTimeout(fn(5-1), 2000); setTimeout(fn(5-0), 0); Try it

C. Parenthesis are evaluated first and the result of (10 == 10) is true. Next, 'steve_' will be concatenated with the bool, true, which will be coerced into a string 'true', yielding 'steve_true' Finally, 'steve_true' will be evaluated for "truthfulness" (that is, is it considered truth-like, or false-like?) and the result is truth-like (as it is not: null, undefined, "", 0, NaN, or false). Since the left side of the ? evaluates to true, the 'C' will be used as the return value.

Try it

var x = 10; var y = 'steve_' + (x == 10 ? 'C' : 'D'); alert(y); // For demonstration purposes, not part of the question

Why it works: Proper use of parenthesis ensures that the ternary operator is evaluated first and the result is then concatenated with 'steve_'

Try it

function setTimeoutX(fnRef, ms, a) { setTimeout(function() { fnRef(a); }, ms); } // test it out function foo(x) { alert(x); } setTimeoutX(foo, 1500, 'steve');

Why it works: setTimeoutX creates a closure around the variable, a, which can then be referenced passed into the fnRef function when it is called.

Try it

function setTimeoutX(fnRef, ms) { var args = arguments; setTimeout(function() { fnRef.apply(window, Array.prototype.slice.call(args, 2)); }, ms); } // test it out function add(a, b, c, d) { alert(a + b + c + d); } setTimeoutX(add, 1500, 5, 10, 15, 20);

Why it works: A closure is created in the same manner as the answers to Question 16, but this time, we capture the arguments variable (a "special" variable available in every javascript function which is an array-like object containing all passed in arguments).

We then leverage the .apply method (all javascript functions can be invoked with .apply) which allows you to specify the "this" object (1st arg) and the arguments to pass into said function, given as an array.

The args variable however, contains ALL arguments (even fnRef and ms, which we don't want to pass to fnRef). So we use the native Array's slice method to pull out all but the first two arguments.

Try it