JS6-Class

Posted 2020-10-03 YC小杨

====Class(类)

Js中，生成实例对象的传统方法是通过构造函数

function Point(x, y) {

  this.x = x;

  this.y = y;

}

var p = new Point(1, 2);

上面这种写法跟传统的面向对象语言（比如 C++ 和 Java）差异很大

 

ES6 提供了更接近传统语言的写法，引入了 Class（类）这个概念，作为对象的模板。通过class关键字，可以定义类。

 

//定义类

class Point {

  constructor(x, y) {

    this.x = x;

    this.y = y;

  }

 

  toString() {

    return ‘(‘ + this.x + ‘, ‘ + this.y + ‘)‘;

  }

}

//创建对象

var p=new Point(1,2)

console.log(p.x)

上面代码定义了一个“类”，可以看到里面有一个constructor方法，这就是构造方法，而this关键字则代表实例对象。也就是说，ES5 的构造函数Point，对应 ES6 的Point类的构造方法。

 

Point类除了构造方法，还定义了一个toString方法。注意，定义“类”的方法的时候，前面不需要加上function这个关键字，直接把函数定义放进去了就可以了。另外，方法之间不需要逗号分隔，加了会报错。

 

ES6 的类，完全可以看作构造函数的另一种写法。

 

class Point {

  // ...

}

 

typeof Point // "function"

Point === Point.prototype.constructor // true

上面代码表明，类的数据类型就是函数，类本身就指向构造函数。

 

使用的时候，也是直接对类使用new命令，跟构造函数的用法完全一致。

class Bar {

  doStuff() {

    console.log(‘stuff‘);

  }

}

var b = new Bar();

b.doStuff() // "stuff"

 

 

 

 

 

 

构造函数的prototype属性，在 ES6 的“类”上面继续存在。事实上，类的所有方法都定义在类的prototype属性上面。

 

class Point {

  constructor() {

    // ...

  }

 

  toString() {

    // ...

  }

 

  toValue() {

    // ...

  }

}

 

// 等同于

 

Point.prototype = {

  constructor() {},

  toString() {},

  toValue() {},

};

在类的实例上面调用方法，其实就是调用原型上的方法。

class B {}

let b = new B();

b.constructor === B.prototype.constructor // true

上面代码中，b是B类的实例，它的constructor方法就是B类原型的constructor方法。

 

由于类的方法都定义在prototype对象上面，所以类的新方法可以添加在prototype对象上面。Object.assign方法可以很方便地一次向类添加多个方法。

class Point {

  constructor(){

    // ...

  }

}

 

Object.assign(Point.prototype, {

  toString(){},

  toValue(){}

});

 

 

类必须使用new调用，否则会报错。这是它跟普通构造函数的一个主要区别，ES5不用new也可以执行。

class Foo {

  constructor() {

    return 666;

  }

}

Foo()// TypeError: Class constructor Foo cannot be invoked without ‘new‘

 

类的实例对象

生成类的实例对象的写法，与 ES5 完全一样，也是使用new命令。如果忘记加上new，像函数那样调用Class，将会报错。

 

class Point {

  // ...

}

// 报错

var point = Point(2, 3);

// 正确

var point = new Point(2, 3);

 

 

与 ES5 一样，类的所有实例共享一个原型对象。

var p1 = new Point(2,3);

var p2 = new Point(3,2);

p1.__proto__ === p2.__proto__//true

上面代码中，p1和p2都是Point的实例，它们的原型都是Point.prototype，所以__proto__属性是相等的。

 

这也意味着，可以通过实例的__proto__属性为“类”添加方法。

 

__proto__ 并不是语言本身的特性，这是各大厂商具体实现时添加的私有属性，虽然目前很多现代浏览器的JS引擎中都提供了这个属性，但不建议在生产中使用该属性:

var p1 = new Point(2,3);

var p2 = new Point(3,2);

 

p1.__proto__.printName = function () { return ‘Oops‘ };

 

p1.printName() // "Oops"

p2.printName() // "Oops"

 

var p3 = new Point(4,2);

p3.printName() // "Oops"

上面代码在p1的原型上添加了一个printName方法，由于p1的原型就是p2的原型，因此p2也可以调用这个方法。而且，此后新建的实例p3也可以调用这个方法。这意味着，使用实例的__proto__属性改写原型，必须相当谨慎，不推荐使用，因为这会改变“类”的原始定义，影响到所有实例。

 

Class 表达式

与函数一样，类也可以使用表达式的形式定义。

const MyClass = class Me {

  getClassName() {

    return Me.name;

  }

};

上面代码使用表达式定义了一个类。需要注意的是，这个类的名字是MyClass而不是Me，Me只在 Class 的内部代码可用，指代当前类。

let inst = new MyClass();

Me.name // ReferenceError: Me is not defined

上面代码表示，Me只在 Class 内部有定义。

 

类也可以写成下面的表达式形式。

const MyClass = class {  };

 

采用 Class 表达式，可以写出立即执行的 Class。

let person = new class {

  constructor(name) {

    this.name = name;

  }

 

  sayName() {

    console.log(this.name);

  }

}(‘张三‘);

person.sayName(); // "张三"

上面代码中，person是一个立即执行的类的实例。

 

不存在变量提升

类不存在变量提升，与 ES5 完全不同。

 

new Foo(); // ReferenceError

