prototype
prototype是什么？
开始最浅显的理解是：JS对象中的一个内置属性，是对其他对象的引用，初始设置是非空（是么？）
有什么用呢？
假设访问objA当中的属性a，objA.a。如果objA本身并没有属性A，那么就会沿着A的prototype链继续访问。
尽头在哪里？所有一般的prototype最终都会指向Object.prototype对象。
举个栗子🌰：
var objA = { a: 2 };
var objB = Object.create(objA);
console.log(objB.a) //2
这里面，objB本身并没有a这个属性，但是create这个方法把objB的prototype指向了objA，而objA是有a这个属性的，因此能够得到访问。
（使用for in 和 in的原理是原型链访问）
给对象设置属性到底经历了什么？
如：myObject.foo = “bar”;
- 如果myObject本身具有属性foo，改变它的值为bar;
- 如果myObject本身没有属性foo，并且遍历它的prototype链上依旧没有，那么创建一个foo属性给myObject，并赋值为bar;
- 如果myObject本身没有属性foo，但是prototype链上有foo这个属性，还有分三种情况：
该foo没有被标记为只读，那么直接在myObject添加新的属性foo，屏蔽了原型链上的foo
该foo被标记为了只读，严格模式下抛出错误，非严格模式下忽略
该foo是个setter，foo不会被添加，也不会被重新定义。
内省：检查一个实例的继承祖先
instanceof
var a = new Foo();
a instanceof Foo;
//true
这里面instanceof回答的问题是：a 的整条prototype链上是否有指向Foo.prototype的对象。
isPrototypeOf
Foo.prototype.isPrototypeOf(a); // true
isPrototypeOf回答的问题是：a的整条prototype链上是否出现过Foo.prototype。
关于“类”和“行为委托”的区分和比较：
类怎么用
定义一个父类，属性+事件都准备好，再定义子类，在父类的基础上特殊化，实际上每个子类特殊化之后都是一个实例，直接操作即可。
class Task {
id;
// 构造函数Task()
Task(ID) { id = ID; }
outputTask() { output( id ); }
}
class XYZ inherits Task {
label;
// 构造函数XYZ()
XYZ(ID,Label) {
super( ID );
label = Label;
}
outputTask() {
super();
output( label );
}
}
class ABC inherits Task {// ...}
行为委托是什么概念
实现一个完整的对象实例不需要一层层去继承，而是由若干个没有关联的对象
去协作“组成”，组成的过程就是关联的过程，也就是行为委托。
Task = {
setID: function(ID) {
this.id = ID;
},
outputID: function() {
console.log( this.id );
}
};
// 让XYZ委托Task
XYZ = Object.create( Task );
XYZ.prepareTask = function(ID,Label) {
this.setID( ID );
this.label = Label;
};
XYZ.outputTaskDetails = function() {
this.outputID();
console.log( this.label );
};
// ABC = Object.create( Task );
// ABC ... = ...”
在上面的代码中，Task和XYZ并不是类或是函数，他们是对象。XYZ通过Object.create( Task )来创建，也就是它的prototype委托了Task对象。
这种委托的行为意味着当在当前对象上找不到某属性或方法时，会把这个请求委托给另外的对象。
区别：
类中体现重写（多态）的优势，而行为委托则相反：避免在prototype上不同的级别中使用相同的命名。
function Foo(who) {
this.me = who;
}
Foo.prototype.identify = function() {
return "I am " + this.me;
};
function Bar(who) {
Foo.call( this, who );
}
Bar.prototype = Object.create( Foo.prototype );
Bar.prototype.speak = function() {
alert( "Hello, " + this.identify() + "." );
};
var b1 = new Bar( "b1" );
var b2 = new Bar( "b2" );
b1.speak();
b2.speak();
面向对象的机制：
Paste_Image.png
———————————————华丽丽分割，讲一下原型链————————————————
Paste_Image.png
Paste_Image.png
每个用function声明（或定义）的对象都会“与生俱来”带有.prototype这个属性，.prototype本身是一个object，
它“与生俱来”又包含两个属性：constructor和__proto__
constructor指向函数本身；
proto又是一个object,里面包含一堆object共有的乱糟糟
Paste_Image.png
这个时候给a的prototype上加一个function，好了，identify这个东西本身是一个function，所以它依然“与生俱来”带有自己的prototype(还有俩崽儿：constructor和proto)
而这个时候a的prototype上除了俩亲崽儿之后就多了identify这个捡来的三儿子。
Paste_Image.png
Paste_Image.png
Paste_Image.png
同样的，identify自己的prototype上的两个崽儿constructor和proto的指向都随它爹。
再来看b
Paste_Image.png
Paste_Image.png
b 本身是一个函数，原本他自己的prototype带俩崽儿 ，把人家的俩崽儿扔掉了，换成了a.prototype，所以a.prototype的崽儿们从此多了一个爹，就是b的prototype。访问identify的时候，用a还是用b就是一模一样的了。
var b1 = new b(“mine”);
Paste_Image.png
Paste_Image.png
现在用b() new了一个b1，但因为是new出来的，new出来的，new出来的，所以b1除了name之外会被加上一个proto，而这个proto指向他“爹”的prototype,也就是b.prototype，这是规定，fuck the rules。
以上是函数声明的。
如果单纯是一个对象的话：恭喜它，它没有prototype，只有一个proto，直面是一堆乱糟糟，毕竟人家是个对象，是对象就会有那一堆乱糟糟。
Paste_Image.png
———————————————华丽丽分割，讲一下原型链end————————————————
而行为委托的代码是这么写的（对象、对象、都是对象，自始至终都没有.prototype的出现）：
Foo = {
init: function(who) {
this.me = who;
},
identify: function() {
return "I am " + this.me;
}
};
Bar = Object.create( Foo );//委托
Bar.speak = function() {
alert( "Hello, " + this.identify() + "." );
};
var b1 = Object.create( Bar );//委托
b1.init( "b1" );
var b2 = Object.create( Bar );//委托
b2.init( "b2" );
b1.speak();
b2.speak();
行为委托的机制：
Paste_Image.png
