function(){
    if(condition){
      // Block A: Do something here
    }else{
      // Block B: A lot of things to do here
    }
  }

  function(){
    if(condition){
      // Block A: Do something here
      return false;
    }
    // Block B: A lot of things to do here
  }

    // if/else/for/while/try 通常都有小括号、花括号和多行
    // 这有助于可读, 以下是很糟糕的写法

    if(condition) doSomething();

    while(condition) iterating++;

    for(var i=0;i<100;i++) someIterativeFn();

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() {
};

/**
 * @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());
};

/** @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" <[email protected]>',
  '"Zaphod Beeblebrox" <[email protected]>',
  '"Ford Prefect" <[email protected]>',
  '"Arthur Dent" <[email protected]>',
  '"Marvin the Paranoid Android" <[email protected]>',
  '[email protected]'
];

// Used in a method call.
goog.dom.createDom(goog.dom.TagName.DIV, {
  id: 'foo',
  className: 'some-css-class',
  style: 'display:none'
}, 'Hello, world!');

// 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';

// Copyright 2009 Google Inc. All Rights Reserved.

/**
 * @fileoverview Description of file, its uses and information
 * about its dependencies.
 * @author [email protected] (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;

/**
 * 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) {
  // ...
};

  // 变量
  var foo = "bar",
    num = 1,
    undef;

  // 字面量标识:
  var array = [],
    object = {};

  // 在一个作用域（函数）内只使用一个 `var` 有助于提升可读性
  // 并且让你的声明列表变得有条不紊 (还帮你省了几次键盘敲击)

  // 不好
  var foo = "";
  var bar = "";
  var qux;

  // 好的做法
  var foo = "",
    bar = "",
    quux;

  // 或者..
  var // 对这些变量的注释
  foo = "",
  bar = "",
  quux;

  // `var` 语句必须总是在各自作用域（函数）顶部
  // 同样适应于来自 ECMAScript 6 的常量

  // 不好
  function foo() {

    // 在变量前有语句

    var bar = "",
      qux;
  }

  // 好
  function foo() {
    var bar = "",
      qux;

    // 所有语句都在变量之后
  }

  /**
   * 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 THINGS_TO_EAT = [apples, oysters, sprayOnCheese]  // No semicolon here.

  // 2. 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 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: '[email protected]'
    },
    {
      name: 'xtof',
      id: 31337,
      email: '[email protected]'
    },
    ...
  ];

  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.

  // 而遍历数组通常用最普通的 for 循环.
  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
  };

null
undefined
''          // 空字符串
0           //数字0

'0'   // 字符串0
[]    // 空数组
{}    // 空对象

while (x != null) {

while (x) {

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

if (y) {

    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

    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 number1 = "45";
    // ParseInt() Test on chrome for mac:31% slower
    var i = parseInt(number1);
    // Using unary Test on chrome for mac:67% slower
    var j = +number1;
    // Number constructor Test on chrome for mac:59% slower
    var k = Number(number1);
    // By multplication Test on chrome for mac:69% slower
    var l = number1 * 1;
    // parseInt with Test on chrome for mac:radix ±3.85% fastest
    var m = parseInt(number1, 10);

    // 当只是判断一个 array 是否有长度，相对于使用这个:
    if (array.length > 0) ...

    // ...判断真伪, 请使用这种:
    if (array.length) ...

    // 当只是判断一个 array 是否为空，相对于使用这个:
    if (array.length === 0) ...

    // ...判断真伪, 请使用这种:
    if (!array.length) ...

    // 当只是判断一个 string 是否为空，相对于使用这个:
    if (string !== "") ...

    // ...判断真伪, 请使用这种:
    if (string) ...

    // 当只是判断一个 string 是为空，相对于使用这个:
    if (string === "") ...

    // ...判断真伪, 请使用这种:
    if (!string) ...

    // 当只是判断一个引用是为真，相对于使用这个:
    if (foo === true) ...

    // ...判断只需像你所想，享受内置功能的好处:
    if (foo) ...

    // 当只是判断一个引用是为假，相对于使用这个:
    if (foo === false) ...

    // ...使用叹号将其转换为真
    if (!foo) ...

    // ...需要注意的是：这个将会匹配 0, "", null, undefined, NaN
    // 如果你 _必须_ 是布尔类型的 false，请这样用：
    if (foo === false) ...

    // 如果想计算一个引用可能是 null 或者 undefined，但并不是 false, "" 或者 0,
    // 相对于使用这个：
    if (foo === null || foo === undefined) ...

    // ...享受 == 类型强制转换的好处，像这样:
    if (foo == null) ...

    // 谨记，使用 == 将会令 `null` 匹配 `null` 和 `undefined`
    // 但不是 `false`，"" 或者 0
    null == undefined

    // 类型转换和对比运算说明
    // 首次 `===`，`==` 次之 (除非需要松散类型的对比)
    // `===` 总不做类型转换，这意味着:
    "1" === 1;
    // false

    // `==` 会转换类型，这意味着:
    "1" == 1;
    // true

    // 布尔, 真 & 伪
    // 布尔:
    true, false

    // 真:
    "foo", 1

    // 伪:
    "", 0, null, undefined, NaN, void 0