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)

  

posted @ 2012-03-28 20:29  失落心灵  阅读(249)  评论(0编辑  收藏  举报