Class

Class

简介

类的由来

JavaScript 语言中，生成实例对象的传统方法是通过构造函数。下面是一个例子

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

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

var p = new Point(1, 2);

上面这种写法跟传统的面向对象语言（比如 C++ 和 Java）差异很大，ES6 提供了更接近传统语言的写法，引入了 Class（类）这个概念，作为对象的模板，通过class关键字，可以定义类

基本上，ES6 的class可以看作只是一个语法糖，它的绝大部分功能，ES5 都可以做到，新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。上面的代码用 ES6 的class改写，就是下面这样

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

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

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

定义“类”的方法的时候，前面不需要加上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属性上面

lass 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(){}
});

prototype对象的constructor属性，直接指向“类”的本身

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

类的内部所有定义的方法，都是不可枚举的（non-enumerable

class Point {
      constructor(x, y) {
            // ...
      }

      toString() {
            // ...
      }
}

Object.keys(Point.prototype)
    // []
Object.getOwnPropertyNames(Point.prototype)
    // ["constructor","toString"]

上面代码中，toString方法是Point类内部定义的方法，它是不可枚举的。这一点与 ES5 的行为不一致

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

Point.prototype.toString = function() {
    // ...
};

Object.keys(Point.prototype)
    // ["toString"]
Object.getOwnPropertyNames(Point.prototype)
    // ["constructor","toString"]

上面代码采用 ES5 的写法，toString方法就是可枚举的

constructor 方法

constructor方法是类的默认方法，通过new命令生成对象实例时，自动调用该方法。一个类必须有constructor方法，如果没有显式定义，一个空的constructor方法会被默认添加

class Point { }
// 等同于
class Point {
    constructor() {}
}

constructor方法默认返回实例对象（即this），完全可以指定返回另外一个对象

class Foo {
      constructor() {
            return Object.create(null);
      }
}

new Foo() instanceof Foo
// false

上面代码中，constructor函数返回一个全新的对象，结果导致实例对象不是Foo类的实例

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

class Foo {
      constructor() {
            return Object.create(null);
      }
}

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

实例的属性除非显式定义在其本身（即定义在this对象上），否则都是定义在原型上（即定义在class上）

//定义类
class Point {

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

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

}

var point = new Point(2, 3);

point.toString()    // (2, 3)

point.hasOwnProperty('x')   // true
point.hasOwnProperty('y')   // true
point.hasOwnProperty('toString')    // false
point.__proto__.hasOwnProperty('toString')  // true

上面代码中，x和y都是实例对象point自身的属性（因为定义在this变量上），所以hasOwnProperty方法返回true，而toString是原型对象的属性（因为定义在Point类上），所以hasOwnProperty方法返回false

类的所有实例共享一个原型对象

var p1 = new Point(2,3);
var p2 = new Point(3,2);

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

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

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

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__属性改写原型，必须相当谨慎，不推荐使用，因为这会改变“类”的原始定义，影响到所有实例

取值函数（getter）和存值函数（settter）

在“类”的内部可以使用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'

值函数和取值函数是设置在属性的 Descriptor 对象上的

需要注意的是 set 函数必须带参数，而 get 函数则不需要参数

属性表达式

类的属性名，可以采用表达式

let methodName = 'getArea';

class Square {
      constructor(length) {
            // ...
      }

      [methodName]() {
            // ...
      }
}

上面代码中，Square类的方法名getArea，是从表达式得到的

静态方法

类相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前，加上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类的实例上调用。如果在实例上调用静态方法，会抛出一个错误，表示不存在该方法

注意，如果静态方法包含this关键字，这个this指的是类，而不是实例

class Foo {
      static bar() {
            this.baz();
      }
      static baz() {
            console.log('hello');
      }
      baz() {
            console.log('world');
      }
}

Foo.bar()   // hello

上面代码中，静态方法bar调用了this.baz，这里的this指的是Foo类，而不是Foo的实例，等同于调用Foo.baz。另外，从这个例子还可以看出，静态方法可以与非静态方法重名

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

class Foo {
      static classMethod() {
            return 'hello';
      }
}

class Bar extends Foo {}

Bar.classMethod()   // 'hello'

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

静态方法也是可以从super对象上调用的

class Foo {
      static classMethod() {
         return 'hello';
      }
}

class Bar extends Foo {
      static classMethod() {
            return super.classMethod() + ', too';
      }
}

Bar.classMethod()   // "hello, too"

静态属性

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

class Foo {}

Foo.prop = 1;
Foo.prop        // 1

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

目前，只有这种写法可行，因为 ES6 明确规定，Class 内部只有静态方法，没有静态属性。现在有一个提案提供了类的静态属性，写法是在实例属性法的前面，加上static关键字

class MyClass {
      static myStaticProp = 42;

      constructor() {
            console.log(MyClass.myStaticProp);  // 42
      }
}

这个新写法大大方便了静态属性的表达

// 老写法
class Foo {
    // ...
}
Foo.prop = 1;

