($=[$=[]][(__=!$+$)[_=-~-~-~$]+({}+$)[_/_]+($$=($_=!''+$)[_/_]+$_[+$])])()[__[_/_]+__[_+~$]+$_[_]+$$](_/_)

//获取数字
console.log(+[]); //0
console.log(-~[]); //1
console.log(-~-~[]); //2
console.log(-~-~-~[]); //3
console.log(-~-~-~-~[]); //4
console.log(-~-~-~-~-~[]); //5
console.log(-~-~-~-~-~-~[]); //6
console.log(-~-~-~-~-~-~-~[]); //7
console.log(-~-~-~-~-~-~-~-~[]); //8
console.log(-~-~-~-~-~-~-~-~-~[]); //9

//获取字母
//[{}]+[] [object Object]
console.log(([{}]+[])[-~[]]); //o
console.log(([{}]+[])[-~-~[]]); //b
console.log(([{}]+[])[-~-~-~[]]); //j
console.log(([{}]+[])[-~-~-~-~[]]); //e
console.log(([{}]+[])[-~-~-~-~-~[]]); //c
console.log(([{}]+[])[-~-~-~-~-~-~[]]); //t

//![]+[] false
console.log((![] + [])[+[]]); //f
console.log((![] + [])[-~[]]); //a
console.log((![] + [])[-~-~[]]); //l
console.log((![] + [])[-~-~-~[]]); //s
console.log((![] + [])[-~-~-~-~[]]); //e

//!![]+[] true
console.log((!![]+[])[+[]]); //t
console.log((!![]+[])[-~[]]); //r
console.log((!![]+[])[-~-~[]]); //u
console.log((!![]+[])[-~-~-~[]]); //e

//({}[(!![]+[])[+[]]])+[] undefined
console.log((({}[(!![]+[])[+[]]])+[])[-~[]]); //n
console.log((({}[(!![]+[])[+[]]])+[])[-~-~[]]); //d
console.log((({}[(!![]+[])[+[]]])+[])[-~-~-~-~-~[]]); //i

var templateManager = (function () {
    var templates = {},
        tmp,
        supplant = {
            init: function (str, params) {
                var value, prop, tmp, len;
                for (prop in params) {
                    if (params.hasOwnProperty(prop)) {
                        value = params[prop];
                        switch (Object.prototype.toString.call(value)) {
                            case '[object Number]':
                            case '[object String]':
                                tmp = {};
                                tmp[prop] = value;
                                str = supplant.replaceString(str, tmp);
                                break;
                            case '[object Function]':
                                str = supplant.replaceFunc(str, prop, value, params);
                                break;
                            case '[object Array]':
                                str = supplant.replaceArray(str, prop, value);
                                break;
                            default:
                                break;
                        }
                    }
                }
                return str;
            },
            replaceString: function (str, params) {
                var prop;
                for (prop in params) {
                    if (params.hasOwnProperty(prop)) {
                        str = str.split('{' + prop + '}').join(params[prop]);
                    }
                }
                return str;
            },
            replaceFunc: function (str, prop, func, item) {
                return str.split('{' + prop + '}').join(func(item));
            },
            replaceArray: function (str, prop, data) {
                var i = 0,
                    left,
                    middle,
                    right,
                    s = '{#' + prop + '}',
                    e = '{/' + prop + '}',
                    len = data.length,
                    start = 0,
                    end = 0;
                    
                start = str.indexOf(s);
                end = str.indexOf(e, start);
                left = str.slice(0, start);
                middle = str.slice(start + s.length, end);
                right = str.slice(end + e.length);
                if (len > 0 && start > -1) {
                    for (; i < len; ++i) {
                        data[i].tmCount = i;
                        data[i].tmNumber = i + 1;
                        if (data[i].content !== null) { //如果content属性不等于null
                            left += supplant.init(middle, data[i]);
                        } else {
                            left += data[i].replace;
                        }
                    }
                    str = left + right;
                    
                    if (str.indexOf(s) > -1) {//如果包括多个循环
                        str = supplant.replaceArray(str, prop, data);
                    }
                }
                
                if (len == 0 && start > -1) {
                    str = left + right;
                }
                
                return str;
            }
        };
    
    return {
        render: function (name, params) {
            if (typeof templates[name] !== 'string') {
                throw 'Template ' + name + ' not found!';
            }
            tmp = name;
            return supplant.init(templates[name], params);
        },
        defineTemplate: function (name, template) {
            if (typeof template == 'string') {
                templates[name] = template;
            } else { //数组
                templates[name] = template.join('');
            }
        }
    };
})();

