JavaScript面向对象编程指南(四) 对象

第4章 对象

4.1 从数组到对象

对象的组成：变量名、{}、用逗号分割的属性、用冒号分割的键/值对。

        var f={
            name:'alen',  // 可以在属性名上加引号
            age:12
        };

对象文本标识法：用{}定义对象的方法；数组文本标识法：用[]定义数组的方法。

4.1.1 元素、属性、方法与成员

数组包含元素，对象包含属性。说法不同，但本质相同。当对象的属性为函数时，称该属性为方法。

        var dog={
            name:'aa',
            talk:function (){   //talk是一个方法
                alert('woof,woof!');
            }
        };

4.1.2 哈希表、关联型数组

数组形式：

一般性数组：也叫索引型数组或枚举型数组（通常以数字为键名）

关联型数组：哈希表或字典（通常以字符串为键值）

4.1.3 访问对象属性

中括号表示法：如dog['name'].

点号表示法：dog.name      可以混合使用两种表示法

如果要访问的属性名不确定，必须使用中括号表示法。

4.1.4 调用对象方法

在指定的方法名后面加()

dog.talk(); //或dog['talk']()

4.1.5 修改属性与方法

        //为对象添加属性和方法
        var hero={}；
        hero.name='a';
        hero.sayName=function (){
            return hero.name;
        };
        //调用方法
        hero.sayName();
        //删除属性
       delete hero.name

4.1.6 使用this值

       var hero={
        name:'a',
        sayName:function (){
            return this.name; // this引用当前对象或这个对象
        }
       };

4.1.7 构造器函数

通过构造器函数来创建对象

       //使用构造器函数来创建对象，构造器函数的首字母一般大写
       function Hero(){
        this.name='a';
       }
       //使用new操作符，为该函数创建对象
       var f1=new Hero();
       f1.name;  //  "a"
       //没用使用new操作符
        var f1=Hero();
        typeof h;  // "undefined"

4.1.8 全局对象

当宿主的环境是web浏览器时，它提供的全局对象是window。

var a=1;
window.a;//
this.a; //1

当构造函数不使用new时，this指向全局对象，所以typeof h；// undefined

4.1.9 构造器属性

constructor property：指向用于创建该对象的构造器函数的引用。

 function Hero(){};
        var a=new Hero();
        a.constructor;  // function Hero(){}
        var o={};  // 由内建构造函数Object()创建
        o.constructor; //  function Object() { [native code] }  

4.1.10 instanceof 操作符

测试一个对象是否为某一个指定的构造器函数所创建。

a instanceof Hero;  // true

4.1.11 返回对象的函数

使用一般函数来创建对象。

        function factory(name){
            return {
                name:name
            };
        }
        var o=factory('one');
        o.name; //  "one"
        o.constructor; // function Object() { [native code] } 

4.1.12 传递对象

当拷贝某个对象或者将它传递给某个函数时，往往传递的是该对象的引用。因此在引用上所做的任何更改，都会影响它所引用的原对象。

        var f1={age:};
        var f2=f1;
        f1.age; //
        f2.age=; //改变age的值
        f1.age;  // 100    f1中age的值也发生改变

4.1.13 比较对象

对象比较操作时，当且仅当两个引用指向同一个对象，结果为true。

        var f3={name:"alen"};
        var f4={name:"alen"};
        f3===f4; // false    

4.2 内建对象

内建对象大致分为三类：

数据封装类对象——包括Object、Array、Boolen、String、Number。

工具类对象——Nath、Date、RegExp等

错误类对象

4.2.3 Function

三种定义函数的方式

        // 函数定义的三种方式

         // 函数声明
         function sum(a,b){
            return a+b;
         }
         // 函数表达式
         var sum=function (a,b){
            return a+b;
         }
         // 构造函数  不推荐使用
         var sum=new Function('a','b','return a+b');

4.2.3.1 函数对象的属性

constructor：引用Function这个构造器函数

length：参数的数量

        function f1(){
            return ;
        };
        f1.constructor; // function Function() { [native code] }

prototype属性：指向一个对象，只有该函数是构造器时才会发挥作用。

4.2.3.2 函数对象的方法

拥用Object对象的方法。toString()方法：函数的源代码

        function f1(){
            return ;
        };
        f1.constructor; // function Function() { [native code] }
        f1.toString(); //  "function f1(){return 1;}" 源代码
        parseInt.toString(); //  "function parseInt() { [native code] }" 内建函数
        // 可以使用toString来区分本地方法和自定义方法

4.2.3.3 call()与apply()

每个函数都有call()和apply()方法，用来触发函数并指定相应的参数。

可是实现代码重用：让一个对象去借用另一个对象的方法。

       var f1={
            name:'Alen',
            say:function (who){
                return 'Hi '+who+', I am '+this.name;
            }
        };
       f1.say('XiaoMing'); //"Hi XiaoMing, I am Alen"
       var f2={name:'XiaoLi'};
       // f2调用f1的say()方法   f1的say方法借给f2
       f1.say.call(f2,'XiaoMing');  //"Hi XiaoMing, I am XiaoLi"
       // apply方法参数的传递通过数组
       f1.say.apply(f2, ['XiaoMing']);  //"Hi XiaoMing, I am XiaoLi"

4.2.3.4 重新认识arguments对象

arguments和数组相比只包含了索引元素和length属性。但可以把arguments转换为数组，从而使用各种数组的方法。

        function f(){
            var args=Array.prototype.slice.call(arguments);//继承数组的方法
            // var args=[].slice.call(arguments);
            return args.reverse(); //翻转
        }
        f(,,,); // [4, 3, 2, 1]