if(example && example && example && example && ... &&
        example){
    doSth();
}

var a = example + example + ... + example + example + example + example +
        example;

function Person(name){
    this.name = name;
}

Person.prototype.sayName = function(){
    alert(this.name);
}

var me = new Person("Jack"); //一看大驼峰就知道前面要有 new

var res = 'This is a \
example.'; //不好

var res = 'This is a ' +
          'example'; //好

var example = null; //example 以后要赋值为对象

var example = obj;
if(example !== null){
}

if(...){
    return obj;
}else{
    return null;
}

var example;
if(example!=null){ //用 null 检测未初始化的变量，不好
    doSth();
}

var book = {
    title: 'red and black'
};
var colors = ['red','blue'];

/**
@method merge
@param {Object} xxx
@return {Object} xxx
**/

for（var prop in obj）{
    if(obj.hasOwnProperty(prop)){
        ...
    }
}

// 不好，容易误以为是把函数赋值给变量
var value = function(){
    ...
}();

// 好，用圆括号把函数包起来
var value = (function(){
    ...
}());

function do(){
    "use strict";
    ...
}

(function(){
    "use strict";
    function doSth(){
        ...
    }
    function doSthElse(){
        ...
    }
})();

/* 
* 虽然 name 是字符串，是原始类型，不是对象，但仍然可以使用 toUpperCase() 之类的方法。
* 因为在该条语句时，创建了 String 类型的新实例，执行完就销毁了。
*/
var name = "Jack";
name.age = 20; // 创建新实例，执行后就销毁
console.log(name.age); //undefined，创建新实例所以是 undefined

var MaintainableJS = {};

// 其他信息都挂载到这个对象上
MaintainableJS.author = ...

var YourGlobal = {};
YourGlobal.DOM.xx = ... // 与 DOM  操作相关的方法挂载在 YourGlobal.DOM 下 // 当然，要先保证 YourGlobal.DOM 是已存在的

var YourGlobal = {
    namespace: function(ns){
        var parts = ns.split("."),
            object = this, // YourGlobal
            i, len;

        for(i=0, len=parts.length; i<len; i++){
            if(!object[parts[i]]){
                object[parts[i]] = {}; 
            }
            object = object[parts[i]];
        }

        return object;
    }
};

// 在使用命名空间前，先声明
YourGlobal.namespace("Book.RedAndBlack"); //若还没有命名空间 Book.RedAndBlack，就会创建一个，所以再不用担心该命名空间不存在了

// 创建模块
YUI.add("module-name", function(Y){
    // 模块正文
}, "version", {requires: ["dependency1", "dependency2"]});

// 使用模块
YUI.use("module-name1", "module-name2", function(Y){
    ...
});

define("module-name", ["dependency1", "dependency2"], function(dependency1, dependency2){ //可以省略 module-name
    // 模块正文
});

(function(win){
    var doc = win.document;
    ...
}(window));

function handleClick(e){
    var popup = document.getElementById("popup");
    popup.style.left = e.clientX + "px";
    popup.style.top = e.clientY + "px";
    popup.className = "reveal";
}

addListener(ele, "click", handleClick);

var App = {
    handleClick: function(e){
        this.showPopup(e);
    },

    showPopup: function(e){ // event 对象被分发了过来
        // 应用逻辑
        var popup = document.getElementById("popup");
        popup.style.left = e.clientX + "px";
        popup.style.top = e.clientY + "px";
        popup.className = "reveal"; 
    }
}

addListener(ele, "click", function(e){
    App.handleClick(e);
});

var App = {
    
    // 事件处理
    handleClick: function(e){
        e.preventDefault();
        e.stopPropagation();
        
        this.showPopup(e.clientX, e.clientY);
    },
    
    // 应用逻辑
    showPopup: function(x, y){
        var popup = document.getElementById("popup");
        popup.style.left = x + "px";
        popup.style.top = y + "px";
        popup.className = "reveal"; 
    }
}

addListener(ele, "click", function(e){
    App.handleClick(e);
});

if("querySelector" in document){ // 在 IE8 及更早的浏览器中检测 DOM 方法是否存在
    img = document.querySelector("img");
}

function isArray(value){
    return typeof value.sort === "function"; // 因为数组是唯一包含 sort() 方法的对象
}

function isArray(value){
    return Object.prototype.toString.call(value) == "[object Array]";
}

var obj = {
    count: 0
}

if(obj["count"]){
    // 0，不会执行这里的代码，是错的。属性值为假值时，就会出错。
}

if("count" in obj){
    // 会执行这里的代码
}

pagesize = 10; // 设置

function validate(ele, value){
    if(! value){
        addClass(ele, "invalid"); // 重复的值，要修改的话，要修改多处
        alert("Invalid value!"); // 需要展现给用户的字符串
        location.href = "error/invalid.html"; // URL
    }else{
        removeClass(ele, "invalid");
    }
}

var config = {
    MSG_INVALID_VALUE: "Invalid value",
    URL_INVALID: "error/invalid.html",
    CSS_INVALID: "invalid",
    PAGESIZE: 10
};

