第4章-函数（1）

函数对象 Functions

对象是“名/值”对的集合并拥有一个连到原型对象的隐藏链接。对象字面量产生的对象链接到Object.prototype。函数对象连接到Function.prototype（该原型对象本身链接到Object.prototype）。每个函数在创建时会附加隐藏属性：函数的上下文和实现函数行为的代码。

每个函数对象在创建时也有一个prototype属性，它的值是一个拥有constructor属性且值即为该函数的对象。

 

函数字面量 Function Literal

函数对象通过函数字面量来创建

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

一个内部函数除了可以访问自己的参数和变量，同时它也能自由访问把它嵌套在其中的父函数的参数和变量。通过函数字面量创建的函数对象包含一个连到外部上下文的链接。这被称为闭包。

 

调用 Invocation

调用一个函数会暂停当前函数的执行，传递控制权和参数给新函数。除了声明定义的形式参数，每个函数还接受两个附加的参数：this和arguments。参数this在面向对象编程中非常重要，它的值取决于调用的模式。在JavaScript中一共有4种调用模式：方法调用模式、函数调用模式、构造器调用模式和apply调用模式。这些模式在如何初始化关键参数this上存在差异

 

方法调用模式 The Method Invocation Pattern

当一个函数被保存为一个对象的属性时，我们称它为一个方法。当一个方法调用时，this被绑定到该对象。

        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可取的它们所属对象的上下文的方法称为公共方法

 

函数调用模式 The Function Invocation Pattern

当一个函数并非一个对象的属性时，那么它就是被当做一个函数来调用的：

    var sum = add(3,4); //sum的值为7

 

以此模式调用函数时，this被绑定到全局对象。这是语言设计上的一个错误，应当一个内部函数被调用时，this应该被绑定到外部函数的this变量。比如：

        var value = 2;

        var test = {
            value:100,
            increment:function(){
                this.value = this.value + 100;
                var output = function(){
                    console.log(this.value);
                };
                output();
            }
        };

        test.increment(); //2

可以看到最后输出的结果是 2 ，this.value指向的是全局变量中的value。有一个很容易的解决方案就是在对象中将this赋值给另外一个变量

        var value = 2;

        var test = {
            value:100,
            increment:function(){
                var that = this;
                that.value = that.value + 100;
                var output = function(){
                    console.log(that.value);
                };
                output();
            }
        };

        test.increment(); //200

 

构造器调用模式 The Constructor Invocation Pattern

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

        //创建一个名为Quo的构造器函数，他构造一个带有status属性的对象
        var Quo = function (string){
            this.status = string;
        };

        Quo.prototype.get_status = function(){
            return this.status;
        };

        var myQuo = new Quo("confused");
        console.log(myQuo.get_status()); //confused

一个函数，如果创建的目的就是希望结合new前缀来使用，那它被称为构造器函数，按照约定，他们保存在以大写格式命名的变量里。

 

Apply 调用模式 The Apply Invocation Pattern

apply方法让我们构建一个参数数组传递给调用函数。它接受两个参数，第1个是要绑定给this的值，第2个就是一个参数数组。

        var array = [3,4];
        //apply第一个参数传递为null，并不是说将add函数的运行上下文环境设置为null，而是设置为全局对象window
        var sum = add.apply(null,array); //sum的值为7

        var statusObject = {
            status: 'A-OK'
        };
        //statusObject并没有继承自Quo.prototype,但我们可以在statusObject上调用get_status方法，尽管statusObject没有这个方法
        var status = Quo.prototype.get_status.apply(statusObject);//status的值为'A-OK'

 

参数 Arguments

函数可以通过此参数访问所有它被调用时传递给它的参数列表，包括哪些没有分配给函数声明时定义的形式参数的多余参数

        var sum = function(){
            var i,sum = 0;
            for(i=0;i<arguments.length;i++){
                sum += arguments[i];
            }
            return sum;
        }

        console.log(sum(10,20,56,48,2,36,98)); //270

 

返回 Return

一个函数总是会返回一个值，如果没有指定返回值，则返回underfined

如果函数调用时在前面加上了new前缀，且返回值不是一个对象，则返回this（该新对象）

 

异常 Exceptions

异常是干扰程序正常流程的不寻常，当发现这样的事故，应该抛出一个异常：

        var add = function(a,b){
            if(typeof a !== 'number' || typeof b !== 'number'){
                throw{
                    name: 'The Most Serious Error',
                    message: 'you are too handsome',
                    from: 'Qq'
                };
            }
            return a + b;
        }

        //throw语句中断函数的执行，它应该抛出一个exception对象，该对象包含一个用来识别异常类型的name属性和一个描述性的message属性。你也可以添加其他的属性。
        //该exception对象被传递到一个try语句的catch从句：

        var try_it = function(){
            try{
                add("seven");
            }catch(e){
                console.log(e.name + ": " + e.message + "  " + e.from);
            }
        }

        try_it(); //The Most Serious Error: you are too handsome  Qq

如果在try代码块内抛出了一个异常，控制权就会跳转到它的catch从句。一个try语句只会有一个捕获所有异常的catch代码块。如果你的处理手段取决于异常的类型，那么异常处理器必须检查异常对象的name属性来确定异常的类型

 

扩充类型的功能 Augmenting Types

JavaScript允许给语言的基本类型扩充功能。举例来说我们可以给Function.prototype增加方法来使得该方法对所有的函数可用：

        Function.prototype.method = function(name,func){
            this.prototype[name] = func;
            return this;
        };

        //给Number.prototype增加一个integer方法来改善它，他会根据数字的正负来判断使用Math.ceiling还是Math.floor。

        Number.method('integer',function(){
            return Math[this < 0 ?'ceil' : 'floor'](this);
        });

        console.log((10/3).integer()); //3

基本类型的原型式公用的，所以在类库混用时务必小心。一个保险的做法就是只在确定没有该方法时在添加它

        Function.prototype.method = function(name,func){
            if(!this.prototype[name]){
                this.prototype[name] = func;
            }
            return this;
        };