关于构造函数和原型的实验笔记

关于构造函数，我想到一个比方。b 本是B生的，但是B断绝了和他的母子关系， A无子女，决定领养b,于是A就成了b的继母，也就是b法律上的妈妈。你问b的妈妈叫什么, 就相当于问b的构造函数是谁。这种关系很容易改变，立个什么字据或证明就可以了。 而原型就相当于是b身上的基因，这是领养这种关系改变不了的，属于先天得到的。 除非把它的基因都给改了，那时自然也就验出B是它的亲妈了。

//学校
function School (name) {
this.name = name;
this.teachers = [];
this.level = function(){
console.log('University')
}
}

//添加到原型上的属性
School.prototype.students = [];

//学校功能--介绍
School.prototype.show = function(){
console.log(this.name+':很棒的学校！')
this.teachers.forEach(function(teach){
console.log(this.name + '-' + teach);
})
}

//学校功能---招聘老师
School.prototype.recruit = function(name){
this.teachers.push(name);
}

//学校功能---招生
School.prototype.enroll = function(name){
this.students.push(name);
}

//通过构造函数的方式创建对象
var ts = new School('Tsinghua University');//此时School就是ts的构造函数
var bj = new School('Beijin University');//此时School就是bj的构造函数

//通过构造函数创建的对象，注意两个问题
//1 构造函数内的属性和方法是不被共享的
//2 原型上的属性和方法是共享的
ts.recruit('frog');  // frog 是ts这个学校的老师
bj.recruit('Aaron'); // Aaron 是bj这个学校的老师

ts.show(); // frog只出现在ts中
bj.show(); //Aaron只出现在bj中

//说明构造函数内声明的属性不被共享
console.log(bj.teachers === ts.teachers); // false
//说明构造函数内声明的方法不被共享
console.log(bj.level === ts.level);//false;

//说明teachers放在构造函数内是对的，各学校的老师互不影响

ts.enroll('Tom'); //只给ts学校招生
console.log(bj.students) //ts学校没有招生，也有这个学生了

bj.enroll('Jek');
console.log(ts.students) //bj学校招的学生，在ts也有

//说明原型上的方法是共享的
console.log(bj.enroll === ts.enroll) // true
//说明原型上的属性是共享的
console.log(bj.students === ts.students) // true;

//小结： 方法尽量写在原型上，可以节省资源，引用类型的属性尽量写在构造函数内，避免污染;

//构造函数的问题
function A(){
this.name = 'A';
}

function B(){
this.name = 'B';
}

var a = new A;
console.log(a.constructor===A) // true

//用A的实例对象替换B的原型对象
B.prototype = new A;
var b = new B;

console.log(b.constructor===B) // false
console.log(b.constructor===A) // true
//说明重写原型对象会产生构造函数指向的问题
//修正构造函数为B
B.prototype.constructor = B;
console.log(b.constructor===B) //true
//constructor是挂在prototype上的，重写prototype，也会自动改写constructor

console.log(b.isPrototypeOf(B)) //false;
console.log(Object.getPrototypeOf(b)) // A
//修正contructor也改变不了prototype的引用关系

//这种写法也会产生B的构造函数指向有问题
B.prototype = {
//...
}

//推荐这样写
A.prototype.getName = function(){
console.log(this.name);
}

function C(){
this.name = 'C';
}
C.prototype.getAge= function(){
console.log('c age 18')
}

var c = new C;
//只改变构造函数
C.prototype.constructor = A;
console.log(Object.getPrototypeOf(c)) // A
console.log(c.isPrototypeOf(C)) // false
console.log(c.isPrototypeOf(A)) // false
console.log(c) //C;
//c.getName(); // undefined
c.getAge(); //c age 18

//小结： 只要改变了对象的原型，那么它的造函数就会自动改变，
//只改变构造函数的指向，原型的判断不准确了，但是没有被改写。