ES6指的是ECMAScript 6，也被称为ES2015。它是JavaScript的一种版本，是ECMAScript标准的第六个版本，于2015年发布。ECMAScript是JavaScript的规范，定义了语言的核心特性和行为。ES6引入了许多新的语法特性和功能，以使JavaScript代码更加现代化、清晰和强大。  在此专栏中，我们会持续更新有关于ES6的新特性，感兴趣的小伙伴们可以订阅一下~

前言

在ES6（ECMAScript 2015）中，引入了一种更接近传统面向对象编程语言的类的概念。在 JavaScript 中，类是对象的蓝图，它定义了对象的属性和方法。类是一种模板，通过它可以创建具有相同属性和方法的多个对象。今天，我们就来聊聊JS中的类

在类出来之前

在 ES5 及其之前的版本中，JavaScript 并没有直接支持类的概念。面向对象编程主要依赖于原型链（Prototype Chain）和构造函数（Constructor Function）的概念。

构造函数：

构造函数是一种特殊的函数，通过 new 关键字调用，用于创建对象。构造函数可以定义对象的属性和方法。以下是一个简单的构造函数的例子：

// 构造函数
function Person(name, age) {
  this.name = name;
  this.age = age;
}
// 在构造函数的原型上定义方法
Person.prototype.greet = function() {
  console.log('Hello, my name is ' + this.name + ' and I am ' + this.age + ' years old.');
};
// 创建对象的实例
var person1 = new Person('John Doe', 25);
// 调用对象的方法
person1.greet();

原型链：

JavaScript 中的对象之间通过原型链连接在一起。每个对象都有一个原型对象，而原型对象也可以有自己的原型，依次类推，形成原型链。在原型链上查找属性和方法是 JavaScript 对象系统的核心机制。

原型继承：

在 JavaScript 中，每个对象都有一个原型对象。原型对象是一个普通的对象，它包含可以被共享的属性和方法。当我们创建一个新对象时，它会继承其原型对象的属性和方法。

// 创建一个对象 obj
var obj = {};
// obj 的原型是 Object.prototype

在这个例子中，obj 对象的原型是 Object.prototype。Object.prototype 本身也有一个原型，最终指向 null，形成了原型链的顶端。

访问属性和方法：

当我们访问一个对象的属性或方法时，JavaScript 引擎会首先查找该对象本身是否包含该属性或方法。如果没有找到，它将沿着原型链向上查找，直到找到该属性或方法，或者到达原型链的顶端。

// 创建一个对象 obj
var obj = {};
// obj 继承了 Object.prototype 的 toString 方法
console.log(obj.toString()); // 输出: [object Object]

在这个例子中，obj 对象本身并没有 toString 方法，但由于它继承了 Object.prototype 的原型，因此可以通过原型链找到并调用 toString 方法。

构造函数和原型链：

构造函数也参与原型链的形成。当我们使用构造函数创建对象时，新对象会继承构造函数的原型。

// 定义一个构造函数
function Person(name) {
  this.name = name;
}
// 使用构造函数创建对象
var person = new Person('John');
// person 继承了 Person.prototype 的原型

在这个例子中，person 对象继承了 Person.prototype 的原型，形成了原型链。

为什么要引入类

ECMAScript 6（ES6）引入类的主要目的是提供一种更直观、更清晰、更标准的面向对象编程方式，使 JavaScript 更接近传统的面向对象编程语言。以下是一些引入类的主要原因：

