js 方法调用

英文原版： http://devlicio.us/blogs/sergio_pereira/archive/2009/02/09/javascript-5-ways-to-call-a-function.aspx

Time after time I find JavaScript code that has bugs caused by lack of proper understanding of how functions work in JavaScript (a lot of that code has been written by me, by the way.) JavaScript has functional programming characteristics, and that can get in our way until we decide to face and learn it.

For starters, let's examine five ways to invoke a function. On the surface we might be tempted to think that functions work exactly like C#, but we will see that there are important differences and ignoring them will undoubtedly result in hard to track bugs.

Let's first create a simple function that we will be using through the rest of this post. This function will just return an array with the current value of this and the two supplied arguments.

<script type="text/javascript">  
    function makeArray(arg1, arg2){  
        return [ this, arg1, arg2 ];  
    }  
    </script>

Most common way, unfortunately, global function calls

When we are learning JavaScript we learn how to define functions using the syntax used in the example above. We learn that it's also very easy to call that function — all we need to do is:

makeArray('one', 'two');  
    // => [ window, 'one', 'two' ]

Wait a minute. What's that window object doing there? Why is it the value of this? If you haven't stopped to think about it, please stay with me here.

In JavaScript, and I'm not talking specifically about the browser here, there's a default/global object. It's as if every code that we write which seems to be just "loose" inside your script (i.e. outside of any object declaration) is actually being written in the context of that global object. In our case, that makeArray function isn't just a loose "global" function, it's a method of the global object. Bringing ourselves back to the browser, the global object is mapped to the window object in this environment. Let's prove that.

alert( typeof window.methodThatDoesntExist );  
    // => undefined  
    alert( typeof window.makeArray);  
    // => function

What all this means is that calling makeArray like we did before is the same as calling as follows.

window.makeArray('one', 'two');  
    // => [ window, 'one', 'two' ]

I say it's unfortunate that this is the most common way because it leads us to declare our functions globally by default. And we all know that global members are not exactly the best practice in software programming. This is especially true in JavaScript. Avoid globals in JavaScript, you won't regret it.

Method call

Let's now create a small object and use the makeArray function as one of its methods. We will declare the object using the literal notation. Let's also call this method.

//creating the object  
    var arrayMaker = {  
        someProperty: 'some value here',  
        make: makeArray  
    };  
      
    //invoke the make() method  
    arrayMaker.make('one', 'two');  
    // => [ arrayMaker, 'one', 'two' ]  
    // alternative syntax, using square brackets  
    arrayMaker['make']('one', 'two');  
    // => [ arrayMaker, 'one', 'two' ]

See the difference here? The value of this became the object itself. You may be wondering why isn't it still window since that's how the original function had been defined. Well, that's just the way functions are passed around in JavaScript. Function is a standard data type in JavaScript, an object indeed; you can pass them around and copy them. It's as if the entire function with argument list and body was copied and assigned to make in arrayMaker. It's just like defining arrayMaker like this:

var arrayMaker = {  
        someProperty: 'some value here',  
        make: function (arg1, arg2) {  
            return [ this, arg1, arg2 ];  
        }  
    };

This is a major source of bugs in event handling code. Look at these examples.

<input type="button" value="Button 1" id="btn1"  />  
    <input type="button" value="Button 2" id="btn2"  />  
    <input type="button" value="Button 3" id="btn3"  onclick="buttonClicked();"/>  
      
    <script type="text/javascript">  
    function buttonClicked(){  
        var text = (this === window) ? 'window' : this.id;  
        alert( text );  
    }  
    var button1 = document.getElementById('btn1');  
    var button2 = document.getElementById('btn2');  
      
    button1.onclick = buttonClicked;  
    button2.onclick = function(){   buttonClicked();   };  
    </script>

Clicking the first button will display "btn1" because it's a method invocation and this will be assigned the owner object (the button input element.) Clicking the second button will display "window" because buttonClicked is being called directly (i.e. not like obj.buttonClicked().) This is the same thing that happens when we assign the event handler directly in the element's tag, as we have done for the third button. Clicking the third button does the same of the second button.

That's another advantage of using a library like jQuery. When defining event handlers in jQuery, the library will take care of overriding the value of this and make sure it contains a reference to the element that was the source of the event.

//using jQuery  
    $('#btn1').click( function() {  
        alert( this.id ); // jQuery ensures 'this' will be the button  
    });

How does jQuery override the value of this? Keep reading.

Two more: apply() and call()

The more you leverage functions in JavaScript, the more you find yourself passing functions around and needing to invoke them in different contexts. Just like jQuery does in the event handler functions, you'll often need to override the value of this. Remember I told you functions are objects in JavaScript? Functions have predefined methods, two of them are apply() and call(). We can use them to do precisely that kind of overriding.

var gasGuzzler = { year: 2008, model: 'Dodge Bailout' };  
    makeArray.apply( gasGuzzler, [ 'one', 'two' ] );  
    // => [ gasGuzzler, 'one' , 'two' ]  
    makeArray.call( gasGuzzler,  'one', 'two' );  
    // => [ gasGuzzler, 'one' , 'two' ]

The two methods are similar. The first parameter will override this. They differ on the subsequent arguments. Function.apply() takes an array of values that will be passed as arguments to the function and Function.call() takes the same arguments separately. In practice I believe you'll find that apply() is more convenient in most cases.

Constructors

I won't delve into the details of defining types in JavaScript but at minimum we should be aware that there aren't classes in JavaScript and that any custom type needs a constructor function. It's also a good idea to define the methods of your type using the prototype object, which is a property of the constructor function. Let's create a small type.

//declaring the constructor  
    function ArrayMaker(arg1, arg2) {  
        this.someProperty = 'whatever';  
        this.theArray = [ this, arg1, arg2 ];  
    }  
    // declaring instance methods  
    ArrayMaker.prototype = {  
        someMethod: function () {  
            alert( 'someMethod called');  
        },  
        getArray: function () {  
            return this.theArray;  
        }  
    };  
      
    var am = new ArrayMaker( 'one', 'two' );  
    var other = new ArrayMaker( 'first', 'second' );  
      
    am.getArray();  
    // => [ am, 'one' , 'two' ]

What's very important to note here is the presence of the new operator before the function call. Without that your function will just be called like a global function and those properties that we are creating would be created on the global object (window.) And you don't want to do that. Another issue is that, because you typically don't have an explicit return value in your constructor function, you'll end up assigning undefined to some variable if you forget to use new. For these reasons it's a good convention to name your constructor functions starting with an upper case character. This should serve as a reminder to put the new operator before the call.

With that taken care of, the code inside the constructor is very similar to any constructor you probably have written in other languages. The value of this will be the new object that you are trying to initialize.

It's a wrap

I hope understanding the differences between the invocation styles help you keeping bugs out of your JavaScript code. Some of these bugs can be very tricky do identify and making sure you always know what the value of this will be is a good start to avoiding them in the first place.