JavaScript函数（二）

在前面我们已经对函数作了简单的介绍，比如函数的定义、函数的声明、函数的调用和函数的传参等。本节将进一步介绍函数的应用，深度理解函数的各种使用。

函数是一个对象，每个函数时Function类型的一个实例，与其他引用类型一样有属性和方法。由于函数时对象，因此函数名实际上也是一个指向函数对象的指针，不会与某个函数绑定。函数通常是函数声明语法定义的。

function sum(x,y){
                    return x+y;
                }

上面使用函数声明语法定义的。

var sum=function(a,b){
                    return a+b;
                }；

上面使用函数表达式声明了一个函数。定义了变量sum，并将其初始化为一个函数。在使用函数表达式定义函数时，没有必要使用函数名。通过变量sum可以引用函数，另外函数的末尾有个分号，与普通的变量定义一样。

另外可以使用Function构造函数来定义函数。Function构造函数可以定义任何数量的参数，最后一个函数被看成是函数体。

var sum= new Function("a","b","return a+b");

function sum(a,b){
                    return a+b;
                }
                var anotherSum=sum;
                console.log(sum(1,2));
                sum=null;
                console.log(anotherSum(2,3));

上面定义了函数sum，用于求两个数之和。定义了变量anotherSum，并将sum赋值给anthorSum。这样anotherSum与sum指向了同一个指针。最后调用的时候，即使将sum=null，依然可以调用anotherSum。

var sum=function(a,b){
                    return a+b;
                }
                sum=function(a,b){
                    return a*b;
                }
                console.log(sum(2,4));//输出8

上面的代码可以清楚地看出函数时没有重载的。后定义的sum将前面的sum覆盖。

JavaScript解析器在执行环境时，对于函数声明和函数表达式定义的函数并不是一视同仁的。解析器会先调用函数的声明，在执行其他代码之前可用。函数表达式，只有当函数执行到当前行，才会被解释执行。

console.log(sum(2,3));//输出5
                function sum(a,b){
                    return a+b;
                }
                console.log(subtract(2,3));//报错，subtract is not function
                var subtract=function(a,b){
                    return a*b;
                }

上面的代码可以看出区别。函数的声明在调用前已经添加到执行环境中，会将函数声明添加到顶部环境中。而通过函数表达式定义的函数，在声明变量前，就调用会发生错误。经过上面的比较，不管是函数声明，还是函数表达式，我们都要养成先定义，再使用的习惯。

JavaScript函数本身就是变量，所以函数可以作为值来使用。函数不仅可以作为参数来传递，而且可以将函数作为另一个函数的结果返回。

function callFunction(func,num){
					return func(num);
				}
				function sum(num){
					return num+10;
				}
				console.log(callFunction(sum,10));

　　上面的代码就是将函数作为另一个函数的结果返回，输出20.

函数内部包含一个子函数，并且返回子函数，这就是所谓的函数闭包。闭包的好处就是可以缓存数据。

function closeTest(){
                    var n=1;
                    Add=function(){
                        n=n+1;
                    }
                    return function F(){
                        return n+1;
                    }
                }
                var result = closeTest();
                console.log(result());
                Add();
                console.log(result());

上面的代码就是一个闭包函数。在闭包函数内部可以使用函数的内部变量。第一个调用result，返回2.第二次调用result输出3，因为前面已经调用了add方法，将n+1，所以最好输出的结果是3.

var name = "The Window";
            　　var object = {
            　　　　name : "My Object",
            　　　　getNameFunc : function(){
            　　　　　　return function(){
            　　　　　　　　return this.name;
            　　　　　　};
            　　　　}
            　　};
            var  result=object.getNameFunc();
            　　console.log(result());//undefined,this的指向是window

通过上面的代码可以看清楚，调用result方法的时候，this指向了window，this.name为undefined

var name = "The Window";
            　　var object = {
            　　　　name : "My Object",
            　　　　getNameFunc : function(){
            　　　　　　return function(){
            　　　　　　　　return this.name;
            　　　　　　}.bind(this);
            　　　　}
            　　};
            var  result=object.getNameFunc();
            　　console.log(result());//My Object

这个代码我们加了bind方法，bind函数用于改变this的指向。this.name指向的是object对象，所以result有输出值。bind函数并不会立即执行，当调用该函数的时候才会执行，同时bind函数可以给函数绑定参数。

var substract=function(a,b){
                return a*b;
            };
                var sum=function(a,b){
                    var that=this;
                    console.log(that);
                    return a+b;
                }.bind(substract,3,4);
                console.log(sum(1,2));//输出7

上面的代码使用bind函数改变了sum函数的this指向，this指向了substract函数，同时为sum添加了两个参数3,4.虽然我在调用的时候又传递了参数1,2,但是我们bind的参数值是在前面的，所有输出7.arguments[2]=1,arguments[3]=2。传递的参数通过arguments依然可以访问到。

函数还有两个常用的方法apply和call。apply和call两个方法的效果是改变函数的指向，并能传递参数，但是立即执行。apply第一个参数是对象，用于改变函数的this指向；第二个参数是数组，是传递给函数的值。call的第一个参数与apply一样，但是call的第二个参数不是数组，与bind类似，参数是一个一个传递的。

function sayHello(str){
                    console.log(str);
                }
                sayHello.bind(this,"bind");
                sayHello.call(this,"call");
                sayHello.apply(this,["apply"]);

上面的代码，我们比较了函数的bind、call和apply方法的不同。最后我们看输出的值为 call apply。但是bind并没有输出，所以说bind并不能让函数立即调用。函数调用bind方法之后，函数依然是一个函数。

sayHello.bind(this,"bind")();这个代码会输出“bind”

apply方法和call方法还可以在函数内部进行调用，并能改变this的指向。

function Super(){
                    this.a="10";
                }
                function Sub(){
                    Super.call(this);
                    this.b="20";
                }
                var sub = new Sub();
                console.log(sub.a);
                console.log(sub.b);

上面的代码有点面向对象继承的意思。通过在sub内部调用super的call方法，让sub也拥有了super的属性。最后的输出结果是 10 20。

函数还拥有一些属性可以使用。如果让我们写一个阶乘函数，大多数人都会这样写：

function factorial(n){
                    if(n<1){
                        return 1;
                    }
                    else{
                        return n*factorial(n-1);
                    }
                }

阶乘算法会用到函数的递归，上面的方法将函数名在函数内部再次调用，增加了函数的耦合。我们可以使用函数的属性callee来解耦。callee是函数的属性，它是一个指针，指向拥有这个函数名的函数。

上面的代码我们可以使用arguments.callee替换函数。

function factorial(n){
                    if(n<1){
                        return 1;
                    }
                    else{
                        return n*arguments.callee(n-1);
                    }
                }
                console.log(factorial(10));//

闭包可以减少全局变量的使用。

(function() {

                    window.oEvent=window.oEvent||{};
                    var addEvent = function() { /*代码的实现省略了*/ };

                    function removeEvent() {}

                    oEvent.addEvent = addEvent;
                    oEvent.removeEvent = removeEvent;
                })(window);
                console.log(oEvent.addEvent());

上面的代码只定义了一个全局变量