javascript之object小结

本文摘自：http://blog.csdn.net/penghua12345/article/details/6610271

一、        Object的定义

1、object的两种定义方式

（1）、通过json格式

var o = {

name : 'myname',

    age : 40

};

（2）、通过点形式添加属性

Var o = {};

o.name=’yaoming’

o.age=100

   2、object的属性

              （1）、通过点

                       o.name

             （2）、通过属性名

o['name']

            （3）、遍历obj内置的属性

function dump(obj) {

   for(var key in obj) {//遍历obj内部的属性

       console.log('key=' + key + ', value=' + obj[key]);

   }

}

（4）、obj的内置属性和方法

obj.__proto__  //obj的内部属性，有js引擎内部实现

obj.constructor  //obj的内部属性

obj.hasOwnProperty的内置用法：

      alert(obj.hasOwnProperty('name'));

      alert(obj.hasOwnProperty('toString'));

      alert(obj.hasOwnProperty('toStrings'));

          alert (obj.hasOwnProperty('hasOwnProperty'));

二、constructor构造函数

1、javascript中，任何一个函数，都是可以作为构造函数的。

  2、constructor的返回值

如果存在显示的return时，则返回实际的返回对象，当返回的

是基本数据类型的时候return无效

Function People(name,age) {

    //js引擎隐式执行 this = {};

    this.name = name;

    this.age = age;

    //js引擎隐式执行 return this;

}

3、用new时生成一个对象时，js引擎首先帮我们生成一个空的对象obj，然后调用People.call(obj,args...)

var p1 = new People("who",100);

alert(typeof p1);            //Object

alert( pl instanceof People);   //true

alert(p1 instanceof Object);   //true

alert(p1.constructor);        //People

alert(p1.toString);           //[native code]

alert(p1.toString());          //[object Object]

三、原型和原型链

1、原型的作用：

（1）、防止多个对象重复定义函数

           function People(name, age){

                      this.name = name;

                      this.age = age;

                      this.show = function(){

                            alert('my name is ' + this.name  + ", my age is " + this.age);

                      };

               }

               var p1 = new People("who", 100);

               var p2 = new People("xxx", 40);                

               alert(p1.show == p2.show)  //false

即p1和p2的show方法虽然代码完全一样，但实际上它们

是不相等的。即每new出一个People对象时，就会new出

一个function show,占用内存。解决多个对象重复定义函数可

通过prototype解决，解决方法如下： 

                        People.prototype.show = function(){

                             alert(this.name  + ", my age is " + this.age);

                  };

                      alert(p1.show == p2.show);  //true       

原理如下图：p1和p2中都有一个__proto__的内嵌属性，它们指向的是同一个原型对象。Show方法通过People.prototype.show定义在了这个原型对象内。故此时，p1.show == p2.show

（2）、构成继承关系

function Animal(name){

               this.name = name;

        }

        function Bird(){                   

        }            

        Bird.prototype = new Animal('bird');

        var b1 = new Bird();

        alert(b1.name);

通过Bird.prototype = new Animal('bird');这个语句，就把Bird的

prototype指向了Animal的prototype，这时Bird就拥有了Animal

的属性。具体如下图：

    2、检测某个对象是否拥有某个自声明的属性

      function hasMyOwnProperty(keyName, obj){

             for(var key in obj){

                    if(key == keyName){

                           return true;

                    }

             }

             return false;

        }