prototype详解

每个函数都有一个prototype属性，这个属性是指向一个对象的引用，这个对象称为原型对象，原型对象包含函数实例共享的方法和属性。

 

在函数内定义的变量和函数如果不对外提供接口，那么外部将无法访问到，也就是变为私有变量和私有函数。

function Obj(){
                var a=0; //私有变量
                var fn=function(){ //私有函数
                    
                }
            }

这样在函数对象Obj外部无法访问变量a和函数fn，它们就变成私有的，只能在Obj内部使用，即使是函数Obj的实例仍然无法访问这些变量和函数

var o=new Obj();
            alert(o.a); //undefined
            alert(o.fn); //undefined

 

当定义一个函数后通过 “.”为其添加的属性和函数，通过对象本身仍然可以访问得到，但是其实例却访问不到，这样的变量和函数分别被称为静态变量和静态函数

function Obj(){
               
            }
           
            Obj.a=0; //静态变量
           
            Obj.fn=function(){ //静态函数
                   
            }
            
            alert(Obj.a); //0
            alert(typeof Obj.fn); //function
           
            var o=new Obj();
            alert(o.a); //undefined
            alert(typeof o.fn); //undefined

在面向对象编程中除了一些库函数我们还是希望在对象定义的时候同时定义一些属性和方法，实例化后可以访问，JavaScript也能做到这样

function Obj(){
                this.a=[]; //实例变量
                this.fn=function(){ //实例方法
                   
                }
            }
           
            console.log(typeof Obj.a); //undefined
            console.log(typeof Obj.fn); //undefined
           
            var o=new Obj();
            console.log(typeof o.a); //object
            console.log(typeof o.fn); //function

达到目的后，又有另外的问题：

function Obj(){
                this.a=[]; //实例变量
                this.fn=function(){ //实例方法
                   
                }
            }
           
            var o1=new Obj();
            o1.a.push(1);
            o1.fn={};
            console.log(o1.a); //[1]
            console.log(typeof o1.fn); //object
            var o2=new Obj();
            console.log(o2.a); //[]
            console.log(typeof o2.fn); //function

在o1中修改了a和fn，而在o2中没有改变，由于数组和函数都是对象，是引用类型，这就说明o1中的属性和方法与o2中的属性与方法虽然同名但却不是一个引用，而是对Obj对象定义的属性和方法的一个复制。

这个对属性来说没有什么问题，但是对于方法来说问题就很大了，因为方法都是在做完全一样的功能，但是却又两份复制，如果一个函数对象有上千和实例方法，那么它的每个实例都要保持一份上千个方法的复制，这显然是不科学的，这可怎么办呢，prototype应运而生。

 

无论什么时候，只要创建了一个新函数，就会根据一组特定的规则为该函数创建一个prototype属性，默认情况下prototype属性会默认获得一个constructor(构造函数)属性，这个属性是一个指向prototype属性所在函数的指针

function Person(name){
                this.name=name;
            }
           
            Person.prototype.share=[];
           
            Person.prototype.printName=function(){
                alert(this.name);
            }
           
            var person1=new Person('Byron');
            var person2=new Person('Frank');
           
            person1.share.push(1);
            person2.share.push(2);
            console.log(person2.share); //[1,2]

 

如果在实例中定义如prototype同名的属性或函数，则会覆盖prototype的属性或函数

function Person(name){
                this.name=name;
            }
            
            Person.prototype.share=[];

            var person=new Person('Byron');
            person.share=0;
            
            console.log(person.share); //0而不是prototype中的[]