摘要：歡迎關注前端小謳的，閱讀更多原創技術文章用構造函數，生成對象實例使用構造函數，并且構造函數后臺會隱式執行創建對象將構造函數的作用域給新對象，即創建出的對象，函數體內的代表出來的對象執行構造函數的代碼返回新對象后臺直接返回用改寫上述代碼通過關

歡迎關注前端小謳的github，閱讀更多原創技術文章
用構造函數，生成對象實例：

使用構造函數，并且new 構造函數(), 后臺會隱式執行new Object() 創建對象
將構造函數的作用域給新對象，（即new Object() 創建出的對象），函數體內的this代表new Object() 出來的對象
執行構造函數的代碼
返回新對象（ 后臺直接返回）

function Person1(name, age) {
  this.name = name
  this.age = age
}
Person1.prototype.say = function () {
  return "My name is " + this.name + ", I"m " + this.age + " years old."
}
var obj = new Person1("Simon", 28);
console.log(obj.say()); // My name is Simon, I"m 28 years old.

用class改寫上述代碼：

通過class關鍵字定義類，使得在對象寫法上更清晰，讓javascript更像一種面向對象的語言
在類中聲明方法的時，不可給方法加function關鍵字

class Person2 {
  // 用constructor構造方法接收參數
  constructor(name, age) {
    this.name = name; // this代表的是實例對象
    this.age = age;
  }
  // 類的方法，此處不能加function
  say() {
    return "My name is " + this.name + ", I"m " + this.age + " years old."
  }
}
var obj = new Person2("Coco", 26);
console.log(obj.say()); // My name is Coco, I"m 26 years old.

ES6中的類，實質上就是一個函數
類自身指向的就是構造函數
類其實就是構造函數的另外一種寫法

console.log(typeof Person2); // function
console.log(Person1 === Person1.prototype.constructor); // true
console.log(Person2 === Person2.prototype.constructor); // true

構造函數的prototype屬性，在ES6的class中依然存在：

// 構造1個與類同名的方法 -> 成功實現覆蓋
Person2.prototype.say = function () {
  return "證明一下：My name is " + this.name + ", I"m " + this.age + " years old."
}
var obj = new Person2("Coco", 26);
console.log(obj.say()); // 證明一下：My name is Coco, I"m 26 years old.

// 通過prototype屬性對類添加方法
Person2.prototype.addFn = function () {
  return "通過prototype新增加的方法addFn"
}
var obj = new Person2("Coco", 26);
console.log(obj.addFn()); // 通過prototype新增加的方法addFn

通過Object.assign方法來為對象動態增加方法：

Object.assign(Person2.prototype, {
  getName: function () {
    return this.name;
  },
  getAge: function () {
    return this.age;
  }
})
var obj = new Person2("Coco", 26);
console.log(obj.getName()); // Coco
console.log(obj.getAge()); // 26

constructor方法是類的構造函數的默認方法
new生成對象實例時，自動調用該方法

class Box {
  constructor() {
    console.log("自動調用constructor方法"); // 實例化對象時，該行代碼自動執行
  }
}
var obj = new Box();

若沒有定義constructor方法，將隱式生成一個constructor方法：

即使沒有添加構造函數，構造函數也是存在的
constructor方法默認返回實例對象this
可以指定constructor方法返回一個全新的對象，讓返回的實例對象不是該類的實例對象

class Text1 {
  constructor() {
    this.text = "這是一段Text";
  }
}
class Text2 {
  constructor() {
    return new Text1(); // 返回一個全新的對象
  }
}
var obj = new Text2()
console.log(obj.text); // 這是一段Text

實例屬性：constructor中定義的屬性，即定義在this對象上
原型屬性：constructor外聲明的屬性，即定義在class上

hasOwnProperty() 函數，判斷屬性是否為實例屬性 -> true or false
in操作符， 判斷對象能否訪問給定屬性 -> true or false（與該屬性存在于實例/原型中無關）

class Text3 {
  // 實例屬性，定義在this對象上
  constructor(text1, text2) {
    this.text1 = text1
    this.text2 = text2
  }
  // 原型屬性，定義在class上
  text3() {
    return text1 + text2
  }
}
var obj = new Text3("123", "234")
console.log(obj.hasOwnProperty("text1")); // true
console.log(obj.hasOwnProperty("text2")); // true
console.log(obj.hasOwnProperty("text3")); // false
console.log("text1" in obj); // true
console.log("text2" in obj); // true
console.log("text3" in obj); // true
console.log("text4" in obj); // false

類的所有實例共享一個原型對象， 它們的原型都是Person.prototype， 所以proto屬性是相等的

class Text4 {
  constructor(text1, text2) {
    this.text1 = text1;
    this.text2 = text2;
  }
  text3() {
    return text1 + text1;
  }
}
// text1與text2都是Text4的實例 -> 它們的__proto__都指向Text4的prototype
var text1 = new Text4("1234", "5678");
var text2 = new Text4("4321", "8765");
console.log(text1.__proto__ === text2.__proto__); // true

通過proto來為類增加方法：

使用實例的proto屬性改寫原型
會改變Class的原始定義，影響到所有實例，不推薦使用

class Num {
  constructor(num1, num2) {
    this.num1 = num1;
    this.num2 = num2;
  }
  sum() {
    return num1 + num2;
  }
}
var num1 = new Num(20, 78);
var num2 = new Num(40, 96);
num1.__proto__.minus = function () {
  return this.num2 - this.num1;
}
console.log(num1.minus()); // 76 -> 改變了class的原始定義，為class新增原型屬性minus
console.log(num2.minus()); // 20 -> num2和num1共享原型對象Num，可以調用原型對象的minus方法

class不存在變量提升，必須先定義再使用：

ES6不會把class的聲明提升到代碼頭部2
ES5存在變量提升, 可以先使用再定義

//ES5可以先使用再定義，存在變量提升
new A()
function A() {}

//ES6不能先使用再定義,不存在變量提升（報錯）
new B() // B is not defined
class B {}