你可以在任何对象上执行一个对象的方法，不管它是否有这个方法。当然，它可能并不总是有效(如果方法假设对象具有它没有的东西)，但它可能非常有用。例如:

function(){
    arguments.push('foo') // This errors, arguments is not a proper array and has no push method
    Array.prototype.push.apply(arguments, ['foo']) // Works!
}

jQuery和JavaScript:

变量名可以包含许多奇数字符。我使用$字符来标识包含jQuery对象的变量:

var $links = $("a");

$links.hide();

jQuery的对象链接模式非常好，但是应用这个模式可能会让人有点困惑。幸运的是JavaScript允许你断行，就像这样:

$("a")
.hide()
.fadeIn()
.fadeOut()
.hide();

一般的JavaScript:

我发现通过使用自执行函数来模拟作用域很有用:

function test()
{
    // scope of test()

    (function()
    {
        // scope inside the scope of test()
    }());

    // scope of test()
}

您可以将“任何具有整数属性和长度属性的*对象转换为适当的数组，从而赋予它所有数组方法，如push、pop、splice、map、filter、reduce等。

Array.prototype.slice.call({"0":"foo", "1":"bar", 2:"baz", "length":3 }) 

//返回["foo"， "bar"， "baz"]

这适用于jQuery对象，html集合和来自其他框架的数组对象(作为整个数组类型的一种可能的解决方案)。我说，如果它有一个长度属性，你可以把它变成一个数组，这没有关系。有很多非数组对象都有length属性，在arguments对象之外。

函数可以有方法。

我使用AJAX表单提交的这种模式。

var fn = (function() {
        var ready = true;
        function fnX() {
            ready = false;
            // AJAX return function
            function Success() {
                ready = true;
            }
            Success();
            return "this is a test";
        }

        fnX.IsReady = function() {
            return ready;
        }
        return fnX;
    })();

    if (fn.IsReady()) {
        fn();
    }

这里有一个简单的思考“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)"返回该属性的名称，则该属性是可枚举的。

嗯，这不是一个很重要的功能，但它非常有用:

显示可选择和格式化的警报:

alert(prompt('',something.innerHTML ));