// 新写法
class Foo {
    static prop = 1;
}

上面代码中，老写法的静态属性定义在类的外部。整个类生成以后，再生成静态属性。这样让人很容易忽略这个静态属性，也不符合相关代码应该放在一起的代码组织原则。另外，新写法是显式声明（declarative），而不是赋值处理，语义更好

实例属性的新写法

实例属性除了定义在constructor()方法里面的this上面，也可以定义在类的最顶层

class IncreasingCounter {
      constructor() {
            this._count = 0;
      }
      get value() {
            console.log('Getting the current value!');
            return this._count;
      }
      increment() {
            this._count++;
      }
}

上面代码中，实例属性this._count定义在constructor()方法里面，另一种写法是，这个属性也可以定义在类的最顶层，其他都不变

class IncreasingCounter {
      _count = 0;
      get value() {
            console.log('Getting the current value!');
            return this._count;
      }
      increment() {
            this._count++;
      }
}

上面代码中，实例属性_count与取值函数value()和increment()方法，处于同一个层级，这时，不需要在实例属性前面加上this

这种新写法的好处是，所有实例对象自身的属性都定义在类的头部，看上去比较整齐，一眼就能看出这个类有哪些实例属性

class foo {
      bar = 'hello';
      baz = 'world';

      constructor() {
            // ...
      }
}

上面的代码，一眼就能看出，foo类有两个实例属性，一目了然。另外，写起来也比较简洁

私有方法和私有属性

现有的解决方法

私有方法和私有属性，是只能在类的内部访问的方法和属性，外部不能访问，这是常见需求，有利于代码的封装，但 ES6 不提供，只能通过变通方法模拟实现

一种做法是在命名上加以区别

class Widget {

      // 公有方法
      foo (baz) {
            this._bar(baz);
      }

      // 私有方法
      _bar(baz) {
            return this.snaf = baz;
      }

        // ...
}

上面代码中，_bar方法前面的下划线，表示这是一个只限于内部使用的私有方法，但是，这种命名是不保险的，在类的外部，还是可以调用到这个方法

另一种方法就是索性将私有方法移出模块，因为模块内部的所有方法都是对外可见的

class Widget {
      foo (baz) {
        bar.call(this, baz);
      }
      // ...
}

function bar(baz) {
    return this.snaf = baz;
}

上面代码中，foo是公开方法，内部调用了bar.call(this, baz)，这使得bar实际上成为了当前模块的私有方法

还有一种方法是利用Symbol值的唯一性，将私有方法的名字命名为一个Symbol值

const bar = Symbol('bar');
const snaf = Symbol('snaf');

export default class myClass{
      // 公有方法
      foo(baz) {
            this[bar](baz);
      }

      // 私有方法
      [bar](baz) {
            return this[snaf] = baz;
      }
      // ...
};

上面代码中，bar和snaf都是Symbol值，一般情况下无法获取到它们，因此达到了私有方法和私有属性的效果。但是也不是绝对不行，Reflect.ownKeys()依然可以拿到它们

const inst = new myClass();

Reflect.ownKeys(myClass.prototype)
    // [ 'constructor', 'foo', Symbol(bar) ]

上面代码中，Symbol 值的属性名依然可以从类的外部拿到

私有属性的提案

目前，有一个提案，为class加了私有属性。方法是在属性名之前，使用#表示

class IncreasingCounter {
      #count = 0;
      get value() {
            console.log('Getting the current value!');
            return this.#count;
      }
      increment() {
            this.#count++;
      }
}

上面代码中，#count就是私有属性，只能在类的内部使用（this.#count），如果在类的外部使用，就会报错

const counter = new IncreasingCounter();
counter.#count      // 报错
counter.#count = 42     // 报错

上面代码在类的外部，读取私有属性，就会报错

下面是另一个例子

class Point {
      #x;
      constructor(x = 0) {
            this.#x = +x;
      }

      get x() {
            return this.#x;
      }

      set x(value) {
            this.#x = +value;
      }
}

上面代码中，#x就是私有属性，在Point类之外是读取不到这个属性的。由于井号#是属性名的一部分，使用时必须带有#一起使用，所以#x和x是两个不同的属性

之所以要引入一个新的前缀#表示私有属性，而没有采用private关键字，是因为 JavaScript 是一门动态语言，没有类型声明，使用独立的符号似乎是唯一的比较方便可靠的方法，能够准确地区分一种属性是否为私有属性。另外，Ruby 语言使用@表示私有属性，ES6 没有用这个符号而使用#，是因为@已经被留给了 Decorator

这种写法不仅可以写私有属性，还可以用来写私有方法

class Foo {
      #a;
      #b;
      constructor(a, b) {
            this.#a = a;
            this.#b = b;
      }
      #sum() {
            return #a + #b;
      }
      printSum() {
            console.log(this.#sum());
      }
}

实例属性

实例属性除了定义在constructor()方法里面的this上面，也可以定义在类的最顶层。