【javascript笔记】关于函数的构造函数和prototype

一,构造函数创建对象

function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
this.getName=function(){
return this.name;
}
this.getAge=function(){
return this.age
}
this.getJob=function(){
return this.job;
}
}

//请看这里 咱们新建一个对象
var person1=new Person('nicolas',29,'software engineer');
var person2=new Person('jack',29,'software engineer');
person1.getName(); //	nicolas
person2.getName();// jack

到此为止 咱们做一个实验：alert(person1.sayName==person2.sayName) //输出为false.

不是同一个函数对象这似乎和许多强类型语言 比如java和c#类似 声明类的属性 然后设置getset方法去调用

但是 为每一个对象都去初始化这样 “执行同一个动作”的函数对象 是否合乎情理呢，这样我们就自然而然想到了j

ava中的静态关键字，

我们姑且可以将prototype理解为静态的成员或者方法，new的对象是共享的，这样我们就会节约内存？

二,再来看原型模式创建对象

function Person(){
}
Person.prototype.name='nicolas';
Person.prototype.age=29;
Person.prototype.job='software engineer';
Person.prototype.sayName=function(){
return this.name
}

//请看这了 咱们还是新建两个对象
var person1=new Person();
var person2=new Person();
person1.getName();//nicolas
person2.getName();//nicolas</span>

到此为止，咱们仍旧做这个同上的实验 alert(person1.sayName==person2.SayName);//输出为true，是同一个对象重点（理解不到也没关系,楼主也是有点晕）构造函数，原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针 ，而每个实力都包含一个指向原型对象的内部指针。现在我们以第二个声明函数的方式来做个例子：

var person1=new Person();
var person2=new Person();
person1.name="Jack";
alert(person1.name);//Jack
alert(person2.name);//nicolas

这时候大家就会奇怪，不是说原型里面都是共享的吗？为什么person2输出的还是原型设置的nicolas 而不是Jack;请注意：这里我们为person1的name设置了新的值后； "如果我们在实例中添加了一个属性，并且该属性与实例原型中的一个实例重名 ，那我们就是在实例中创建了该属性，换句话说就是：person1.name='Jack';这一句代码表示了这个name是属于实例的属性.它会阻止我们去访问实例的原型中的nicolas";当然我们也可以通过代码delete
person1.name; 去删除person1.name这个实例属性，执行了这局代码后：

alert(person1.name);//nicolas 原型属性

javascript里面有很多判断属性是属于实例或者原型的，请大家自行搜索。

三,更加简单的原型语法:以字面量形式创建原型对象

function Person(){ }
Person.prototype={
name:"nicolas",
age:29,
job:"software engineer",
getName:function(){
return this.name;
}
}</span>

第二大点中说过，每创建一个函数就会同时创建他的prototype对象，这个对象也会自动获得constructor属性（指向构造函数的指针）；但是这里constructor属性不再指向Person了，这里我们使用的字面量声明方式本质上完全重写了默认的prototype对象，指向构造函数的指针不会指向原来Person，而是Object.

//如果原型指向构造函数的指针真的这么重要,请像下面这样声明：
function Person(){ }
Person.prototype={
constructor:Person,
name:"nicolas",
age:29,
job:"software engineer",
getName:function(){
return this.name;
}

}

//但是这种方式重新设置constructor属性会导致它的[Enumerable]属性设置为true.默认情况下原生的constructor属性是不可枚举的,
//因此如果你是用兼容ECMAScript5的javascript引擎 请像下面这样声明：

function Person(){ }
Person.prototype={
name:"nicolas",
age:29,
job:"software engineer",
getName:function(){
return this.name;
}

}
Object.defineProperty(Person.prototype,"constructor",{
enumerable:false,
value:Person
})

四， 在第三点中提到了用表达式方式声明prototype会或重写默认的prototype对象，这就引出了这一个话题:原型的动态性

<span style="font-size:12px;"> var friend=new Person();
Person.prototype.sayHello=function(){
alert('Hello~')
}
friend.sayHello();//不会报错

//但是 若是这样
function Person(){}
var friend=new Person();
Person.prototype={
...something
sayHello:function(){
alert('Hello~')
}
}
friend.sayHello();//error</span>

用表达式这种方法添加sayHello()，重写了整个prototype 但是当下的friend对象仍然是指向原来的原型，当我们原型整个修改就相当于把原型修改为另外一个对象了，切断了构造函数与最初原型之间的联系。请记住 实例中的指针仅仅指向原型，而不指向构造函数。 相当于当前friend指向的原型 和我们重新写的没有任何关系~

五,原型存在的问题

最重要的问题就是 共享的属性若是引用类型,只要任何实例一改动，原型里面的内容也会改动;

function Person(){}
Person.prototype={
name:"nicolas",
job:'software engineer',
age;29,
friends:['sheldon','Lenard']
};
var person1=new Person();
var person2=new Person();

person1.friends.push('Nianlu');
alert(person1.friends);// sheldon,Lenard,Nianlu
alert(person2.friends);// sheldon,Lenard,Nianlu

//再看，他们引用的是否是同一个数组
alert(person1.friends==person2.friends) //true

六,组合使用构造函数和原型模式

//既然两种模式各有优缺点,我们就把两者结合到一起，请看下面的例子
function Person(name,job,age){
this.name=name;
this.job=job;
this.age=age;
this.friends=['Sheldon','Lenard'];
}
Person.prototype={
constructor:Person,
sayHello:function(){
alert('Hello~');
}
}
var person1=new Person('nicolas','software engineer',29);
var person1=new Person('jack','software engineer',29);
person1.friends.push('Kimkadasion');

alert(person1.friends);// sheldon,Lenard,Kimkadasion
alert(person2.friends);// sheldon,Lenard

alert(person1.friends==person2.friends) //false
alert(person1.sayHello==person2.sayHello) //true

结束~