//替换变量
templateManager.defineTemplate('profile', '姓名:{name}，blog:{blog}');
templateManager.render('profile', {name: 'vapour', blog: 'http://dovapour.info/'});
//结果 姓名:vapour，blog:http://dovapour.info/

//实现循环
templateManager.defineTemplate('website', [
    '<ul>',
        '{#webs}<li><a href="{url}">{name}<_buff_29_buff_li>{/webs}',
    '<ul>'
]);
templateManager.render('website', {
    webs: [{
        name: '百度',
        url: 'http://www.baidu.com/',
        getLen: function (item) {
            return item.url.length;
        }
    }, {
        name: '淘宝',
        url: 'http://www.taobao.com/',
        getLen: function (item) {
            return item.url.length;
        }
    }, {
        name: '腾讯',
        url: 'http://www.qq.com/',
        getLen: function (item) {
            return item.url.length;
        }
    }, {
        name: '网易',
        url: 'http://163.com/',
        getLen: function (item) {
            return item.url.length;
        }
    }, {
        name: '新浪',
        url: 'http://www.sina.com/',
        getLen: function (item) {
            return item.url.length;
        }
    }]
});
/*
<ul>
    <li><a href="http://www.baidu.com/">百度</a>，url长度21</li>
    <li><a href="http://www.taobao.com/">淘宝</a>，url长度22</li>
    <li><a href="http://www.qq.com/">腾讯</a>，url长度18</li>
    <li><a href="http://163.com/">网易</a>，url长度15</li>
    <li><a href="http://www.sina.com/">新浪</a>，url长度20</li>
<ul>
*/

isCustomDomain: function () {
   if (!this.ie) return false;
   var g = document.domain,
   h = window.location.hostname;
   return g != h && g != '[' + h + ']';
}

var oldDomain = document.domain,
    newDomain = 'xxx.com';
if (newDomain != oldDomain) {
   document.domain = newDomain;
}

var selectAll = (function () {
   if (arale.isIE()) { //IE
      return function (win) {
         win = win || window;
         win.document.body.createControlRange().execCommand('SelectAll');
      }
   } else { //标准浏览器
      return function (win) {
         var s, r;
         win = win || window;
         doc = win.document;
         s = win.getSelection();
         r = doc.createRange();

         r.selectNode(doc.body);
         s.addRange(r);
      }
   }
})();

function bad (foo) {
    if ( ! (foo instanceof Bar) ) {
        throw new TypeError("This is an annoying restriction!");
    }
    return foo.baz(foo.quux(10));
}

function good (foo) {
    if ( !foo.baz || !foo.quux ) {
        throw new TypeError("We need foo to have baz and quux methods.");
    }
    return foo.baz(foo.quux(10));
}

