ES6 引入了“类”的概念,这一方法不同于 类。在这里,类是特殊函数, 可用作创建已包含数据、属性的对象 与这些数据的操作有关的方法。 这些对象、属性和方法统称为“成员”的 类。

如需定义类,请使用 class 关键字。遵循最佳实践和 JavaScript 内置构造函数建立的惯例,以任何 类标识符:

class MyClass {}

类旨在提供更易上手的高级用法 原型和构造函数函数的功能:

class MyClass {}

typeof MyClass;
> "function"

因为添加部分类是为了支持高级 JavaScript 有时也被称为 "语法糖"。不过, 类不仅仅能提供实用的简写形式, 原型继承。 引入类语法创造了解决长期设计问题的机会 但不会引入向后兼容性问题。合并为一个 例如,类正文内的所有代码始终在 严格模式

如需创建类的实例,请使用 new 运算符。

class MyClass {}

const myClassInstance = new MyClass();

myClassInstance
;
> Object { }

在类正文中定义的函数会作为每个函数的方法公开 该类的一个实例。

class MyClass {
    classMethod
() {
        console
.log( "My class method." );
   
}
}

const myClassInstance = new MyClass();

myClassInstance
.classMethod();
> "My class method."

在类中定义的方法会成为 生成的实例由于 原型链,您可以调用 这些方法:

class MyClass {
  classMethod
() {
    console
.log( "My class method." );
 
}
}

const myClassInstance = new MyClass( "A string." );

myClassInstance
;
> Object { }
   
<prototype>: Object { }
        classMethod
: function classMethod()
        constructor
: class MyClass { constructor(myPassedValue) }
       
<prototype>: Object { }

myClassInstance
.classMethod();
> "My class method."

创建类的实例会调用特殊的 constructor() 方法,该方法将 执行所有必要的“设置”并初始化 任何相关媒体资源使用 可供 constructor() 方法使用:

class MyClass {
  constructor
( myPassedValue ) {
    console
.log( myPassedValue );
 
}
}

const myClassInstance = new MyClass( "A string." );
> "A string."

在类的正文中,this 的值是指实例本身, 在 this 中定义的任何属性都公开为 该类:

class MyClass {
  constructor
( myPassedValue ) {
   
this.instanceProperty = myPassedValue;
 
}
}

const myClassInstance = new MyClass( "A string." );

myClassInstance
;
> Object { instanceProperty: "A string." }

类正文中的所有方法也可以使用这些属性:

class MyClass {
  constructor
( myPassedValue ) {
   
this.instanceProp = myPassedValue;
 
}
  myMethod
() {
    console
.log( this.instanceProp );
 
}
}

const myClassInstance = new MyClass( "A string." );

myClassInstance
.myMethod();
> "A string."

如果您没有为类定义 constructor(),JavaScript 引擎 假定使用空的“default”constructor。每个类只能有一个特殊的 名为 constructor() 的方法:

class MyClass {
  constructor
() {}
  constructor
() {}
}
> Uncaught SyntaxError: A class may only have one constructor

您可以使用类声明类表达式。前面的示例都是类声明, 这要求使用 new 来调用名称。类表达式可以命名为 保留未命名以创建“匿名”类。

let ClassExpression = class {
    constructor
() {}
};

ClassExpression;
> class  {}

您可以使用匿名类表达式的一个函数是 构建“即时”类:

function classMaker() {
 
return class {
    constructor
() {}
 
};
}

let
MyVariable = classMaker();

MyVariable;
> class  {}

使用类声明来重复声明类会导致语法错误:


class MyClass {
    constructor
( ) {
        console
.log( "My class." );
   
}
};

class MyClass {
    constructor
() {
        console
.log( "My new class." );
   
}
};
> Uncaught SyntaxError: redeclaration of class MyClass

不过,类表达式可让您重新定义类:

let ClassExpression = class MyClass { };

ClassExpression = class MyOtherClass {
    constructor
( myString ) {
       
this.myProp = myString;
   
}
};

new ClassExpression( "String." );
> MyOtherClass {myProp: 'String.'}

不能像对类那样通过名称调用已命名的类表达式 声明。不过,类表达式的分配名称以 属性,这主要是为了简化调试:

let MyVariable = class MyClass {};

MyClass;
> Uncaught ReferenceError: MyClass is not defined

MyVariable;
> class MyClass {}

MyVariable.name;
> "MyClass"

使用类表达式初始化变量时, 提升规则 该变量会按预期跟随。类声明遵循 相同的“时间死区”规则为letconst, 并且表现得就像未提升到当前作用域的顶部一样, 这意味着在类声明之前调用类会导致错误:

{
    let myVar
= new MyClass( "Property string." );

   
class MyClass {
        myProp
;

        constructor
( myString ) {
           
this.myProp = myString;
       
}
   
};
};
> Uncaught ReferenceError: Cannot access 'MyClass' before initialization

检查您的理解情况

以下哪项正确定义了类?

myClass = class {}
class MyClass {}
new class()

一个类可以有多少个 constructor() 方法?

无限制
1