1. JavaScript error - first the function returning 42 is called with the second function as a parameter, then the number 42 is "called" resulting in an error.
2. You will most likely get a 'no such property in undefined' error at runtime as it tries to call x[ffVersion][isIE]().
3. die is called unless resultOfOperation() is NaN and THINGS_TO_EAT gets assigned the result of die().

JavaScript requires statements to end with a semicolon, except when it thinks it can safely infer their existence. In each of these examples, a function declaration or object or array literal is used inside a statement. The closing brackets are not enough to signal the end of the statement. Javascript never ends a statement if the next token is an infix or bracket operator.

This has really surprised people, so make sure your assignments end with semicolons.

• Private properties, variables, and methods (in files or classes) should be named with a trailing underscore.
• Protected properties, variables, and methods should be named without a trailing underscore (like public ones).

For more information on private and protected, read the section on visibility .

Optional function arguments start with opt_.

Functions that take a variable number of arguments should have the last argument named var_args. You may not refer to var_args in the code; use the arguments array.

Optional and variable arguments can also be specified in @param annotations. Although either convention is acceptable to the compiler, using both together is preferred.

Getters and setters for properties are not required. However, if they are used, then getters must be named getFoo() and setters must be named setFoo(value). (For boolean getters, isFoo() is also acceptable, and often sounds more natural.)

JavaScript has no inherent packaging or namespacing support.

Global name conflicts are difficult to debug, and can cause intractable problems when two projects try to integrate. In order to make it possible to share common JavaScript code, we've adopted conventions to prevent collisions.

Filenames should be all lowercase in order to avoid confusion on case-sensitive platforms. Filenames should end in .js, and should contain no punctuation except for - or _ (prefer - to _).

Because of implicit semicolon insertion, always start your curly braces on the same line as whatever they're opening. For example:

Single-line array and object initializers are allowed when they fit on a line:

Multiline array initializers and object initializers are indented 2 spaces, just like blocks.

Long identifiers or values present problems for aligned initialization lists, so always prefer non-aligned initialization. For example:

Not like this:

When possible, all function arguments should be listed on the same line. If doing so would exceed the 80-column limit, the arguments must be line-wrapped in a readable way. To save space, you may wrap as close to 80 as possible, or put each argument on its own line to enhance readability. The indentation may be either four spaces, or aligned to the parenthesis. Below are the most common patterns for argument wrapping:

When declaring an anonymous function in the list of arguments for a function call, the body of the function is indented two spaces from the left edge of the function call or the statement, not two spaces from the left edge of the function keyword. This is to make the body of the anonymous function easier to read (i.e. not be all squished up into the right half of the screen).

In fact, except for array and object initializers , and passing anonymous functions, all wrapped lines should be indented either left-aligned to the expression above, or indented four spaces, not indented two spaces.

Use newlines to group logically related pieces of code. For example:

Always put the operator on the preceding line, so that you don't have to think about implicit semi-colon insertion issues. Otherwise, line breaks and indentation follow the same rules as in other Google style guides.

The JS2 proposal contained a language for specifying JavaScript types. We use this language in JsDoc to express the types of function parameters and return values.

As the JS2 proposal has evolved, this language has changed. The compiler still supports old syntaxes for types, but those syntaxes are deprecated.

Type Example	Value Examples	Description
number	1 1.0 -5 1e5 Math.PI
Number	new Number(true)	Number object
string	'Hello' "World" String(42)	String value
String	new String('Hello') new String(42)	String object
boolean	true false Boolean(0)	Boolean value
Boolean	new Boolean(true)	Boolean object
RegExp	new RegExp('hello') /world/g
Date	new Date new Date()
null	null
undefined	undefined
void	function f() { return; }	No return value
Array	['foo', 0.3, null] []	Untyped Array
Array.<number>	[11, 22, 33]	An Array of numbers
Array.<Array.<string>>	[['one', 'two', 'three'], ['foo', 'bar']]	Array of Arrays of strings
Object	{} {foo: 'abc', bar: 123, baz: null}
Object.<string>	{'foo': 'bar'}	An Object in which the values are strings.
Object.<number, string>	var obj = {}; obj[1] = 'bar';	An Object in which the keys are numbers and the values are strings. Note that in JavaScript, the keys are always implicitly coverted to strings, so obj['1'] == obj[1]. So the key wil always be a string in for...in loops. But the compiler will verify the type if the key when indexing into the object.
Function	function(x, y) { return x * y; }	Function object
function(number, number): number	function(x, y) { return x * y; }	function value
SomeClass	/** @constructor */ function SomeClass() {} new SomeClass();
SomeInterface	/** @interface */ function SomeInterface() {} SomeInterface.prototype.draw = function() {};
project.MyClass	/** @constructor */ project.MyClass = function () {} new project.MyClass()
project.MyEnum	/** @enum {string} */ project.MyEnum = { BLUE: '#0000dd', RED: '#dd0000' };	Enumeration
Element	document.createElement('div')	Elements in the DOM.
Node	document.body.firstChild	Nodes in the DOM.
HTMLInputElement	htmlDocument.getElementsByTagName('input')[0]	A specific type of DOM element.

Because JavaScript is a loosely-typed language, it is very important to understand the subtle differences between optional, nullable, and undefined function parameters and class properties.

The following are all false in boolean expressions:

• null
• undefined
• '' the empty string
• 0 the number

But be careful, because these are all true:

• '0' the string
• [] the empty array
• {} the empty object

This means that instead of this:

you can write this shorter code (as long as you don't expect x to be 0, or the empty string, or false):

And if you want to check a string to see if it is null or empty, you could do this:

But this is shorter and nicer:

Caution: There are many unintuitive things about boolean expressions. Here are some of them:

• Boolean('0') == true
'0' != true
• 0 != null
0 == []
0 == false
• Boolean(null) == false
null != true
null != false
• Boolean(undefined) == false
undefined != true
undefined != false
• Boolean([]) == true
[] != true
[] == false
• Boolean({}) == true
{} != true
{} != false

Instead of this:

you can write this:

The ternary conditional is also useful when generating HTML:

These binary boolean operators are short-circuited, and evaluate to the last evaluated term.

"||" has been called the 'default' operator, because instead of writing this:

you can write this:

"&&" is also useful for shortening code. For instance, instead of this:

you could do this:

or this:

However, this is going a little too far:

It is common to see this:

but this is slow in Internet Explorer, so it is better to do this:

You can also use an array as a stringbuilder, and convert it into a string with myArray.join(''). Note that since assigning values to an array is faster than using push() you should use assignment where possible.

Node lists are often implemented as node iterators with a filter. This means that getting a property like length is O(n), and iterating over the list by re-checking the length will be O(n^2).

It is better to do this instead:

This works well for all collections and arrays as long as the array does not contain things that are treated as boolean false.

In cases where you are iterating over the childNodes you can also use the firstChild and nextSibling properties.