引用类型---函数

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

一．函数的声明方式

1.普通的函数声明

function sum(num1,num2){        return num1+num2;    }

2.使用变量初始化函数

var sum = function(num1,num2){        return num1+num2;    }

3.使用Function构造函数

var box= new Function('num1', 'num2' ,'return num1 + num2');PS：第三种方式我们不推荐，因为这种语法会导致解析两次代码（第一次解析常规ECMAScript代码，第二次是解析传入构造函数中的字符串），从而影响性能。但我们可以通过这种语法来理解"函数是对象，函数名是指针"的概念。函数名仅仅是指向函数的指针，因此函数名和包含对象指针的其他变量一样。也就是说，不同的函数名可以指向同一个函数。

function hcd(a,b){            return a+b;        }        alert(hcd(1,2));                    //3        var h = hcd;                        //注意:不带括号的函数名表示的是访问函数指针,不是调用函数        alert(h(3,2));                      //5,因为复制的是指针,其实指向的是同一个函数        hcd = null;                         //表示hcd就和函数断绝关系了，他就不是函数指针了        alert(hcd(0,1))                     //hcd is not a function

首先定义了一个函数hcd，将h设置为与hcd相等，(注意：使用不带圆括号的函数名是访问函数指针，而非调用函数结果)，这时hcd和h就指向同一个函数。因为函数的根源是对象，所以将hcd设置为空对象null，就可以将hcd和函数“断绝关系”。但是这并不影响h指向函数。

二．函数的特点

1. 没有重载

    function h(a){        return a+1;    }    function h(b){        return b+2;    }    alert(h(2));//4    其实和这个是一样的：    var h = function(a){        return a+1;    }    h = function(b){        return b+2;    }    alert(h(2));//4

2. 函数声明和函数表达式

函数声明：    解析器会先读取函数声明，并使其在执行任何代码前可用。    alert(hcd(1,2));//3    function hcd(a,b){        return a+b;    }    只是因为在解析时将函数声明放在了代码的顶部函数表达式：    是按代码的顺序执行的。    alert(hcd(1,2));    var hcd = function(a,b){        return a+b;    }    这是会报错误hcd is not a function；除了这点差别外，其他是一样的。

3.作为值的函数

    var hcd = function(a){            return a+5;        }        function h(b,c){            return b(c);        }        alert(h(hcd,10));//15        h函数接受两个参数，第一个参数为函数，第二个参数为传递给改函数的一个值。

一个数组，含有多个对象，根据对象的某一属性值的大小，对对象进行排序        var data =[            {                name:"a",                age:10            },            {                name:"b",                age:11            },            {                name:"v",                age:20            },            {                name:"g",                age:8            }        ]        function compare(s){            return function hcd(obj1,obj2){                var value1 = obj1[s];                var value2 = obj2[s];                if(value1<value2){                    return -1;                }else if(value1>value2){                    return 1;                }else{                    return 0;                }            }        }        data.sort(compare("age"))        console.log(data[0].age)//8        console.log(data[1].age)//10        console.log(data[2].age)//11        console.log(data[3].age)//20

4.函数内部的属性

  在函数的内部有两个特殊的对象：arguments和this

arguments

  arguments：类数组对象，包含所有传入函数中的参数。argument的callee属性指向该函数。

  例如：      常见的递归函数      function hcd(a){            if(a<=1){                return 1;            }else{                return a*hcd(a-1)            }        }      console.log(hcd(4))//24      这样的话就会将执行函数紧紧的与hcd耦合在一起。

 下面的方法会更好。      function hcd(a){            if(a<=1){                return 1;            }else{                return a*arguments.callee(a-1)            }        }        console.log(hcd(4))//24        这样一来：        var text = hcd;        hcd = function(){         return 0;        }         console.log(text(4))//24        console.log(hcd(24))//0        变量text获取了hcd的值，其实是在两外一个位置上保存了函数的指针。

this：

    this引用的是当前函数执行的环境对象。

    wndow.color = "red";        var o = {            color:"blue"        };        function say(){            console.log(this.color)        }        say();                      //"red"        o.say = say;        o.say();                     //"blue"

  say函数为在全局定义的函数，在调用函数前，并不能确定this是那个对象。  当在全局中调用时，this引用的是全局对象window，换句话说this.color会转换为window.color。  而当将say函数赋值给o.say()时，this引用的是对象o。

5.函数的属性和方法

    函数就是对象，所以有属性和方法。    每个函数都有两个属性：length，prototype

length

    length：接受参数的个数

        function hcd(a,b){            return a+b;        }        function h(a){            return a;        }        alert(hcd.length);                  //2        alert(h.length);                    //1

prototype

    对于prototype属性，它是保存所有实例方法的真正所在，也就是原型。这个属性，我们将在面向对象一章详细介绍。而prototype下有两个方法：apply()和call()每个函数都有2个非继承而来的方法call和apply，这两个方法可以让函数在特定的作用域中调用函数，其实等于设置this。

apply

    apply:参数1.运行函数的作用域，参数2.数组，也可以是数组实例，也可以是arguments

        function hcd(a,b){            return a+b;        }        function h1(c,d){            return hcd.apply(this,arguments);        }        function h2(c,d){            return hcd.apply(this,[c,d]);        }        alert(h1(10,10));        alert(h2(10,10));        在全局环境下调用h2和h1,所以传入hcd的this即为window对象

call：

    和apply的用法类似，只不过参数2不为数组

        function h2(c,d){            return hcd.call(this,c,d);        }        apply和call的真正强大在于扩充函数赖以运行的作用域。        window.color = "red";        var o = {            color:"blue"        };        function hcd(){            alert(this.color)        }        //在全局环境下运行        hcd();             //"red"        //在函数调用的环境下运行        hcd.call(this);     //"red"        //在全局环境下运行        hcd.call(window);     //"red"        //在o环境下运行        hcd.call(o);     //"blue"

bind()

创建一个函数的实例，this会绑定到传给bind()函数的值。

        window.color = "red";        var o = {            color:"blue"        };        function hcd(){            alert(this.color)        }        var objectSay = hcd.bind(o);        objectSay()//"blue"        hcd()调用bind()并传入对象o，意思就说在环境变量为o的情况下，创建一个函数实例objectSay。