面向对象与原型

对象的原型

每个对象都含有原型的引用，当查找属性时，若对象本身不具有该属性，则会查找原型上是否有该属性。
对象的原型是内置属性prototype，无法直接访问。
Object.setPrototypeOf(o1,o2)将o2设置为o1的原型。
每个对象可以有一个原型，每个对象的原型也可以拥有一个原型，如此形成原型链。

对象构造器与原型

每个函数都有一个原型对象。
每一个函数的原型都具有一个constructor属性，该属性指向函数本身。
constructor对象的原型设置为新创建的对象的原型。

function Bear(){}
Bear.prototype.eat=()=>console.log('bear is eating!');
const bro=new Bear();
bro.eat();

通过构造函数的原型中constructor属性访问对象的构造器。

function Bear(){}
const bro=new Bear();
const dc=new bro.constructor();
assert(bro instanceof Bear,'bro由Bear构造');
assert(bro.constructor===Bear,'构造函数的引用');
assert(dc instanceof Bear,'dc也由Bear构造');

实现继承

使用Animal的实例作为Bear的原型。

function Animal(){}
Animal.prototype.dance=()=>{};
function Bear(){}
Bear.prototype=new Animal();
const bro=new Bear();
assert(bro instanceof Bear,'bro is a Bear');
assert(bro instanceof Animal,'and a Animal');

使用关键字class

class是语法糖，底层仍然是基于原型的实现。
使用constructor创建构造函数。
使用static来创建静态函数。

class Bear{
  constructor(name){
    this.name=name;
    code();
  }
  eat(){
    console.log('eating...');
  }
  static code(){
    console.log('Bear 1926');
  }
}
var bro=new Bear('bro');

使用extend实现继承。使用super调用基类构造函数。

class Animal{
  constructor(name){
    this.name=name;
  }
  dance(){
    console.log(this.name+' is dancing!')
  }
}
class Bear extends Animal{
  constructor(name,nick){
    super(name);
    this.nick=nick;
  }
}
const bro=new Bear('bro','xhb');
assert(bro instanceof Animal,'bro is Animal!');
bro.dance();