javascript Function类型

Function（函数）类型实际上是对象，每个函数都是Function类型的实例，而且都与其他引用类型一样具有属性和方法，由于函数是对象，因此函数名实际上也是一个指向函数对象的指针

　　声明方式

　　　　function box(number1,number2){                        //1.普通函数声明的方式
             return number1*number2;
        }


        var box=function(num1,num2){                        //2.使用变量初始化函数
            return num1+num2;
        }


        var box=new Function("num1","num2","return num1+num2")         //3.使用new的构造函数来声明函数（不推荐使用 会解析2次代码）

　　作为值的函数

　　　　函数名本身就是变量，所以函数也可以作为值来使用，也就是说，不仅可以像传递参数一样把一个函数

传递给另一个函数，而且可以将一个函数作为另一个函数的结果返回

function box(sum,name){             
        return sum+name;
    }

    function sum(id){
        return id+10;
    }
    var a=box(sum(10),10);              //sum(10)这里传递的是函数的返回值，和普通的变量一样没区别
    alert(a);

function box(sum,name){             
        return sum(name);
    }

    function sum(id){
        return id+10;
    }
    var a=box(sum,10);              //sum在这里是一个函数，当作参数传递到另一个函数中，而不是函数的返回值
    alert(a);

 

函数的外部属性

　　在函数内部，有两个特殊的对象，arguments和this。arguments是一个类数组对象，包含传入函数中的所有参数，主要用途是保存函数参数，但这个对象还有一个名字叫callee的属性，该属性是一个指针，指向拥有

arguments对象的函数。

    function box(num){
        if (num<=1) {
            return 1;
        }else{
            return num*box(num-1)   //调用自身理解   第一步调用box(4)   4>1返回4*box(3),3>1返回4*3*box(2)，2>1 返回4*3*2*box(1),1=1 返回1  最后结果4*3*2*1=24
        }
    }




    alert(box(4));

利用arguments.callee属性来代替

function box(num){
        if (num<=1) {
            return 1;
        }else{
            return num*arguments.callee(num-1)   //arguments.calle是一个指针可以指向拥有这个arguments函数（也就是自身的意思）
        }
    }

this：

　　其行为与java、C#中的this大致相似，换句话说this引用的是函数据以执行操作的对象，或者说函数调用语句所处的那个作用域，

ps:当在全局作用域中调用函数时，this对象引用的就是window。

　　

//window是一个对象，是js里面最大的对象，是最外围的
    alert(window);             //返回object window
    alert(this);             //返回object window   所以window=this 

    var color="红色的";     //这里的color 就是全局变量,而这个变量又是window的属性
    alert(window.color);     //返回红色的   这里已经很好的说明color是window下面的属性

    window.color="红色的";    //相当与 var color="红色的";
    alert(this.color);         //返回红色的  因为这里的this对象就是window

this.color="蓝色的";
    alert(color);                                    //这里的color是window下的属性，也就是全局变量
    var box={                                     //创建box对象   属性color    方法sayColor
        color:"红色的",                            //这里的color是box属性下的color，也就是局部变量
        sayColor:function(){
            alert(this.color);                        //这里的this代表的是box对象
        }
    }


    box.sayColor();                                  //掉用box下的sayColor    不要直接写SayColor

    window.color="蓝色的";
    function sayColor(){
        alert(this.color);
    }

    sayColor();                   //返回蓝色的，这里的this 没有对象把它包含，它还是winsow的

    window.color="红色的";
    function sayColor(){
        alert(this.color);
    }

    //sayColor();                   //返回蓝色的，这里的this 没有对象把它包含，它还是winsow的

    var box={
        color:'蓝色的'    
    }
    box.sayColor=sayColor;             //这段代码相当于 在box里面加了sayColor:function (){alert(this.color)}
    box.sayColor();

函数的内部属性

length：来获取函数的参数的个数

function box(name,age){
        return name*age
    }

    alert(box.length);   //返回函数的参数个数

prototype属性　　

　　它是保存所有实例方法的真正所在，也就是原型，这个属性我们将在面向对象第一章详细介绍。而prototype下有两个方法，apply（）和call（），每个函数都包含这两个非继承而来的方法。这两个方法的用途都在特定的作用域中调用函数

实际上等于设置函数体内this对象的值

　　语法：

　　　　对象.apply(对象,[参数1，参数2.....]);

function box(name,age){
        return name+age
    }

    //利用apply()方法来冒充执行box
    function sum(name,age){
        return box.apply(this,[name,age])          //this表示windows下的作用域，[]表示传递的参数
    }

    alert(sum(1,6));                              //调用sum方法返回结果和box一样 冒充成功

    function box(name,age){
        return name+age
    }

    //利用apply()方法来冒充执行box
    function sum(name,age){
        return box.apply(this,[name,age])          //this表示windows下的作用域，[]表示传递的参数    apply（）和call可以冒充另外一个函数
    }

    //alert(sum(1,6));                              //调用sum方法返回结果和box一样 冒充成功
    function sum2(name,age){
        return box.apply(this,arguments);          //如果参数过多我们可以使用argument类数组来代替参数
    }
    alert(sum2(10,20));

call（）方法和apply相同，他们的区别仅仅在于接收参数的方式不同，对于call()方法而言，第一个参数是作用域 没有变化，变化只是其余的参数都是直接传递给函数的

    function box(name,age){
        return name+age
    }

    //利用apply()方法来冒充执行box
    function sum(name,age){
        return box.call(this,name,age)          //this表示windows下的作用域，[]表示传递的参数    apply（）和call可以冒充另外一个函数
    }

    alert(sum(10,20));