Es6 Class

介绍Class

 1:基本上，ES6 的class可以看作只是一个语法糖，它的绝大部分功能，ES5 都可以做到，新的
   class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。
 2:注意，定义“类”的方法的时候，前面不需要加上function这个关键字，直接把函数定义放进去 
  了就可以了。另外，方法之间不需要逗号分隔，加了会报错。

class Point {} typeof Point // "function" Point === Point.prototype.constructor // true

 3:类的数据类型就是函数，类本身就指向构造函数。
 4:类的所有方法都定义在类的prototype属性上面。
 5:由于类的方法都定义在prototype对象上面，所以类的新方法可以添加在prototype对象
  上面Object.assign方法可以很方便地一次向类添加多个方法。
 6:ES6类的内部所有定义的方法，都是不可枚举的（non-enumerable）
   ES5 方法就是可枚举的。
 7:类的属性名，可以采用表达式。

let methodName = 'getArea'; class Square { constructor(length) { // ... } [methodName]() { // ... } }

constructor 方法

8:constructor方法是类的默认方法，通过new命令生成对象实例时，自动调用该方法。
一个类必须有 constructor方法，如果没有显式定义，一个空的constructor方法会被默认添加。
9:constructor方法默认返回实例对象（即this），完全可以指定返回另外一个对象。

class Foo { constructor() { return Object.create(null); } } new Foo() instanceof Foo // false

  constructor函数返回一个全新的对象，结果导致实例对象不是Foo类的实例。

类的实例对象

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

不存在变量的提升

私有方法和私有属性

   11：有方法是常见需求，但 ES6 不提供，只能通过变通方法模拟实现。
   一种做法是在命名上加以区别。
   class Widget {

                  // 公有方法
                  foo (baz) {
                    this._bar(baz);
                  }
                  // 私有方法
                  _bar(baz) {
                    return this.snaf = baz;
                  }
                  // ...
                }
        上面代码中，_bar方法前面的下划线，表示这是一个只限于内部使用的私有方法。
        但是，这种命名是不保险的，在类的外部，还是可以调用到这个方法
     12：另一种方法就是索性将私有方法移出模块，因为模块内部的所有方法都是对外可见的。
                class Widget {
                  foo (baz) {
                    bar.call(this, baz);
                  }
                  // ...
                }
                function bar(baz) {
                  return this.snaf = baz;
                }
      foo是公有方法，内部调用了bar.call(this, baz)。这使得bar实际上成为了当前模块
       的私有方法。

      13：还有一种方法是利用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;
          }
        
          // ...
        };

私有属性的提案 (#号代替)了解

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方法而导致报错。
  
    一个比较简单的解决方法是，在构造方法中绑定this，这样就不会找不到print方法了。
    
    class Logger {
      constructor() {
        this.printName = this.printName.bind(this);
      }
    
      // ...
    }
  
 另一种解决方法是使用箭头函数。
    class Logger {
  constructor() {
    this.printName = (name = 'there') => {
      this.print(`Hello ${name}`);
    };
  }

  // ...
}

name 属性

    由于本质上，ES6 的类只是 ES5 的构造函数的一层包装，所以函数的许多特性都被Class继承，包括name属性。
    class Point {}
    Point.name // "Point"
    name属性总是返回紧跟在class关键字后面的类名。

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

Class 的 Generator 方法

如果某个方法之前加上星号（*），就表示该方法是一个 Generator 函数。

class Foo {
  constructor(...args) {
    this.args = args;
  }
  * [Symbol.iterator]() {
    for (let arg of this.args) {
      yield arg;
    }
  }
}

for (let x of new Foo('hello', 'world')) {
  console.log(x);
}
// hello
// world

上面代码中，Foo类的Symbol.iterator方法前有一个星号，表示该方 
法是一个 Generator 函数。Symbol.iterator方法返回一个Foo类的默认 
遍历器，for...of循环会自动调用这个遍历器。

Class 的静态方法

如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用，
这就称为“静态方法”。
如果new对象去调用，会出现不存在此方法 

注意，如果静态方法包含this关键字，这个this指的是类，而不是实例。（静态方法可以与非静态方法重名。）

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

静态方法也是可以从super对象上调用的。
    class Foo {
      static classMethod() {
        return 'hello';
      }
    }
    class Bar extends Foo {
      static classMethod() {
        return super.classMethod() + ', too';
      }
    }
    Bar.classMethod() // "hello, too"

Class 的静态属性和实例属性

 静态属性指的是 Class 本身的属性，即Class.propName，而不是定义在实例对象（this）上
 的属性。
                class Foo {
                }
                
                Foo.prop = 1;
                Foo.prop // 1

    类的实例属性
    类的实例属性可以用等式，写入类的定义之中。
    
    class MyClass {
      myProp = 42;
    
      constructor() {
        console.log(this.myProp); // 42
      }
    }

以前，我们定义实例属性，只能写在类的constructor方法里面。

有了新的写法以后，可以不在constructor方法里面定义。

    class ReactCounter extends React.Component {
      state = {
        count: 0
      };