在ES5时代，可以像下面这样模拟一个类，先声明一个构造函数，然后在其原型上定义共享的方法，最后与new运算符组合实例化一个类。

functionPeople(name){this.name=name;}People.prototype.getName=function(){returnthis.name;};varpeople=newPeople("strick");people.getName();//"strick"ES6类（Class）基础

ES6的class只是一个语法糖，完全可以看作构造函数的另一种写法，ES5的构造函数对应ES6的构造方法

classPoint{//...}typeofPoint//"function"Point===Point.prototype.constructor//true

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

classPoint{constructor(){//...}toString(){//...}toValue(){//...}}//等同于Point.prototype={constructor(){},toString(){},toValue(){},};

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

classPoint{constructor(){//...}}Object.assign(Point.prototype,{toString(){},toValue(){}});

prototype对象的constructor属性，直接指向“类”的本身，这与ES5的行为是一致的

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

类的内部所有定义的方法，都是不可枚举的，这一点与ES5的行为不一致

classPoint{constructor(x,y){//...}toString(){//...}}Object.keys(Point.prototype)//[]Object.getOwnPropertyNames(Point.prototype)//["constructor","toString"]类的属性名，可以采用表达式/*类的属性名，可以采用表达式Square类的方法名getArea，是从表达式得到的*/letmethodName=getArea;classSquare{constructor(length){//...}[methodName](){//...}}console.log(Square.prototype)

「严格模式」

类和模块的内部，默认就是严格模式，所以不需要使用usestrict指定运行模式。只要你的代码写在类或模块之中，就只有严格模式可用。

「constructor方法」

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

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

classFoo{constructor(){returnObject.create(null);}}newFoo()instanceofFoo

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

classFoo{constructor(){returnObject.create(null);}}Foo()//TypeError:ClassconstructorFoocannotbeinvokedwithoutnew

「类的实例对象」

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

//定义类classPoint{constructor(x,y){this.x=x;this.y=y;}toString(){return(+this.x+,+this.y+);}}varpoint=newPoint(2,3);point.toString()//(2,3)point.hasOwnProperty(x)//truepoint.hasOwnProperty(y)//truepoint.hasOwnProperty(toString)//falsepoint.__proto__.hasOwnProperty(toString)//true

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

proto并不是语言本身的特性，这是各大厂商具体实现时添加的私有属性，虽然目前很多现代浏览器的JS引擎中都提供了这个私有属性，但依旧不建议在生产中使用该属性，避免对环境产生依赖。生产环境中，我们可以使用Object.getPrototypeOf方法来获取实例对象的原型，然后再来为原型添加方法/属性

varp1=newPoint(2,3);varp2=newPoint(3,2);p1.__proto__.printName=function(){returnOops};p1.printName()//"Oops"p2.printName()//"Oops"varp3=newPoint(4,2);p3.printName()//"Oops"

使用实例的__proto__属性改写原型，必须相当谨慎，不推荐使用，因为这会改变“类”的原始定义，影响到所有实例

「Class表达式」

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

constMyClass=classMe{getClassName(){returnMe.name;}};

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

letinst=newMyClass();inst.getClassName()//MeMe.name//ReferenceError:Meisnotdefined

「不存在变量提升」

类不存在变量提升，这一点与ES5完全不同

newFoo();//ReferenceErrorclassFoo{}

上面代码中，Foo类使用在前，定义在后，这样会报错，因为ES6不会把类的声明提升到代码头部

「私有方法」

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

classWidget{foo(baz){bar.call(this,baz);}//...}functionbar(baz){returnthis.snaf=baz;}

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

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

constbar=Symbol(bar);constsnaf=Symbol(snaf);exportdefaultclassmyClass{//公有方法foo(baz){this[bar](baz);}//私有方法[bar](baz){returnthis[snaf]=baz;}//...};

上面代码中，bar和snaf都是Symbol值，导致第三方无法获取到它们，因此达到了私有方法和私有属性的效果

「私有属性」

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

「name属性」

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

classPoint{}Point.name//"Point"

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

与ES5一样，在“类”的内部可以使用get和set关键字，对某个属性设置存值函数和取值函数，拦截该属性的存取行为存值函数和取值函数是设置在属性的Descriptor对象上的

classCustomHTMLElement{constructor(element){this.element=element;}gethtml(){returnthis.element.innerHTML;}sethtml(value){this.element.innerHTML=value;}}vardescriptor=Object.getOwnPropertyDescriptor(CustomHTMLElement.prototype,"html");"get"indescriptor//true"set"indescriptor//true

「Class的静态方法」

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

classFoo{staticclassMethod(){returnhello;}}Foo.classMethod()//hellovarfoo=newFoo();foo.classMethod()//TypeError:foo.classMethodisnotafunction

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

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

classFoo{staticbar(){this.baz();}staticbaz(){console.log(hello);}baz(){console.log(world);}}Foo.bar()//hello

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

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

classFoo{staticclassMethod(){returnhello;}}classBarextendsFoo{staticclassMethod(){returnsuper.classMethod()+,too;}}Bar.classMethod()//"hello,too"classFoo{staticclassMethod(){returnhello;}}classBarextendsFoo{staticclassMethod(){returnsuper.classMethod()+,too;}}Bar.classMethod()//"hello,too"

「Class的静态属性」

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

classFoo{}Foo.prop=1;Foo.prop//1

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

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

「new.target属性」

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

functionPerson(name){if(new.target!==undefined){this.name=name;}else{thrownewError(必须使用new命令生成实例);}}//另一种写法functionPerson(name){if(new.target===Person){this.name=name;}else{thrownewError(必须使用new命令生成实例);}}varperson=newPerson(张三);//正确varnotAPerson=Person.call(person,张三);//报错

需要注意的是，子类继承父类时，new.target会返回子类

classRectangle{constructor(length,width){console.log(new.target===Rectangle);//...}}classSquareextendsRectangle{constructor(length){super(length,length);}}varobj=newSquare(3);//输出false

利用这个特点，可以写出不能独立使用、必须继承后才能使用的类（抽象类）

classShape{constructor(){if(new.target===Shape){thrownewError(本类不能实例化);}}}classRectangleextendsShape{constructor(length,width){super();//...}}varx=newShape();//报错vary=newRectangle(3,4);//正确

上面代码中，Shape类不能被实例化，只能用于继承注意，在函数外部，使用new.target会报错

原文链接：