JS学习笔记 - Extends

基本用法

ES6 的class可以看作只是一个语法糖,其本质仍然是构造函数+原型链的组合式继承。
ES6 定义类

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  toString() {
    return '(' + this.x + ', ' + this.y + ')';
  }
}

解析之后，与下面相同

function Point(x, y) {
  this.x = x;
  this.y = y;
}

Point.prototype.toString = function () {
  return '(' + this.x + ', ' + this.y + ')';
};

ES6中有关class的继承方式，引入了extends关键字

例子：

class A {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    getName() {
        return this.name;
    }
}

class B extends A {
    constructor(name, age) {
        super(name, age);
        this.job = "IT";
    }
    getJob() {
        return this.job;
    }
    getNameAndJob() {
        return super.getName() + this.job;
    }
}

var b = new B("Tom", 20);
console.log(b.name);
console.log(b.age);
console.log(b.getName());
console.log(b.getJob());
console.log(b.getNameAndJob());
//输出：Tom，20，Tom，IT，TomIT

重点解析之extends关键字
上面代码定义了一个B类（class），该类通过extends关键字，继承了A类的所有属性和方法。A类中的所有方法默认是添加到B的原型上，所以extends继承的实质仍然是原型链。

测试代码：

console.log("constructor" in b);
console.log("getName" in b); 
console.log(b.hasOwnProperty("getName"));
console.log(b.hasOwnProperty("constructor"));
//输出：true，true，false，false
重点解析之super关键字

super这个关键字，既可以当作函数使用，也可以当作对象使用。
当作函数使用时，super代表父类的构造函数，并在子类中执行Parent.apply(this)，从而将父类实例对象的属性和方法，添加到子类的this上面。以下三点需要特别注意：

1. 子类必须在constructor方法中调用super方法，如果子类没有定义constructor方法，constructor方法以及其内部的super方法会被默认添加。
   测试代码：

class A {
   constructor(name, age) {
       this.name = name;
       this.age = age;
   }
   getName() {
       return this.name;
   }
}

class B extends A {}

var b = new B("Tom", 20);

console.log(b.name);
console.log(b.age);
console.log(b.getName());
console.log(b.hasOwnProperty("name"));
//输出：Tom，20，Tom，true

2. 在子类的constructor方法中，只有调用super之后，才可以使用this关键字，否则会报错。
   测试代码：

class A {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
}

class B extends A {
    constructor(name, age) {
        this.job = "IT";
        super(name, age);
    }
}

var b = new B("Tom", 20)
//输出：报错

3. super()只能用在子类的constructor方法之中，用在其他地方就会报错。
   测试代码：

class A {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
}

class B extends A {
    toStr(name, age) {
        super(name, age)
    }
}

var b = new B("Tom", 20)
//输出：报错

super作为对象时，在子类中指向父类的原型对象。
即super=Parent.prototype。

测试代码：

class A {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    getName() {
        console.log(this.name);
    }
}
A.prototype.n = 2;

class B extends A {
    constructor(name, age) {
        super(name, age);
    }
    toStr() {
        return super.n;
    }
    activeGetName() {
        super.getName();
    }
}

var b = new B("Tom", 20);
console.log(b.toStr());
console.log(b.activeGetName());
//输出：2，Tom

重点解析之静态方法的继承:
在一个方法前加上关键字static，就表示该方法不会被实例继承，但是父类的静态方法，会被子类继承。
例子：

class A {
    static say() {
        console.log("hello");
    }
}

class B extends A {}

console.log(B.say());
//输出：hello

也可以使用super在子类的静态方法中调用父类的静态方法。super在静态方法中指向父类本身，而不是父类的原型对象。
例子：

class A {
    static say() {
        console.log("hello");
    }
}

class B extends A {
    static toStr() {
        super.say();
    }
}
var b = new B();
console.log(B.toStr());
//输出：hello

继承表达式的类

类不但可以继承自其他类，也可以继承表达式。只要表达式可以被解析为一个函数并且通过new关键字可以创建新的实例对象即可。

例子1：
继承传统形式的构造函数

let Obj = function(name) {
    this.name = name;
}
Obj.prototype.getName = function() {
    console.log(this.name);
}

class Person extends Obj {
    constructor(name, age) {
        super(name);
        this.age = age;
    }
}

const p = new Person("Tom", 19);

console.log(p.name); //输出：Tom
console.log(p.age); //输出：19
p.getName(); //输出：Tom

例子2：
继承函数返回结果

let fn = function() {
    return class Person {
        constructor(name) {
            return {
                name
            }
        }
    }
}

class SomeOne extends fn() {
    constructor(name) {
        super(name);
    }
}

let p = new SomeOne("Tom");
console.log(p.name); //输出：Tom

New.target

我们知道，函数内部有一个new.target对象用于判断函数是否通过new关键字调用。类构造函数也可以通过new.target来确定类的调用形式。

例子：

class Obj {
    //new Obj()时，new.target的值为 Obj
    constructor() {
        if (new.target === Obj) {
            console.log("不可以直接调用基类！");
        }
    }
    fn() {
        console.log(this.name);
    }
}

class Person extends Obj {
    //new Person("Tom")时，new.target的值为 Person
    constructor(name) {
        super();
        this.name = name;
    }
}

let p1 = new Person("Tom");
p1.fn(); //输出：Tom
let p2 = new Obj(); //输出：不可以直接调用基类！

*因为类必须通过new关键字调用，所以在类的构造函数中new.target的值永远不会是undefined。

http://www.imooc.com/article/79235