/**  * The number of seconds in a minute.  * @type {number}  */ goog.example.SECONDS_IN_A_MINUTE = 60;

/**  * The number of seconds in each of the given units.  * @type {Object.<number>}  * @const  */ goog.example.SECONDS_TABLE = {   minute: 60,   hour: 60 * 60,   day: 60 * 60 * 24 }

// 1. MyClass.prototype.myMethod = function() {   return 42; }  // No semicolon here.  (function() {   // Some initialization code wrapped in a function to create a scope for locals. })();   var x = {   'i': 1,   'j': 2 }  // No semicolon here.  // 2.  Trying to do one thing on Internet Explorer and another on Firefox. // I know you'd never write code like this, but throw me a bone. [normalVersion, ffVersion][isIE]();   var THINGS_TO_EAT = [apples, oysters, sprayOnCheese]  // No semicolon here.  // 3. conditional execution a la bash -1 == resultOfOperation() || die();

if (x) {   function foo() {} }

if (x) {   var foo = function() {} }

var x = new Boolean(false); if (x) {   alert('hi');  // Shows 'hi'. }

var x = Boolean(0); if (x) {   alert('hi');  // This will never be alerted. } typeof Boolean(0) == 'boolean'; typeof new Boolean(0) == 'object';

function D() {   goog.base(this) } goog.inherits(D, B);  D.prototype.method = function() {   ... };

Foo.prototype.bar = function() {   /* ... */ };

function foo(element, a, b) {   element.onclick = function() { /* uses a and b */ }; }

function foo(element, a, b) {   element.onclick = bar(a, b); }  function bar(a, b) {   return function() { /* uses a and b */ } }

users = [   {     name: 'Eric',     id: 37824,     email: 'jellyvore@myway.com'   },   {     name: 'xtof',     id: 31337,     email: 'b4d455h4x0r@google.com'   },   ... ];

var userOnline = false; var user = 'nusrat'; var xmlhttp = new XMLHttpRequest(); xmlhttp.open('GET', 'http://chat.google.com/isUserOnline?user=' + user, false); xmlhttp.send(''); // Server returns: // userOnline = true; if (xmlhttp.status == 200) {   eval(xmlhttp.responseText); } // userOnline is now true.

with (foo) {   var x = 3;   return x; }

function printArray(arr) {   for (var key in arr) {     print(arr[key]);   } }  printArray([0,1,2,3]);  // This works.  var a = new Array(10); printArray(a);  // This is wrong.  a = document.getElementsByTagName('*'); printArray(a);  // This is wrong.  a = [0,1,2,3]; a.buhu = 'wine'; printArray(a);  // This is wrong again.  a = new Array; a[3] = 3; printArray(a);  // This is wrong again.

function printArray(arr) {   var l = arr.length;   for (var i = 0; i < l; i++) {     print(arr[i]);   } }

var myString = 'A rather long string of English text, an error message \                 actually that just keeps going and going -- an error \                 message to make the Energizer bunny blush (right through \                 those Schwarzenegger shades)! Where was I? Oh yes, \                 you\'ve got an error and all the extraneous whitespace is \                 just gravy.  Have a nice day.';

// Length is 3. var a1 = new Array(x1, x2, x3);  // Length is 2. var a2 = new Array(x1, x2);  // If x1 is a number and it is a natural number the length will be x1. // If x1 is a number but not a natural number this will throw an exception. // Otherwise the array will have one element with x1 as its value. var a3 = new Array(x1);  // Length is 0. var a4 = new Array();

var a = [x1, x2, x3]; var a2 = [x1, x2]; var a3 = [x1]; var a4 = [];

var o = new Object();  var o2 = new Object(); o2.a = 0; o2.b = 1; o2.c = 2; o2['strange key'] = 3;

var o = {};  var o2 = {   a: 0,   b: 1,   c: 2,   'strange key': 3 };

var f = function () {     /*@cc_on if (@_jscript) { return 2* @*/  3; /*@ } @*/ };

var sloth = {};  sloth.sleep = function() {   ... };

goog.provide('sloth');  sloth.sleep = function() {   ... };

foo.require('foo.hats');  /**  * WRONG -- Do NOT do this.  * @constructor  * @extend {foo.hats.RoundHat}  */ foo.hats.BowlerHat = function() { };

foo.provide('googleyhats.BowlerHat');  foo.require('foo.hats');  /**  * @constructor  * @extend {foo.hats.RoundHat}  */ googleyhats.BowlerHat = function() {   ... };  goog.exportSymbol('foo.hats.BowlerHat', googleyhats.BowlerHat);

/**  * @constructor  */ some.long.namespace.MyClass = function() { };  /**  * @param {some.long.namespace.MyClass} a  */ some.long.namespace.MyClass.staticHelper = function(a) {   ... };  myapp.main = function() {   var MyClass = some.long.namespace.MyClass;   var staticHelper = some.long.namespace.MyClass.staticHelper;   staticHelper(new MyClass()); };

myapp.main = function() {   var namespace = some.long.namespace;   namespace.MyClass.staticHelper(new namespace.MyClass()); };

/** @enum {string} */ some.long.namespace.Fruit = {   APPLE: 'a',   BANANA: 'b' };  myapp.main = function() {   var Fruit = some.long.namespace.Fruit;   switch (fruit) {     case Fruit.APPLE:       ...     case Fruit.BANANA:       ...   } };

myapp.main = function() {   var MyClass = some.long.namespace.MyClass;   MyClass.staticHelper(null); };

if (something) {   // ... } else {   // ... }

var arr = [1, 2, 3];  // No space after [ or before ]. var obj = {a: 1, b: 2, c: 3};  // No space after { or before }.

// Object initializer. var inset = {   top: 10,   right: 20,   bottom: 15,   left: 12 };  // Array initializer. this.rows_ = [   '"Slartibartfast" <fjordmaster@magrathea.com>',   '"Zaphod Beeblebrox" <theprez@universe.gov>',   '"Ford Prefect" <ford@theguide.com>',   '"Arthur Dent" <has.no.tea@gmail.com>',   '"Marvin the Paranoid Android" <marv@googlemail.com>',   'the.mice@magrathea.com' ];  // Used in a method call. goog.dom.createDom(goog.dom.TagName.DIV, {   id: 'foo',   className: 'some-css-class',   style: 'display:none' }, 'Hello, world!');

CORRECT_Object.prototype = {   a: 0,   b: 1,   lengthyName: 2 };

WRONG_Object.prototype = {   a          : 0,   b          : 1,   lengthyName: 2 };

// Four-space, wrap at 80.  Works with very long function names, survives // renaming without reindenting, low on space. goog.foo.bar.doThingThatIsVeryDifficultToExplain = function(     veryDescriptiveArgumentNumberOne, veryDescriptiveArgumentTwo,     tableModelEventHandlerProxy, artichokeDescriptorAdapterIterator) {   // ... };  // Four-space, one argument per line.  Works with long function names, // survives renaming, and emphasizes each argument. goog.foo.bar.doThingThatIsVeryDifficultToExplain = function(     veryDescriptiveArgumentNumberOne,     veryDescriptiveArgumentTwo,     tableModelEventHandlerProxy,     artichokeDescriptorAdapterIterator) {   // ... };  // Parenthesis-aligned indentation, wrap at 80.  Visually groups arguments, // low on space. function foo(veryDescriptiveArgumentNumberOne, veryDescriptiveArgumentTwo,              tableModelEventHandlerProxy, artichokeDescriptorAdapterIterator) {   // ... }  // Parenthesis-aligned, one argument per line.  Visually groups and // emphasizes each individual argument. function bar(veryDescriptiveArgumentNumberOne,              veryDescriptiveArgumentTwo,              tableModelEventHandlerProxy,              artichokeDescriptorAdapterIterator) {   // ... }

var names = items.map(function(item) {                         return item.name;                       });  prefix.something.reallyLongFunctionName('whatever', function(a1, a2) {   if (a1.equals(a2)) {     someOtherLongFunctionName(a1);   } else {     andNowForSomethingCompletelyDifferent(a2.parrot);   } });

someWonderfulHtml = '' +                     getEvenMoreHtml(someReallyInterestingValues, moreValues,                                     evenMoreParams, 'a duck', true, 72,                                     slightlyMoreMonkeys(0xfff)) +                     '';  thisIsAVeryLongVariableName =     hereIsAnEvenLongerOtherFunctionNameThatWillNotFitOnPrevLine();  thisIsAVeryLongVariableName = 'expressionPartOne' + someMethodThatIsLong() +     thisIsAnEvenLongerOtherFunctionNameThatCannotBeIndentedMore();  someValue = this.foo(     shortArg,     'Some really long string arg - this is a pretty common case, actually.',     shorty2,     this.bar());  if (searchableCollection(allYourStuff).contains(theStuffYouWant) &&     !ambientNotification.isActive() && (client.isAmbientSupported() ||                                         client.alwaysTryAmbientAnyways()) {   ambientNotification.activate(); }

doSomethingTo(x); doSomethingElseTo(x); andThen(x);  nowDoSomethingWith(y);  andNowWith(z);

var x = a ? b : c;  // All on one line if it will fit.  // Indentation +4 is OK. var y = a ?     longButSimpleOperandB : longButSimpleOperandC;  // Indenting to the line position of the first operand is also OK. var z = a ?         moreComplicatedB :         moreComplicatedC;

var msg = 'This is some HTML';

// File 1. // AA_PrivateClass_ and AA_init_ are accessible because they are global // and in the same file.  /**  * @private  * @constructor  */ AA_PrivateClass_ = function() { };  /** @private */ function AA_init_() {   return new AA_PrivateClass_(); }  AA_init_();

// File 1.  /** @constructor */   AA_PublicClass = function() { };  /** @private */ AA_PublicClass.staticPrivateProp_ = 1;  /** @private */ AA_PublicClass.prototype.privateProp_ = 2;  /** @protected */ AA_PublicClass.staticProtectedProp = 31;  /** @protected */ AA_PublicClass.prototype.protectedProp = 4;  // File 2.  /**  * @return {number} The number of ducks we've arranged in a row.  */ AA_PublicClass.prototype.method = function() {   // Legal accesses of these two properties.   return this.privateProp_ + AA_PublicClass.staticPrivateProp_; };  // File 3.  /**  * @constructor  * @extends {AA_PublicClass}  */ AA_SubClass = function() {   // Legal access of a protected static property.   AA_PublicClass.staticProtectedProp = this.method(); }; goog.inherits(AA_SubClass, AA_PublicClass);  /**  * @return {number} The number of ducks we've arranged in a row.  */ AA_SubClass.prototype.method = function() {   // Legal access of a protected instance property.   return this.protectedProp; };

/**  * Some class, initialized with a value.  * @param {Object} value Some value.  * @constructor  */ function MyClass(value) {   /**    * Some value.    * @type {Object}    * @private    */   this.myValue_ = value; }

/**  * Some class, initialized with a non-null value.  * @param {!Object} value Some value.  * @constructor  */ function MyClass(value) {   /**    * Some value.    * @type {!Object}    * @private    */   this.myValue_ = value; }

/**  * Some class, initialized with an optional value.  * @param {Object=} opt_value Some value (optional).  * @constructor  */ function MyClass(opt_value) {   /**    * Some value.    * @type {Object|undefined}    * @private    */   this.myValue_ = opt_value; }

/**  * Takes four arguments, two of which are nullable, and two of which are  * optional.  * @param {!Object} nonNull Mandatory (must not be undefined), must not be null.  * @param {Object} mayBeNull Mandatory (must not be undefined), may be null.  * @param {!Object=} opt_nonNull Optional (may be undefined), but if present,  *     must not be null!  * @param {Object=} opt_mayBeNull Optional (may be undefined), may be null.  */ function strangeButTrue(nonNull, mayBeNull, opt_nonNull, opt_mayBeNull) {   // ... };

// Copyright 2009 Google Inc. All Rights Reserved.  /**  * @fileoverview Description of file, its uses and information  * about its dependencies.  * @author user@google.com (Firstname Lastname)  */

/**  * Class making something fun and easy.  * @param {string} arg1 An argument that makes this more interesting.  * @param {Array.<number>} arg2 List of numbers to be processed.  * @constructor  * @extends {goog.Disposable}  */ project.MyClass = function(arg1, arg2) {   // ... }; goog.inherits(project.MyClass, goog.Disposable);

/**  * Converts text to some completely different text.  * @param {string} arg1 An argument that makes this more interesting.  * @return {string} Some return value.  */ project.MyClass.prototype.someMethod = function(arg1) {   // ... };  /**  * Operates on an instance of MyClass and returns something.  * @param {project.MyClass} obj Instance of MyClass which leads to a long  *     comment that needs to be wrapped to two lines.  * @return {boolean} Whether something occured.  */ function PR_someMethod(obj) {   // ... }

/**  * @return {Element} The element for the component.  */ goog.ui.Component.prototype.getElement = function() {   return this.element_; };

/**  * Maximum number of things per pane.  * @type {number}  */ project.MyClass.prototype.someProperty = 4;

/** @type {number} */ (x) (/** @type {number} */ x)

/**  * Illustrates line wrapping for long param/return descriptions.  * @param {string} foo This is a param with a description too long to fit in  *     one line.  * @return {number} This returns something that has a description too long to  *     fit in one line.  */ project.MyClass.prototype.method = function(foo) {   return 5; };

/**  * This is NOT the preferred indentation method.  * @param {string} foo This is a param with a description too long to fit in  *                     one line.  * @return {number} This returns something that has a description too long to  *                  fit in one line.  */ project.MyClass.prototype.method = function(foo) {   return 5; };

/**  * Enum for tri-state values.  * @enum {number}  */ project.TriState = {   TRUE: 1,   FALSE: -1,   MAYBE: 0 };

/**  * Sets project state.  * @param {project.TriState} state New project state.  */ project.setState = function(state) {   // ... };

/**  * @param {string} tagName  * @param {(string|Element|Text|Array.<Element>|Array.<Text>)} contents  * @return {Element}  */ goog.createElement = function(tagName, contents) {   ... };

/** @typedef {(string|Element|Text|Array.<Element>|Array.<Text>)} */ goog.ElementContent;  /** * @param {string} tagName * @param {goog.ElementContent} contents * @return {Element} */ goog.createElement = function(tagName, contents) { ... };

/**  * Computes weight based on three factors:  *   items sent  *   items received  *   last timestamp  */

/**  * Computes weight based on three factors:  * <ul>  * <li>items sent  * <li>items received  * <li>last timestamp  * </ul>  */

/**  * Changes <b> tags to <span> tags.  */

/**  * Changes <b> tags to <span> tags.  */

/** * Changes 'b' tags to 'span' tags. */

while (x != null) {

while (x) {

if (y != null && y != '') {

if (y) {

if (val != 0) {   return foo(); } else {   return bar(); }

return val ? foo() : bar();

var html = '<input type="checkbox"' +     (isChecked ? ' checked' : '') +     (isEnabled ? '' : ' disabled') +     ' name="foo">';

/** @param {*=} opt_win */ function foo(opt_win) {   var win;   if (opt_win) {     win = opt_win;   } else {     win = window;   }   // ... }

/** @param {*=} opt_win */ function foo(opt_win) {   var win = opt_win || window;   // ... }

if (node) {   if (node.kids) {     if (node.kids[index]) {       foo(node.kids[index]);     }   } }

if (node && node.kids && node.kids[index]) {   foo(node.kids[index]); }

var kid = node && node.kids && node.kids[index]; if (kid) {   foo(kid); }

node && node.kids && node.kids[index] && foo(node.kids[index]);

function listHtml(items) {   var html = '<div class="foo">';   for (var i = 0; i < items.length; ++i) {     if (i > 0) {       html += ', ';     }     html += itemHtml(items[i]);   }   html += '</div>';   return html; }

function listHtml(items) {   var html = [];   for (var i = 0; i < items.length; ++i) {     html[i] = itemHtml(items[i]);   }   return '<div class="foo">' + html.join(', ') + '</div>'; }

var paragraphs = document.getElementsByTagName('p'); for (var i = 0; i < paragraphs.length; i++) {   doSomething(paragraphs[i]); }

var paragraphs = document.getElementsByTagName('p'); for (var i = 0, paragraph; paragraph = paragraphs[i]; i++) {   doSomething(paragraph); }

var parentNode = document.getElementById('foo'); for (var child = parentNode.firstChild; child; child = child.nextSibling) {   doSomething(child); }