JavaScript的隐藏特性？

您永远不必使用 eval() 来组装全局变量名。

也就是说，如果您有几个全局变量（出于任何原因）的名称为 spec_grapes, spec_apples，您不必使用 eval("spec_" + var) 访问它们。

所有全局变量都是 window[] 的成员，所以您可以使用 window["spec_" + var]。

JavaScript使用简单的对象字面量：

var x = { intValue: 5, strValue: "foo" };

这将构造一个完整的对象。

JavaScript使用基于原型的面向对象编程，并提供了在运行时扩展类型的能力：

String.prototype.doubleLength = function() {
    return this.length * 2;
}

alert("foo".doubleLength());

对象将自己不包含的所有属性访问委托给其“原型”，即另一个对象。这可以用于实现继承，但实际上更强大（即使更加繁琐）：

/* "Constructor" */
function foo() {
    this.intValue = 5;
}

/* Create the prototype that includes everything
 * common to all objects created be the foo function.
 */
foo.prototype = {
    method: function() {
        alert(this.intValue);
    }
}

var f = new foo();
f.method();

在使用 Firebug 的 console.log() 进行测试时，防止在 Internet Explorer 中出现烦人的错误：

function log(message) {
    (console || { log: function(s) { alert(s); }).log(message);
}

var names = new Array(1024), i = names.length;
while(i--)
  names[i] = "John" + i;

var birds = new Array(1024); 
for(var i = 0, j = birds.length; i < j; i++)
  birds[i].fly();

使用数组连接大字符串（更快）：

var largeString = new Array(1024), i = largeString.length;
while(i--) {
  // It's faster than for() loop with largeString.push(), obviously :)
  largeString[i] = i.toString(16);
}

largeString = largeString.join("");

在循环中，它比 largeString += "something" 这种方式要快得多。

我最喜欢的之一是构造函数类型检查：

function getObjectType( obj ) {  
    return obj.constructor.name;  
}  

window.onload = function() {  
    alert( getObjectType( "Hello World!" ) );  
    function Cat() {  
        // some code here...  
    }  
    alert( getObjectType( new Cat() ) );  
}

所以，与 typeof 关键字通常返回的疲惫不堪的 [Object object] 不同，您实际上可以根据构造函数获取真正的对象类型。

另一个方法是使用可变参数作为“重载”函数的一种方式。您所做的只是使用表达式来检测参数数量并返回重载输出：

function myFunction( message, iteration ) {  
    if ( arguments.length == 2 ) {  
        for ( i = 0; i < iteration; i++ ) {  
            alert( message );  
        }  
    } else {  
        alert( message );  
    }  
}  

window.onload = function() {  
    myFunction( "Hello World!", 3 );  
}

var a, b, c, d;
b = a;
c = b;
d = c;

新的（速记）方式：

var a, b, c, d;
d = c = b = a;

玩得开心 :)

如果你用逗号分隔语句，你可以在圆括号内做几乎任何事情：

var z = ( x = "can you do crazy things with parenthesis", ( y = x.split(" "), [ y[1], y[0] ].concat( y.slice(2) ) ).join(" ") )

alert(x + "\n" + y + "\n" + z)

输出：

can you do crazy things with parenthesis
can,you,do,crazy,things,with,parenthesis
you can do crazy things with parenthesis

function Animal () {

}

var animal = new Animal();
var animal = new Animal;

同样的事情。

函数声明和函数表达式的处理方式不同。

function blarg(a) {return a;} // statement
bleep = function(b) {return b;} //expression

函数表达式在遇到它们的地方内联执行。它们在此之前不可用，但可以利用动态上下文。