摘要：使用除關(guān)鍵字之外的方式調(diào)用構(gòu)造函數(shù)會(huì)導(dǎo)致程序拋出錯(cuò)誤。在類中修改類名會(huì)導(dǎo)致程序報(bào)錯(cuò)。與之等價(jià)的聲明必須通過關(guān)鍵字調(diào)用構(gòu)造函數(shù)不可使用關(guān)鍵字調(diào)用構(gòu)造函數(shù)類表達(dá)式類表達(dá)式可以是被命名的或匿名的。類也是中的一等公民。

class (類)作為對(duì)象的模板被引入，可以通過 class 關(guān)鍵字定義類。類簡(jiǎn)要說明
類的本質(zhì)是function,是基本原型繼承的語法糖。所以，JS中繼承的模型是不會(huì)被改變的。
類既然是函數(shù)，那與函數(shù)有何不同呢？我們?yōu)槭裁匆褂妙惸兀?br>有時(shí)間，先看一下MDN od

函數(shù)聲明可以被提升，而類聲明與let/const 聲明類似，不能被提升，也就是在真正執(zhí)行聲明之前，它們會(huì)一直存在于臨時(shí)死區(qū)中。

類聲明中的所有代碼將自動(dòng)運(yùn)行在嚴(yán)格模式下，而且無法強(qiáng)行讓代碼脫離嚴(yán)格模式。

類中的所有方法，都是不可枚舉的。而普通自定義類型中，必須通過Object.defineProperty()方法來指定某方法不可枚舉。

每個(gè)類都有一個(gè)[[Construct]]的內(nèi)部方法，通過關(guān)鍵字new調(diào)用那些不含[[Construct]]的方法會(huì)導(dǎo)致程序拋出錯(cuò)誤。

使用除關(guān)鍵字new之外的方式調(diào)用構(gòu)造函數(shù)會(huì)導(dǎo)致程序拋出錯(cuò)誤。

在類中修改類名會(huì)導(dǎo)致程序報(bào)錯(cuò)。

首先class關(guān)鍵字，然后是類的名字，其它部分的語法，類似于對(duì)象字面量方法的簡(jiǎn)寫形式，但不需要在各元素之間使用逗號(hào)分隔。

class HelloClass {
    constructor(greeting) {
        this.greeting = greeting;
    }
    
    sayGreeting(){
        console.log(this.greeting);
    }
}

let hello = new HelloClass("Hello");
hello.sayGreeting();  // Hello

console.log(hello instanceof HelloClass);  // true
console.log(hello instanceof Object);  // true

console.log(typeof HelloClass);  // function
console.log(typeof HelloClass.prototype.sayGreeting); // function

分析：

constructor為保留方法名，是用來構(gòu)建對(duì)象的，不可用作其它用途。

函數(shù)定義之前，不需要添加function關(guān)鍵字。

類的屬性不可被賦予新值，HelloClass.prototype是一個(gè)只可讀類屬性。

與之等價(jià)的ES5聲明

let HelloClass = (function(){
    "use strict";
    const HelloClass  = function(greeting) {
        if (typeof new.target === "undefined") {
            throw new Error("必須通過關(guān)鍵字new調(diào)用構(gòu)造函數(shù)");
        }
        this.greeting = greeting;

        Object.defineProperty(HelloClass.prototype, "sayGreeting", {
            value: function() {
                if (typeof new.target !== "undefined") {
                    throw new Error("不可使用關(guān)鍵字new調(diào)用構(gòu)造函數(shù)");
                }
                console.log(this.greeting);
            },
            enumerable: false,
            writable: true,
            configurable: true
        });        
    }
    return HelloClass;
}());

let hello = new HelloClass("Hello");
hello.sayGreeting();

console.log(hello instanceof HelloClass);
console.log(hello instanceof Object);

console.log(typeof HelloClass);
console.log(typeof HelloClass.prototype.sayGreeting);

類表達(dá)式可以是被命名的或匿名的。賦予一個(gè)命名類表達(dá)式的名稱是類的主體的本地名稱。和function的表達(dá)式類似,但不會(huì)像函數(shù)聲名或和函數(shù)表達(dá)式一樣被提升。

/* 匿名類 */ 
let Rectangle = class {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
};
console.log(typeof Rectangle); // function

/* 命名的類 */ 
let Rectangle = class Rectangle1 {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
};
console.log(typeof Rectange); // function
console.log(typeof Rectange1); // undefined

在JS中，函數(shù)為一等“公民”，可以傳入函數(shù)，也可以從函數(shù)中返回，還可以賦值給變量的值。類也是JS中的一等公民。

- getter
- setter

class Rectangle {
    // constructor
    constructor(height, width) {
        this.height = height;
        this.width = width;
    }
    // Getter
    get area() {
        return this.calcArea()
    }
    // Method
    calcArea() {
        return this.height * this.width;
    }
}
const square = new Rectangle(10, 10);

console.log(square.area);
// 100

const methodName = "sayGreeting";
class HelloClass {
    constructor(greeting) {
        this.greeting = greeting;
    }
    
    [methodName]() {
        console.log(this.greeting);
    }
}

let hello = new HelloClass("Hello");
hello.sayGreeting(); // Hello
hello[methodName](); // Hello

可計(jì)算訪問器屬性。

const propertyName = "greeting";
class HelloClass {
    constructor() {
        
    }
    
    get [propertyName]() {
        return this.greetingStr;
    }
    set [propertyName](value) {
        this.greetingStr = value;
    }
}

let hello = new HelloClass();
hello.greeting = "Hello";
console.log(hello.greeting);

class NormClass {
    *createIterator() {
        yield 1;
        yield 2;
        yield 3;
    }
}
let instance = new NormClass();
let iterator = instance.createIterator();
console.log(iterator.next());  // { value: 1, done: false }
console.log(iterator.next());  // { value: 2, done: false }
console.log(iterator.next());  // { value: 3, done: false }
console.log(iterator.next());  // { value: undefined, done: true }

為類定義默認(rèn)迭代器。

class Collection {
    constructor() {
        this.items = [];
    }

    *[Symbol.iterator]() {
        yield *this.items.values();
    }
}

var coll = new Collection();
coll.items.push(1);
coll.items.push(2);
coll.items.push(3);
for (let i of coll) {
    console.log(i);
}
// 1
// 2
// 3

class Animal { 
    speak() {
      return this;
    }
    static eat() {
      return this;
    }
  }
  
  let obj = new Animal();
  console.log(obj.speak()); // Animal {}
  let speak = obj.speak;
  console.log(speak()); // undefined
  
  console.log(Animal.eat()); // class Animal
  let eat = Animal.eat;
  console.log(eat()); // undefined