主要知識點：類宣告、類表示式、類的重要要點以及類繼承
1. 類的宣告
基本的類宣告
類宣告以class關鍵字開始，其後是類的名稱；類中的方法就像是物件字面量中的方法簡寫，並且方法之間不需要使用逗號：
class PersonClass{
constructor(name){
this.name = name;
}
sayName(){
console.log(this.name);
}
}
let person = new PersonClass("hello class");
person.sayName();
複製程式碼類宣告語法允許使用constructor直接定義一個構造器，而不需要先定義一個函式，再把它當做構造器來使用。類中的方法使用的函式簡寫語法，省略了關鍵字function。
使用class關鍵字來定義一個型別，有這樣幾個要點：
- 類宣告不會被提升，這與ES6之前通過函式定義不同。類宣告與使用
let定義一樣，因此也存在暫時性死區； - 類宣告中的所有程式碼會自動執行在嚴格模式下，並且無法退出嚴格模式；
- 類的所有方法都是不可列舉的；
- 類的所有內部方法都沒有
[[Constructor]]，因此使用new來呼叫他們會丟擲錯誤； - 呼叫類構造器時不使用
new，會丟擲錯誤； - 試圖在類的內部方法中重寫類名，會丟擲錯誤；
2. 類表示式
類與函式有相似之處，都有兩種形式：宣告與表示式。函式宣告與類宣告都以關鍵詞開始（分別是function和class），之後就是識別符號（即函式名或者類名）。如果需要定義匿名函式，則function後面就無需有函式名，類似的，如果採用類表示式，關鍵是class後也無需有類名；
基本的類表示式
使用類表示式，將上例改成如下形式：
let PersonClass = class {
constructor(name){
this.name = name;
}
sayName(){
console.log(this.name);
}
}
let person = new PersonClass("hello class");
person.sayName(); //hello class
複製程式碼示例程式碼中就定義了一個匿名的類表示式，如果需要定義一個具名的類表示式，只需要像定義具名函式一樣，在class關鍵字後面寫上類名即可。
3. 類的重要要點
作為一級公民的類
在程式設計中，能夠被當作值來使用的就成為一級公民（first-class citizen）。既然都當作值使用，就說明它能夠作為引數傳遞給函式、能作為函式的返回值也能用來給變數賦值。JS中的函式是一等公民，類也是一等公民。
例如，將類作為引數傳遞給函式：
function createObj(classDef){
return new classDef();
}
let obj = createObj(class{
sayName(){
console.log('hello'); //hello
}
})
obj.sayName();
複製程式碼**類表示式另一個重要用途是實現立即呼叫類構造器以建立單例。**語法是使用new來配合類表示式使用，並在表示式後面新增括號()：
//立即呼叫構造器
let person = new class{
constructor(name){
this.name = name;
}
sayName(){
console.log(this.name);
}
}('hello world');
person.sayName(); //hello world
複製程式碼訪問器屬性
自有屬性需要在類構造器中建立，而類還允許建立訪問器屬性。為了建立一個getter，要使用get關鍵字，並要與後面的識別符號之間留出空格；建立setter使用相同的方式，只需要將關鍵字換成set即可：
class PersonClass{
constructor(name){
this.name = name;
}
get name(){
return name; //不要使用this.name會導致無限遞迴
}
set name(value){
name=value; //不要使用this.value會導致無限遞迴
}
}
let person = new PersonClass('hello');
console.log(person.name); // hello
person.name = 'world';
console.log(person.name); //world
let descriptor = Object.getOwnPropertyDescriptor(PersonClass.prototype,'name');
console.log('get' in descriptor); //true
複製程式碼需計算屬性名
物件字面量和類之間的相似點有很多，類方法與類訪問器屬性都能使用需計算屬性名的方式，語法與物件字面量中需計算屬性名一樣，都是使用方括號[]來包裹表示式：
//需計算屬性名
let methodName ='sayName';
let propertyName = 'name';
class PersonClass{
constructor(name){
this.name = name;
}
get [propertyName](){
return name;
}
set [propertyName](value){
name = value;
}
[methodName](){
return console.log(this.name);
}
}
let person = new PersonClass('hello world');
person.sayName(); //hello world
console.log(person.name); //hello world
複製程式碼生成器方法
在物件字面量中定義一個生成器：只需要在方法名前附加一個星號*即可，這一語法對類同樣有效，允許將類的任意內部方法程式設計生成器方法：
//生成器方法：
class GeneClass{
*generator(){
yield 1;
yield 2;
}
}
let obj = new GeneClass();
let iterator = obj.generator();
console.log(iterator.next().value); //1
console.log(iterator.next().value); //2
console.log(iterator.next().value); //undefined
複製程式碼可迭代物件用於Symbol.iterator屬性，並且該屬性指向生成器函式。因此，在類定義中同樣可以使用Symbol.iterator屬性來定義生成器方法，從而定義出類的預設迭代器。同時也可以通過生成器委託的方式，將陣列、Set、Map等迭代器委託給自定義類的迭代器：
class Collection {
constructor() {
this.items = [];
}
*[Symbol.iterator]() {
for(let item of this.items){
yield item;
}
}
}
let collection = new Collection();
collection.items.push(1);
collection.items.push(2);
collection.items.push(3);
for (let x of collection) {
console.log(x);
}
輸出：1 2 3
複製程式碼靜態成員
ES6的類簡化了靜態成員的建立，只要在方法與訪問器屬性的名稱前新增static關鍵字即可：
class PersonClass {
// 等價於 PersonType 構造器
constructor(name) {
this.name = name;
}
static create(name) {
return new PersonClass(name);
}
}
let person = PersonClass.create("Nicholas");
複製程式碼通過在方法前加上static關鍵字，使其轉換成靜態方法。能在類中的任何方法與訪問器屬性上使用 static 關鍵字，唯一限制是不能將它用於 constructor 方法的定義。靜態成員不能用例項來進行訪問，始終需要用類自身才能訪問它們。
類繼承
使用關鍵字extends可以完成類繼承，同時使用super關鍵字可以在派生類上訪問到基類上的方法，包括構造器方法：
//類繼承
class Rec{
constructor(width,height){
this.width = width;
this.height = height;
}
getArea(){
return this.width*this.height;
}
}
class Square extends Rec{
constructor(width,height){
super(width,height);
}
}
let square = new Square(100,100);
console.log(square.getArea()); //10000
複製程式碼關於類繼承，還有這樣幾個要點：
- **在派生類中方法會覆蓋掉基類中的同名方法，**例如在派生類
Square中有getArea()方法的話就會覆蓋掉基類Rec中的getArea()方法； - 如果基類中包含了靜態成員，那麼這些靜態成員在派生類中也是可以使用的。注意：靜態成員只能通過類名進行訪問，而不是使用物件例項進行訪問；
從表示式中派生類
在ES6中派生類最大的能力就是能夠從表示式中派生類，只要一個表示式能夠返回的物件具有[[Constructor]]屬性以及原型，你就可以對該表示式使用extends進行繼承。由於extends後面能夠接收任意型別的表示式，這就帶來了巨大的可能性，可以動態決定基類，因此一種物件混入的方式：
//從表示式中派生類
let SerializableMixin = {
serialize() {
return JSON.stringify(this);
}
};
let AreaMixin = {
getArea() {
return this.length * this.width;
}
};
function mixin(...mixins) {
var base = function() {};
Object.assign(base.prototype, ...mixins);
return base;
}
class Square extends mixin(AreaMixin, SerializableMixin) {
constructor(length) {
super();
this.length = length;
this.width = length;
}
}
let x = new Square(3);
console.log(x.getArea()); // 9
console.log(x.serialize()); // "{"length":3,"width":3}"
複製程式碼mixin()函式接受代表混入物件的任意數量的引數，它建立了一個名為 base 的函式，並將每個混入物件的屬性都賦值到新函式的原型上。此函式隨後被返回，於是 Square 就能夠對其使用 extends 關鍵字了。注意由於仍然使用了 extends ，你就必須在構造器內呼叫 super()。若多個混入物件擁有相同的屬性，則只有最後新增
的屬性會被保留。
4. 繼承內建物件
在E6中能夠通過extends繼承JS中內建物件，例如：
class MyArray extends Array {
// 空程式碼塊
}
let colors = new MyArray();
colors[0] = "red";
console.log(colors.length); // 1
colors.length = 0;
console.log(colors[0]); // undefined
複製程式碼Symbol.species
屬性Symbol.species被用於定義靜態訪問器屬性，該屬性值用來指定類的構造器。當建立一個新的物件例項時，就需要通過Symbol.species屬性獲取到構造器，從而新建物件例項。
下面內建物件都定義了Symbol.species屬性：
- Array;
- ArrayBuffer;
- Map;
- Promise;
- RegExp;
- Set;
- 型別化陣列
例如在自定義型別中，使用Symbol.species:
class MyClass {
static get [Symbol.species]() {
return this;
}
constructor(value) {
this.value = value;
}
clone() {
return new this.constructor[Symbol.species](this.value);
}
}
class MyDerivedClass1 extends MyClass {
// 空程式碼塊
}
class MyDerivedClass2 extends MyClass {
static get [Symbol.species]() {
return MyClass;
}
}
let instance1 = new MyDerivedClass1("foo"),
clone1 = instance1.clone(),
instance2 = new MyDerivedClass2("bar"),
clone2 = instance2.clone();
console.log(clone1 instanceof MyClass); // true
console.log(clone1 instanceof MyDerivedClass1); // true
console.log(clone2 instanceof MyClass); // true
console.log(clone2 instanceof MyDerivedClass2); // false
複製程式碼此處, MyDerivedClass1 繼承了 MyClass ，並且未修改 Symbol.species 屬性。由於
this.constructor[Symbol.species] 會返回 MyDerivedClass1 ，當 clone() 被呼叫時，它就
返回了 MyDerivedClass1 的一個例項。 MyDerivedClass2 類也繼承了 MyClass ，但重寫了
Symbol.species，讓其返回 MyClass 。當 clone() 在 MyDerivedClass2 的一個例項上被調
用時，返回值就變成 MyClass 的一個例項。使用 Symbol.species，任意派生類在呼叫應當
返回例項的方法時，都可以判斷出需要返回什麼型別的值。
在類構造器中使用new.target
使用new.target屬效能夠判斷當前例項物件是由哪個類構造器進行建立的，簡單的情況下，new.target屬性就等於該類的構造器函式，同時new.target屬性也只能在構造器內被定義。
class Rec{
constructor(){
console.log(new.target===Rec);
}
}
class Square extends Rec{
}
let rec = new Rec();
let square = new Square();
輸出：true false
複製程式碼當建立Rec物件例項時，new.target指代的是Rec自身的構造器，因此new.target===Rec會返回true，而Rec的派生類Square的new.target會指向它自身的構造器，因此new.target===Rec會返回false;
可以使用new.target來建立一個抽象基類：
class Rec{
constructor(){
if(new.target===Rec){
throw new Error('abstract class');
}
}
}
class Square extends Rec{
}
let rec = new Rec(); //Uncaught Error: abstract class
let square = new Square(); //不會報錯
複製程式碼當試圖建立一個Rec例項物件時，會丟擲錯誤，因此Rec可以當做一個抽象基類。
5. 總結
-
ES6中的類使用關鍵字class進行定義，即可以採用類宣告的方式也可以採用類表示式進行定義。 此外，類構造器被呼叫時不能缺少 new ，確保了不能意外地將類作為函式來呼叫用。
-
基於類的繼承允許你從另一個類、函式或表示式上派生新的類。這種能力意味著你可以呼叫一個函式來判斷需要繼承的正確基類，也允許你使用混入或其他不同的組合模式來建立一個新類。新的繼承方式讓繼承內建物件（例如陣列） 也變為可能，並且其工作符合預期。
-
可以使用
new.target來判斷建立例項物件時所用的類構造器。利用new.target可以用來建立一個抽象基類；
總之，類是 JS 的一項新特性，它提供了更簡潔的語法與更好的功能，通過安全一致的方式來自定義一個物件型別。