JavaScript中的面向对象【四】

Function　

　　有一个内置的构造器函数叫Function（），它允许以另外一种方式创建函数。　　

　　function sum01(a, b) { return a + b; }
 　　document.write(sum01(1,2));

　　var sum02 = function (a, b) { return a + b; } 
　　document.write(sum02(1,2));

　　//注意:Function是大写
　　var sum03 = new Function ('a', 'b', 'return a + b;')
　　document.write(sum03(1, 2));

　　如果你用Function 构造器创建函数时有许多的参数，那么传给Function 的时候可以只传一个参数，它们是以一个逗号分隔的列表　

　　　　var sum03 = new Function ('a', 'b', 'return a + b;')
　　　　document.write(sum03(1, 2));

　　　　var sum04 = new Function('a, b', 'return a + b;')
　　　　document.write(sum04(1, 2));

　　　　var sum05 = new Function('a, b', 'c', 'return a + b + c;')
　　　　document.write(sum05(1, 2, 3));

　　当用Function（）构造器的时候，先传递的数据会作为参数（以字符串），接着是函数体的源代码（也以字符串的形式）。 　　
　　JavaScript引擎就会评估你传过来的源代码并为你创建一个函数。 　　
　　源代码的评估会遭受eval（）函数一样的缺点。所以用Function（）构造器定义函数应该尽可能的避免（不推荐使用）。

Function对象的属性

　　constructor 属性（“JavaScript中的面向对象【二】”中讲过，所以这里就不讲了）

　　length属性：得到的是Function的参数个数

        function myFunction(a, b, c) {
            return a + b + c;
        }
        
        //Function的length属性得到的是Function的参数个数
        alert(myFunction.length);

　　caller属性：返回调用本函数的函数引用

        //Two()调用了One(),而One()中返回的One调用了caller
        function One() {
            return One.caller;
        }

        function Two() {
            return One();
        }

        //此时，Two()将返回自己Two();
        alert(Two());

        //如果你在全局空间（在任何函数外面)调用One(),则返回null
        alert(One());

        //****************************************************************
        //没有调用caller
        function Three() {
            return Three;
        }

        function Fore() {
            return Three();
        }

        //此时，Fore()将返回调用的函数Three();
        alert(Fore())

　　prototype属性（请期待以后的文章）

Function对象的方法

　　call()方法：改变this的指向

　　　　如果方法有参数的话： call(this要指向的对象,参数1，参数2...)
　　　　如果方法没有参数的话： call(this要指向的对象)

       var MyFunction = { 
            name:'John',
            run:function(name){
                alert(this.name + '和' + name + '在跑!')
            }
        }

        var OtherFunction = { 
            name:'Jeff'
        }

        //call(this要指向的对象,参数1，参数2...)
        //MyFunction.run()方法中的this.name的this在没有调用call方法时是指向了MyFunction
        //但当调用了call方法后，this指向了OtherFunction，所以this.name的值是‘Jeff’
        MyFunction.run('Mary');
        MyFunction.run.call(OtherFunction, 'Mary');

　　apply()方法：与Call()方法一样，不过它的参数是一个数组

　　　　如果方法有参数的话： apply(this要指向的对象,[ 参数1，参数2... ]) 　　　　
　　　　如果方法没有参数的话： apply(this要指向的对象) 　

       //apply原理与call一样,只不过apply(this要指向的对象,一个参数数组)
        MyFunction.run.apply(OtherFunction, ['MM']);

arguments 对象

　　arguments 看上去像一个数组，但实际上它是一个像数组的对象而已。
　　它看上去像数组是因为它包含索引化的元素和length属性，然而，相似性也就到此为止了，
　　因为arguments没有提供任何数组的方法，如：sort（）或者slice（）。

　　利用arguments对象可以做一个可变参数的函数

        function argDemo() {
            for (var i = 0; i < arguments.length; i++) {
                document.write(arguments[i]);
            }
        }

        argDemo(1);
        argDemo(1,2);
        argDemo(1,2,3);

　　arguments对象还有另外一个有趣的属性——callee属性。它包含被调用函数的一个引用

        //它包含被调用函数的一个引用。
        //如果你创建了一个函数它返回arguments.callee 并且你调用了这个函数，
        //它只是简单返回一个自己的引用
        function Demo() {
            return arguments.callee;
        }

        alert(Demo());

　　我们再看下面的例子：　

       //arguments.length是实参长度，arguments.callee.length是形参长度
        function calleeLengthDemo(arg1, arg2) {
            if (arguments.length == arguments.callee.length)
                alert('实参长度等于形参长度');
            else
                alert('实参长度:' + arguments.length + '  形参长度:' + arguments.callee.length)
        }

        //实参长度等于2，形参长度等于2
        calleeLengthDemo(1, 1);
        //实参长度等于3, 形参长度等于2
        calleeLengthDemo(1, 1, 1);

Error对象

• 　JavaScript 提供了try,catch 和finally 以帮助处理错误。如果一个错误发生，一个错误对象会抛出。
• 　Error 对象通过这几个内置的构造器之一来创建：EvalError，RageError，ReferenceError，SyntaxError，TypeError，URIError。
• 　所有的这些构造器都继承于Error 对象。

　　我们看下面的例子

       function MyFunction() {
            this.style.color = 'gray';
        }

        try{
            MyFunction();  
        }
        catch (e) {      
            //e.name 包含用来创建错误对象的构造器的名字
            //e.message 错误信息
            alert(e.name + '  ' + e.message);
        }

　　上面的例子是获取的是系统的错误信息，下面我们抛出我们定义的错误信息。

　　有两种方式：　

       //抛出一个Error对象
       throw new Error(‘ code… ’)
       //抛出一个对象，里面包含name属性和message属性
　　　　throw {
　　　　　　name:’  code… ’,
　　　　　　message:’ code… ’
　　　　}

　　我们看一下这两种方式的例子：

　　抛出一个Error对象

          function ThrowDemo(num) {
            try {
                if (num === 0) {
                    throw new Error('Error:输入信息有误！');
                }
                else {
                    alert(num);
                }
            }
            catch (e) {
                alert(e.name + " : " + e.message);
            }
            finally {
                alert('finally');
            }
        }

        ThrowDemo(0);

　　抛出一个对象，里面包含name属性和message属性 　

        function ThrowObjectDemo(num) {
            try {
                throw {
                    name:'Error',
                    message:'有错误！'
                }
            }
            catch (e) {
                alert(e.name + " : " + e.message);
            }
        }

        ThrowObjectDemo(0)