1. 更直观的语法： 类提供了一种更直观和清晰的语法，使得对象的定义和使用更加容易理解。使用 class 关键字可以直观地定义类、构造函数和方法，使代码更易读、易写。
2. 更易于继承： ES6 的类引入了 extends 关键字，使得实现继承更加简洁。在 ES5 中，继承是通过原型链和构造函数的组合来实现的，而 ES6 中的类提供了更直接的方式。
3. 更标准的面向对象实现： 类是对原型和构造函数的一种封装，提供了更标准的、面向对象的实现方式。这有助于开发者更容易理解和使用面向对象的概念。
4. 更符合传统面向对象语言的习惯： 很多其他编程语言（如Java、C#）使用类作为对象的模板，ES6 的类语法使 JavaScript 更具有通用性和可迁移性，使那些熟悉传统面向对象语言的开发者更容易上手。
5. 更方便的构造函数： 类引入了 constructor 关键字，使得构造函数的定义更为明确和一致，更容易进行初始化工作。
6. 更易于静态方法的定义： 在类中，可以直接使用 static 关键字定义静态方法，而不需要手动将方法添加到构造函数的原型上。
7. 更好的封装性： 类的定义和实现更加清晰，更容易实现封装，使得内部细节不易被外部访问，提高了代码的安全性和可维护性。

总的来说，ES6 引入类是为了使 JavaScript 在面向对象编程方面更具有可读性、可维护性和可扩展性，使其更加适用于大型应用程序的开发。

类

在 JavaScript 中，可以使用 class 关键字创建类。类是对象的模板，它定义了对象的属性和方法。以下是一个简单的类的创建例子：

// 使用 class 关键字定义一个名为 "Person" 的类
class Person {
  // 构造函数，用于初始化对象的属性
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  // 类的方法
  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}
// 使用 extends 关键字创建一个继承自 Person 的子类
class Student extends Person {
  // 构造函数，可以通过 super 调用父类的构造函数
  constructor(name, age, grade) {
    super(name, age); // 调用父类的构造函数
    this.grade = grade;
  }
  // 子类可以覆盖父类的方法
  greet() {
    console.log(`Hello, I'm a student named ${this.name}, ${this.age} years old, in grade ${this.grade}.`);
  }
  // 子类可以定义自己的方法
  study() {
    console.log('Studying hard!');
  }
}
// 创建一个 Person 类的实例
const person1 = new Person('John Doe', 25);
// 调用类的方法
person1.greet();
// 创建一个 Student 类的实例
const student1 = new Student('Alice Smith', 20, 12);
// 调用子类的方法
student1.greet();
student1.study();

• 使用 class 关键字定义了一个名为 Person 的类。
• constructor 方法是构造函数，用于初始化对象的属性。
• greet 是在类原型上定义的方法。
• 使用 new 关键字创建了 person1 实例，并调用了它的 greet 方法。
• 使用 extends 关键字创建了一个继承自 Person 的 Student 子类，它可以调用父类的构造函数并覆盖父类的方法。
• 创建了 person1 和 student1 两个实例，并调用了它们的方法。

Static

在 JavaScript 中，使用 static 关键字可以定义类的静态方法和静态属性。静态方法和属性属于类本身，而不是类的实例。这意味着你可以直接通过类来调用静态方法，而不需要创建类的实例。

静态方法：

class MathOperations {
  // 静态方法
  static add(x, y) {
    return x + y;
  }
  static subtract(x, y) {
    return x - y;
  }
}
// 调用静态方法，无需创建类的实例
console.log(MathOperations.add(5, 3)); // 输出: 8
console.log(MathOperations.subtract(8, 3)); // 输出: 5

在这个例子中，add 和 subtract 方法是 MathOperations 类的静态方法，可以直接通过类名调用。

静态属性：

class Configuration {
  // 静态属性
  static version = '1.0.0';
  static getFullVersion() {
    return `Version ${this.version}`;
  }
}
// 访问静态属性
console.log(Configuration.version); // 输出: 1.0.0
// 调用静态方法
console.log(Configuration.getFullVersion()); // 输出: Version 1.0.0

在这个例子中，version 是 Configuration 类的静态属性，可以通过类名直接访问。

静态方法和属性对于那些不依赖于实例状态而属于整个类的功能非常有用。它们提供了一种组织和封装类内部通用功能的方式，而不需要创建类的实例。