class

//类的定义
class Animal {
    //构造函数
    constructor(name,age) {
        console.log("父构造函数")
        this.name = name||"无";
     }
    //实例方法
     sayName() {
        console.log('My name is '+this.name);
     }
}

//类的继承
class Programmer extends Animal {
    constructor(name) {
        console.log("子构造函数")
        //ES6 要求，子类的构造函数必须执行一次super函数。在这里相当于Animal.prototype.constructor.call(this)。
        super(name) 
    }
    program() {
        console.log("I'm coding...");
    }
}

//测试我们的类
var animal=new Animal('dummy',2)
console.log("---------")
var programmer=new Programmer("zks")
console.log("---------")
programmer.sayName()

验证super内部this指向:
在super()执行时，它指向的是子类B的构造函数，而不是父类A的构造函数。也就是说，super()内部的this指向的是B。

class A {
    constructor() {
        console.log(new.target.name); //new.target指向当前正在执行的函数
    }
}
class B extends A {
    constructor() {
        console.log('-------')
        super();
    }
}
new A() // A
new B() // B

super.x赋值为3，这时等同于对this.x赋值为3。而当读取super.x的时候，读的是A.prototype.x，所以返回undefined。

class A {
 constructor() {
  this.x = 1;
 }
}
class B extends A {
 constructor() {
  super();
  this.x = 2;
  super.x = 3;
  console.log(super.x); // undefined
  console.log(this.x); // 3
 }
}
let b = new B();

class A {
    constructor() {
        this.x = 1;
    }
    s() {
        console.log(this.x);
    }
}
class B extends A {
    constructor() {
      super();
      this.x = 2;
    }
    m() {
        super.s();
    }
}
let b = new B();
b.m() // 2

class A {
 constructor() {
  this.x = 1;
 }
}
class B extends A {
 constructor() {
  super();
  this.x = 2;
  super.x = 3;
  console.log(super.x); // undefined
  console.log(this.x); // 3
 }
}
let b = new B();