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”;

1. 如果myObject本身具有属性foo，改变它的值为bar;
2. 如果myObject本身没有属性foo，并且遍历它的prototype链上依旧没有，那么创建一个foo属性给myObject，并赋值为bar;
3. 如果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

以上是函数声明的。
如果单纯是一个对象的话：恭喜它，它没有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