函数l (f, n) {n&&l (n - 1 f, f (n));} L(函数(循环){警报(循环);}， 5);

警报5、4、3、2、1

确保在遍历对象属性时使用hasOwnProperty方法:

for (p in anObject) {
    if (anObject.hasOwnProperty(p)) {
        //Do stuff with p here
    }
}

这样做是为了只访问object的直接属性，而不使用原型链下面的属性。

还有一个几乎不为人知的JavaScript语法:

var a;
a=alert(5),7;
alert(a);    // alerts undefined
a=7,alert(5);
alert(a);    // alerts 7

a=(3,6);
alert(a);    // alerts 6

更多信息请点击这里。

这似乎只适用于Firefox (SpiderMonkey)。函数内部:

Arguments[-2]给出了参数的个数(与Arguments .length相同) Arguments[-3]给出了被调用的函数(与Arguments .callee相同)

window.name的值在页面更改时保持不变，如果在同一个域中(如果在iframe中，使用document)，可以被父窗口读取。getElementById(“你的帧的ID”). contentwindow .name来访问它)，并且只受可用内存的限制。

这里有一个简单的思考“this”的方法。函数中的'This'将引用该函数的未来对象实例，通常使用operator new创建。所以很明显，内部函数的“this”永远不会指向外部函数的实例。

以上建议可以让你远离麻烦。但是你可以用“this”做更复杂的事情。

示例1:

     function DriveIn()
     {
          this.car = 'Honda';
          alert(this.food);  //'food' is the attribute of a future object 
                             //and DriveIn does not define it.
     }

     var A = {food:'chili', q:DriveIn};  //create object A whose q attribute 
                                         //is the function DriveIn;

     alert(A.car); //displays 'undefined' 
     A.q();        //displays 'chili' but also defines this.car.
     alert(A.car); //displays 'Honda' 

规则如下:

当一个函数作为一个对象的属性被调用时，在函数内部(但在任何内部函数之外)出现的任何'this'都指向该对象。

我们需要明确，即使使用operator new，“The Rule of This”也适用。在幕后，new通过对象的构造函数属性将“this”附加到对象上。

示例2:

      function Insect ()
      {
           this.bug = "bee";
           this.bugFood = function()
           {
               alert("nectar");
           }
       }

      var B = new Insect();
      alert(B.constructor); //displays "Insect"; By "The Rule of This" any
                            //ocurrence of 'this' inside Insect now refers 
                            //to B.    

为了更清楚地说明这一点，我们可以不使用operator new创建一个Insect实例。

示例3:

   
    var C = {constructor:Insect};  //Assign the constructor attribute of C, 
                                   //the value Insect.
    C.constructor();               //Call Insect through the attribute. 
                                   //C is now an Insect instance as though it 
                                   //were created with operator new. [*]
    alert(C.bug);                  //Displays "bee." 
    C.bugFood();                   //Displays "nectar." 

[*]我能辨别的唯一实际区别是，在示例3中，'constructor'是一个可枚举属性。当使用operator new时，'constructor'变成一个属性，但不是可枚举的。如果for-in操作"for(var name in object)"返回该属性的名称，则该属性是可枚举的。