javascript原型prototype

每一个函数都有一个原型函数

每创建一个函数 f 的时候，就会生成这个函数对应的prototype对象（函数中有一个指向这个对象的指针）可以向该对象中添加对象和方法，prototype对象中有一个construction属性，指向 f 函数，目的：共享这些方法和属性

构造函数.prototype=原型对象

原型对象.constructor=构造函数

实力对象的prototype指针指向=原型对象

原型对象。isPrototypeOf（实力对象）  判断

Object.getPrototypeOf(实力对象)     返回原型对象

每读取一个对象属性时，先搜索实例对象，有就返回，没有的话再在原型对象中搜索，都没有返回undifined

判断属性是实例的，hasOwnProperty（‘name’）

in操作符：alert（’name‘ in p1）判断p1中是否有name属性，不区分在实例里还是原型里 

Object.keys()  返回一个对象的所有属性，放在一个数组中

Object.getOwnPropertyNames  返回一个对象的所有属性，放在一个数组中，把不可枚举的constructor也列出

给原型对象重置构造方法 Object.defineProperty()

简单原型：

function Person () {
             
           } 
           Person.prototype={
           //    constructor:Person,
               name:'Mary',
               age:12,
               job:'程序员',
               sayHello:function(){alert('hello');}
           };

应该先创建原型，再实例化。

原型的弊端：方法属性被所有对象共享。正因为共性的特性，导致存在很大的问题

我们一般组合使用构造函数式和原型模式。

function Person(name,age){
             this.name=name;
             this.age=age;
             
         }
         Person.prototype={
             sayName:function(){
                 alert(this.name);
             }
         };
         var p1=new Person('z4',12);
         p1.sayName();          //z4
         var p2=new Person('w5',12);
         p2.sayName();        //w5

动态原型方法

function Person(name,age){
             this.name=name;
             this.age=age;
             if(typeof this.sayName!='function'){
                  Person.prototype.sayName=function(){
                      alert(this.name);   
                  };       
             }
        }

稳妥构造函数式，没有公共属性，不能使用this对象

function Person(name,age,sex){
           var obj=new Object();
           var name=name;
           var age=age;
           var sex=sex;
           obj.sayName=function () {
               
             alert(name);
           } ;
           return obj;         
       }
       var obj=new Person('z4',12,'男');
       obj.sayName();