JavaScript语言精粹之函数

函数对象

JavaScript中的函数就是对象。所以函数可以像其他值一样被使用。函数可以保存在变量，对象和数组中。函数可以被当做参数传递给其他函数，函数也可以再返回函数。而且，因为函数是对象，所以函数可以拥有方法。
函数的与众不同之处在于：它们可以被调用。

函数字面量

            function add(a,b){
                return a+b;
            }

函数字面量包括4个部分：

• 保留字function
• 函数名，它可以被省略，被省略函数名被称为匿名函数
• 包围在圆括号中的一组参数，多个参数用逗隔开
• 包围在花括号中的一组语句，这些语句是函数的主体，在函数被调用是执行

调用

调用一个函数会暂停当前函数的执行，传递控制权和参数给新函数。除了声明时定义的参数，每个函数还接受两个附加参数：this和arguments。参数this在面向对象过程中很重要，它的值取决于不同的调用模式。javascript中共有四种调用模式：方法调用模式，函数调用模式，构造器调用模式和apply调用模式。

            function add(a,b){
                console.log(a+b); //7
                console.log(arguments); //(4)[3,4,5,6];
            }
            add(3,4,5,6);

当实际参数（arguments）的个数与形式参数（parameters）的个数不匹配时，不会导致错误。如果实际参数值过多了，超出的参数值会被忽略。如果实际参数值过少，缺失的值会被换为undefined。

方法调用模式

            var myObject={
                value:0,
                increment:function(inc){
                    this.value+=typeof inc==='number'?inc:1;
                }
            }
            myObject.increment();
            console.log(myObject.value); //1
            myObject.increment(2);
            console.log(myObject.value); //3

当函数被保存为一个对象的属性的时候，我们称它为一个方法。当一个方法被调用的时候，this被绑定到该对象。方法可以使用this访问自己的所属对象，所以它能从对象中取值或者对对象进行修改。通过this可取得它们所属对象的上下文的方法称为公共方法。

函数调用模式

function add(a,b){
    return a+b;
}
var sum=add(3,4);

当一个函数并非一个对象的属性的时候，那么它就被当做一个函数来调用。这种调用方式，this绑定到全局对象。这是设计上的错误，如果想要了解请移步：
http://blog.csdn.net/chengqunbin/article/details/79114259

构造器调用模式

如果在一个函数面前带上new来调用，那么背地里将会创建一个连接到该函数的prototype成员的新对象，同时，this会绑定到那个新对象。

            //创建一个名为Que的构造器函数，它构造一个带有status属性的对象。
            var Quo=function(string){
                this.status=string;
            }
            //给Que的所有实例提供一个名为get_status的公共方法。
            Quo.prototype.get_status=function(){
                return this.status;
            }
            //创建一个Que实例，这个时候this绑定到myQue
            var myQuo=new Quo("confused");
            console.log(myQuo.get_status());//confused

一个函数，如果创建的目的就是希望结合new前缀来使用，那么它就被称为构造器函数，一般用大写命名。

Apply调用模式

apply方法让我们构建一个参数传递给调用函数，它允许我们选择this值。apply方法接收两个参数，一个是要绑定给this的值，另外一个就是一个参数数组。

            var array=[3,4];
            var sum=add.apply(null,array); //7

            var statusObject={
                status:'A-OK'
            };
            //status并没有继承自Quo.prototype，但是我们可以在statusObject调用get_status方法。
            var status=Quo.prototype.get_status.apply(statusObject);
            console.log(status);//A-OK

异常

            var add=function(){
                if(typeof a!=='number'||typeof b!=='number'){
                    throw {
                        name:"TypeError",
                        message:"add needs numbers"
                    }
                }
                return a+b;
            }
            var a;
//          console.log(add(a,8)); //Uncaught {name: "TypeError", message: "add needs numbers"}

throw语句中断函数的执行，它应该抛出一个exception对象：{name: “TypeError”, message: “add needs numbers”}

            var try_it=function(){
                try{
                    add(a,8);
                }catch(e){
                    console.log(e.name+":"+e.message);
                }
            }
            try_it(); //TypeError:add needs numbers

递归

递归函数就是会直接或者调用自身的一种函数。

            function factorical(num){
                if(num<1){
                    return 1;
                }else{
                    return num*factorical(num-1);
                }
            }
            console.log(factorical(3));//6

扩充类型的功能

我们可以通过给Function.prototype添加方法来使得该方法对所有的函数可用。

            Function.prototype.method=function(name,func){
                if(!this.prototype[name]){
                    this.prototype[name]=func;
                }
                return this;
            }
            Number.method('integer',function(){
                return Math[this<0?'ceil':'floor'](this);
            })
            console.log((-10/3).integer()); //-3

            String.method('trim',function(){
                return this.replace(/^\s+|\s+$/g,'');
            });
            console.log('"'+"   neat   ".trim()+'"');//"neat"

我们知道，上面代码使用了函数调用模式中的方法调用，所以，这个this也就是对象neat。

闭包

我们直接来看我们修改之前的两个demo

            var myObject1=(function(){
                var value=0;
                return {
                    increment:function(inc){
                        value+=typeof inc==='number'?inc:1;
                    },
                    getValue:function(){
                        return value;
                    }
                };
            }());
            console.log(myObject1.increment(3));//  undefined

上面的demo显示，我们通过一个函数的形式去初始化myObject，该函数会返回一个对象字面量，函数里定义的value变量，对于方法内部的方法是可见的，可是对于外部是不可见的。

            var quo1=function(status){
                return {
                    get_status:function(){
                        return status;
                    }
                };
            };
            var myQuo1=quo1('amazed');
            console.log(myQuo1.get_status());//amazed

上面的这个demo我们同样使得status在方法的内部可见，外部不可见。

    这就是闭包的作用。