class Foo {}

上面代码中，Foo类使用在前，定义在后，这样会报错，因为 ES6 不会把类的声明提升到代码头部。这种规定的原因与继承有关，必须保证子类在父类之后定义。

{

  let Foo = class {};

  class Bar extends Foo {

  }

}

上面的代码不会报错，因为Bar继承Foo的时候，Foo已经有定义了。但是，如果存在class的提升，上面代码就会报错，因为class会被提升到代码头部，而let命令是不提升的，所以导致Bar继承Foo的时候，Foo还没有定义。

 

 

this 的指向

类的方法内部如果含有this，它默认指向类的实例。但是，必须非常小心，一旦单独使用该方法，很可能报错。

 

class Logger {

  printName(name = ‘there‘) {

    this.print(`Hello ${name}`);

  }

 

  print(text) {

    console.log(text);

  }

}

 

const logger = new Logger();

const { printName } = logger;

printName(); // TypeError: Cannot read property ‘print‘ of undefined

上面代码中，printName方法中的this，默认指向Logger类的实例。但是，如果将这个方法提取出来单独使用，this会指向该方法运行时所在的环境，因为找不到print方法而导致报错。

解决方法:写在构造函数constructor里。

class Logger {

  constructor() {

    this.printName = (name = ‘there‘) => {

      this.print(`Hello ${name}`);

    };

  }

}

 

 

Class 的取值函数（getter）和存值函数（setter）

在“类”的内部可以使用get和set关键字，对某个属性设置存值函数和取值函数，拦截该属性的存取行为。

class MyClass {

  constructor() {

    // ...

  }

  get prop() {

    return ‘getter‘;

  }

  set prop(value) {

    console.log(‘setter: ‘+value);

  }

}

let inst = new MyClass();

inst.prop = 123;// setter: 123

inst.prop// ‘getter‘

上面代码中，prop属性有对应的存值函数和取值函数，因此赋值和读取行为都被自定义了。

 

 

Class 的静态方法

类相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就称为“静态方法”。

class Foo {

  static classMethod() {

    return ‘hello‘;

  }

}

Foo.classMethod() // ‘hello‘

var foo = new Foo();

foo.classMethod()// TypeError: foo.classMethod is not a function

上面代码中，Foo类的classMethod方法前有static关键字，表明该方法是一个静态方法，可以直接在Foo类上调用（Foo.classMethod()），而不是在Foo类的实例上调用。如果在实例上调用静态方法，会抛出一个错误，表示不存在该方法。

 

父类的静态方法，可以被子类继承。

class Foo {

  static classMethod() {

    return ‘hello‘;

  }

}

class Bar extends Foo {

}

 

Bar.classMethod() // ‘hello‘

上面代码中，父类Foo有一个静态方法，子类Bar可以调用这个方法。

 

Class 的静态属性和实例属性

静态属性指的是 Class 本身的属性，即Class.propName，而不是定义在实例对象（this）上的属性。

class Foo {

}

Foo.prop = 1;

Foo.prop // 1

上面的写法为Foo类定义了一个静态属性prop。

目前，只有这种写法可行，因为 ES6 明确规定，Class 内部只有静态方法，没有静态属性。

// 以下两种写法都无效

class Foo {

  // 写法一

  prop: 2

 

  // 写法二

  static prop: 2

}

Foo.prop // undefined

 

目前有一个静态属性的提案，对实例属性和静态属性都规定了新的写法:

类的实例属性

类的实例属性可以用等式，写入类的定义之中。

以前，我们定义实例属性，只能写在类的constructor方法里面。有了新的写法以后，可以不在constructor方法里面定义。

class MyClass {

  myProp = 42;

  constructor() {

    console.log(this.myProp); // 42

  }

}

上面代码中，myProp就是MyClass的实例属性。在MyClass的实例上，可以读取这个属性。

 

这种写法比以前更清晰:

class Person{

  it= {

    count: 3

  };

}

 

为了可读性的目的，对于那些在constructor里面已经定义的实例属性，新写法允许直接列出:

class Person{

  state;

  constructor() {

     this.state = {

      count: 0

    };

  }

}

 

类的静态属性

类的静态属性只要在上面的实例属性写法前面，加上static关键字就可以了。这个新写法大大方便了静态属性的表达。

// 老写法

class Foo {

  // ...

}

Foo.prop = 1;

 

// 新写法

class Foo {

  static prop = 1;

}

上面代码中，老写法的静态属性定义在类的外部。整个类生成以后，再生成静态属性。这样让人很容易忽略这个静态属性，也不符合相关代码应该放在一起的代码组织原则。

 

new.target属性

new是从构造函数生成实例的命令。ES6 为new命令引入了一个new.target属性，该属性一般用在在构造函数之中，返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的，new.target会返回undefined，因此这个属性可以用来确定构造函数是怎么调用的。

function Person(name) {

  if (new.target !== undefined) {

    this.name = name;

  } else {

    throw new Error(‘必须使用new生成实例‘);

  }

}

 

// 另一种写法

function Person(name) {

  if (new.target === Person) {

    this.name = name;

  } else {

    throw new Error(‘必须使用 new 生成实例‘);

  }

}

var person = new Person(‘张三‘); // 正确

var notAPerson = Person(‘张三‘);  // 报错

上面代码确保构造函数只能通过new命令调用。