function validate(ele, value){
    if(! value){
        addClass(ele, config.CSS_INVALID); // 重复的值，要修改的话，要修改多处
        alert(config.MSG_INVALID_VALUE); // 需要展现给用户的字符串
        location.href = config.URL_INVALID; // URL
    }else{
        removeClass(ele, config.CSS_INVALID);
    }
}

# 面向用户的消息
MSG_INVALID_VALUE = Invalid value

throw new Error("error!"); // 错误信息作为参数，抛出后将显示在控制台

throw "error!";

function getDivs(ele){
    return ele.getElementsByTagName("div");
}

function getDivs(ele){
    if(ele && ele.getElementsByTagName){
        return ele.getElementsByTagName("div");
    }else{
        throw new Error("getDivs(): Argument must be a DOM element.");
    }
}

function addClass(ele, className){
    if(!ele || typeof ele.className != "string"){ // 应保留，因为 ele 很有可能不是 DOM 元素，导致出错
        throw new Error("addClass(): Fisrt argument must be a DOM element.");
    }
    if(typeof className != "string"){ // 应去掉，因为不是 string 也不至于严重错误，何况会自动转换类型
        throw new Error("addClass(): second argument must be a string.");
    }

    element.className += " " + className;
}

try{
    ...
}catch(ex){
    if(ex instanceof TypeError){
        // 处理类型错误
    }else if(ex instanceof ReferenceError){
        // 处理 对象不存在 的错误
    } else {
        // 其他处理
    }
}

function MyError(msg){
    this.msg = msg;
}
MyError.prototype = new Error();
// 抛出自己定义的错误
throw new myError("This is my error.");
// 检测自己的错误
try{
    ...
}catch(ex){
    if(ex instanceof MyError){
        // 处理自己定义的错误
    }else{
        // 其他处理
    }
}

var person = {
    name: "jack",
    sayName: function(){
        alert(this.name);
    }
};
var myPerson = Object.create(person); // myPerson 继承 person
myPerson.sayName(); // "jack", myPerson 可以访问 person 的属性、方法
myPerson.sayName = function(){
    alert("rose");
};
myPerson.sayName(); // "rose", 重新定义，自动切断对 person.sayName 的访问，person 不受影响

var myPerson = Object.create(person,{
    name: {
        value: "Amy"
    }
});
myPerson.sayName(); // "Amy", person 不受影响

function MyError(msg){
    this.msg = msg;
}
MyError.prototype = new Error(); // 每个 MyError 实例都继承 Error 的属性、方法

function Person(name){
    this.name = name;
}
function Author(name){
    // name 是继承自 Person 的
    Person.call(this, name); // 构造器继承：调用超类的构造函数时，传入新建的 Author 对象 this，作为调用 Person 构造器的那个 this 的值。所以是用 Person 构造器在这个 Author 对象上定义了一个 name 属性 
}
Author.prototype = new Person();

// 创建门面
function DOMWrapper(ele){
    this.ele = ele; // 把对象传过来保存起来
}
// 给保存起来的对象添加方法
DOMWrapper.prototype.addClass = function(className){
    this.ele.className += " " + className; 
};
// 用法
var wrapper = new DOMWrapper(document.getElementById("wrap"));
wrapper.addClass("active");

var person = {
    name: "Jack"
};
Object.preventExtension(person);
console.log(Object.isExtensible(person)); // false
person.age = 25; // 不会成功

Object.seal(person);
console.log(Object.isExtensible(person)); // false
console.log(Object.isSealed(person)); // true
delete person.name; // 不会成功

Object. freeze(person);
console.log(Object.isExtensible(person)); // false
console.log(Object.isSealed(person)); // true
console.log(Object.isFrozen(person)); // true
person.name = "rose"; // 不会成功

if(isIe8OrEarlier){ // 检测低版本的，而不是检测高版本的浏览器。因为检测高版本的浏览器，以后出了新的高版本浏览器，这段代码就需要修改了
    // 处理 IE8 及更早版本
}else{
    // 处理其他浏览器
}

function setAnimation(callback){
    if(window.requestAnimationFrame){ // 标准
        return requestAnimationFrame(callback);
    }else if(window.mozRequestAnimationFrame){ // firefox
        return requestAnimationFrame(callback);
    }else if(window.webkitRequestAnimationFrame){ // webkit
        return requestAnimationFrame(callback);
    }else if(window.oRequestAnimationFrame){ // opera
        return requestAnimationFrame(callback);
    }else if(window.msRequestAnimationFrame){ // ie
        return requestAnimationFrame(callback);
    }else{
        return setTimeout(callback,0);
    }
}

if(document.getElementsByTagName){

    document.getElementById(..) // 认为 document.getElementsByTagName 存在，那么 getElmentById 也存在，不对

}

if(document.all){
    // 认为是 IE 浏览器，就开始使用 IE 特有的一些方法
    // 但是 document.all 的存在并不能说明这是 IE 浏览器
}

- csslint
 + .git
 + .build // 不提交，因为编译就可以生成
 + demos
 + lib
 + npm
 + release // 包含最新的稳定发行版本
 + src
 + tests