var quacksLike = function (obj, definition) {
    var k, ctor;
    for ( k in definition ) {
        ctor = definition[k];
        if ( ctor === Number ) {
            if ( Object.prototype.toString.call(obj[k]) !== "[object Number]" || isNaN(obj[k]) ) {
                return false;
            }
        } else if ( ctor === String ) {
            if ( Object.prototype.toString.call(obj[k]) !== "[object String]" ) {
                return false;
            }
        } else if ( ! (obj[k] instanceof ctor) ) {
            return false;
        }
    }
    return true;
};
Object.combine = function () {
    var newObj = {},
        i = 0,
        args = Array.prototype.slice.call(arguments),
        len = args.length;
    function copyProperty(k) {
        newObj[k] = args[i][k];
    }
    for ( ; i < len; i++ ) {
        Object.getOwnPropertyNames(args[i]).forEach(copyProperty);
    }
    return newObj;
};
window.$ = (function () {
    var undef, listen, customAPI;
    
    // Private function to turn 'thing' in to an array,
    // optionally slicing the first 'n' elems off.
    function toArray(thing, n) {
        return Array.prototype.slice.call(thing, n || 0);
    }

    // Private function to partially apply the first n arguments
    // to 'fn'.
    function curry (fn) {
        var args = toArray(arguments, 1);
        return function () {
            return fn.apply(this, args.concat(toArray(arguments)));
        };
    }

    // Private function to set the attribute 'attr' of a single
    // DOM node 'node' to 'val'.
    function nodeAttributeSetter (attr, val, node) {
        node.setAttribute(attr, val);
    }

    // Private function to get the value of the attribute 'attr'
    // on the DOM node 'node'.
    function nodeAttributeGetter (attr, node) {
        return node.getAttribute(attr);
    }

    // Do the work to determine the correct method for attaching
    // event listeners only once by using 'quacksLike' and an
    // immediately invoked function.
    listen = (function () {
        var w3c = {
                addEventListener: Function
            },
            ie = {
                attachEvent: Function
            };

        if ( quacksLike(document.body, w3c) ) {
            return function (event, fn, node) {
                node.addEventListener(event, fn, false);
            };
        } else if ( quacksLike(document.body, ie) ) {
            return function (event, fn, node) {
                node.attachEvent("on" + event, fn);
            };
        } else {
            throw new TypeError("Do not know how to attach event listeners.");
        }
    }());

    // This object is a mixin to be composed with the NodeList
    // results of querying the DOM by CSS selector. It provides
    // handy methods for getting and setting attributes,
    // attaching event listeners, and performing sub-queries by
    // CSS on these elements.
    customAPI = {
        attr: function (attr, val) {
            if ( val !== undef ) {
                this.forEach(curry(nodeAttributeSetter, attr, val));
                return this;
            } else {
                return this.length > 0 ? nodeAttributeGetter(attr, this[0]) : "";
            }
        },
        on: function (event, fn) {
            this.forEach(curry(listen, event, fn));
            return this;
        },

        find: function (selector) {
            var res = [];
            this.forEach(function (node) {
                res.push.apply(res, toArray(node.querySelectorAll(selector)));
            });
            return Object.combine(res, customAPI);
        }

    };

    return function (selector, context) {
        context = context || document;
        return Object.combine(Array.prototype, context.querySelectorAll(selector), customAPI);
    };

}());

//The mini DOM library might be used like this:

// The following two forms are equivalent.
// They select the same elements.
$("div").find("p");
$("div p");

// Disable all links.
$("a").on("click", function (event) {
  event.preventDefault();
  alert("Don't leave me all alone!");
});

// Get the id of the first paragraph.
$("p").attr("id");

// Disable all input elementss.
$(input").attr("disabled", "disabled");

// Do stuff with each matched element.
$("div.foo").forEach(function (el) {
  doStuffWith(el);
});

div:hover span {
    transition: 1s transform;
    transform: rotate(270deg);
}

div span {
    transition: 1s transform;
}
div:hover span {
    transform: rotate(270deg);
}

/*mouseleave*/
div span {
    transition: 3s transform;
}
/*mouseenter*/
div:hover span {
    transform: rotate(270deg);
    transition: 1s transform;
}

<ul id="sdfsde" class="multi-list">
    <li><label for="q1"><input id="q1" type="text" value="" />工商</label></li>
    <li><label for="q2"><input id="q2" type="text" value="" />农业</label></li>
    <li><label for="q3"><input id="q3" type="text" value="" />招商</label></li>
    <li><label for="q4"><input id="q4" type="text" value="" />建设</label></li>
    <li><label for="q5"><input id="q5" type="text" value="" />浦发</label></li>
</ul>

<label id="lbUser">
    <input id="txtUser" type="text" value="单击这里alert二次" />
    单击这里alert三次
</label>
<script type="text/javascript">
$('lbUser').click(function(){
    alert('单击label');
});
$('txtUser').click(function(){
    alert('单击input');
});
</script>

 [{}]+[]//[object Object]

+[]//0 

++[+[]][+[]]//1 

 alert([[{}]+[]][+[]][++[+[]][+[]]])//"o"

// get the reference to the map method
var map = Array.prototype.map;

// and call it for a string
var hello = map.call("hello world", function (char) {
  return char + "*";
});

alert(hello.join("")); // "h*e*l*l*o* *w*o*r*l*d*"

var s = 'abcd'
    f = Array.prototype.join;
var str = f.call(s, '-');
alert(str);// a-b-c-d

// reuse "toUpperCase" method
var toUpperCase = String.prototype.toUpperCase;
var upper = toUpperCase.apply(["foo", "bar"]).split(",");
alert(upper); // ["FOO", "BAR"]

function smallest(array){
    return Math.min.apply( Math, array );
}
function largest(array){
    return Math.max.apply( Math, array );
}

console.log(foo); //reference error
if(foo){ //reference error
    alert('true');
}
typeof(foo); //undefined