Class

Class的数据类型是函数，类本身就指向构造函数

Class Bar{
}
var b=new Bar();
//类的实例的方法与类原型的方法相同:
class B{}
let b=new B();
b.constructor===B.prototype.constructor

Class内部的toString方法是可枚举的,Class只是原先的构造器的一层包装。

可以通过__proto__来向原型中添加对应的方法。
类的属性名可以使用属性表达式：

let methodName = 'getArea';
class Square {
  constructor(length) {
    // ...
  }
  [methodName]() {
    // ...
  }
}
//甚至与函数一样可以将其用表达式的形式进行定义：
const MyClass=class Me{
    getClassName(){
        return Me.name;
    }
}
//可以写出立即执行的Class
let person = new class {
  constructor(name) {
    this.name = name;
  }
  sayName() {
    console.log(this.name);
  }
}('张三');
person.sayName(); // "张三"

this的指向问题：

//this默认指向类的实例,如下：
class Logger{
    printName(){
        this.print(...)
    }
}
const logger=new Logger();
const {printName}=logger;
printName();//此时的this提取出来是undefined，所以会报错。
//解决1：构造函数中绑定this
Class Logger{
    constructor(){
        this.printName=this.printName.bind(this);
    }
}
//2:使用箭头函数：
class Obj{
    constructor(){
        this.getThis=()=>this;
    }
}
const myObj=new Obj();
//使用Proxy,自动绑定this,做上一层包装，自动绑定this（自己写一个handler进行处理）.

static静态方法,使用的this对应的是类，而不是实例，可以通过exthends继承,对于属性的定义可以放到最顶层：

class IncreasingCount{
    _count=0;//实例属性
    get Value(){
        return this._count;
    }
}
//静态属性则是加上static关键字

私有方法:

1. 使用Symbol来生成私有方法名。
2. 使用#如#count来命名私有方法

new.target属性在构造函数内部使用，用来判断是否通过new来调用，不是的会返回undefined.在继承时，子类的new.target会返回子类,可以通过这种方式实现父类只能继承不能实例化的效果。

Class的继承

ES5的继承是先创造子类实例this,然后将父类的方法添加到this上,而ES6是将父类实例对象的属性方法加到this上，所以要先调super

• 使用super调用时，使用的是父类的方法，this是子类的
• super当成对象时，是指向父类的原型对象（无法获取父类实例上的方法或属性），如果是在静态方法中则指向其父类，
• class具有__proto__属性和prototype属性

class A {
}
class B extends A {
}
B.__proto__ === A // true
B.prototype.__proto__ === A.prototype // true
//说明对于A和B来说，类的继承是如下机制：
Object.setPrototypeOf(B, A);//B.__proto__=A

因此有两条继承链，作为一个对象,子类B的原型是父类，作为一个构造函数，子类的原型对象是父类的原型对象的实例。

ES6可以在原生的构造函数上自定义自己的数据结构：

class MyArray extends Array {
  constructor(...args) {
    super(...args);
  }
}

实现Mixin模式，将多个类合并为一个类：

function mix(...mixins) {
  class Mix {
    constructor() {
      for (let mixin of mixins) {
        copyProperties(this, new mixin()); // 拷贝实例属性
      }
    }
  }
  for (let mixin of mixins) {
    copyProperties(Mix, mixin); // 拷贝静态属性
    copyProperties(Mix.prototype, mixin.prototype); // 拷贝原型属性
  }
  return Mix;
}
function copyProperties(target, source) {
  for (let key of Reflect.ownKeys(source)) {
    if ( key !== 'constructor'
      && key !== 'prototype'
      && key !== 'name'
    ) {
      let desc = Object.getOwnPropertyDescriptor(source, key);
      Object.defineProperty(target, key, desc);
    }
  }
}

原文地址：http://www.cnblogs.com/mengyiqwq/p/16823046.html