只需定义一个getter。

MyClass类 ｛ get MY_CONST(){返回'string';｝ 构造函数() ｛ console.log ("MyClass MY_CONST:"， this.MY_CONST); ｝ ｝ var obj = new MyClass();

如果只是构造函数的混乱问题，为什么不实现一个初始化方法来初始化变量呢?当构造函数充满了不必要的东西时，这样做是很正常的。即使在类型化的程序语言中，如c#，它的常规约定是添加一个Initialize方法来处理它。

只需定义一个getter。

MyClass类 ｛ get MY_CONST(){返回'string';｝ 构造函数() ｛ console.log ("MyClass MY_CONST:"， this.MY_CONST); ｝ ｝ var obj = new MyClass();

只是补充一下本杰明的答案——类变量是可能的，但你不会使用原型来设置它们。

对于一个真正的类变量，你应该像下面这样做:

class MyClass {}
MyClass.foo = 'bar';

在类方法中，该变量可以通过this.constructor.foo(或MyClass.foo)访问。

这些类属性通常不能被类实例访问。即MyClass。foo给出'bar'但新的MyClass()。Foo没有定义

如果你也想从实例中访问你的类变量，你必须另外定义一个getter:

class MyClass {
    get foo() {
        return this.constructor.foo;
    }
}

MyClass.foo = 'bar';

我只在Traceur上测试过这个功能，但我相信它在标准实现中也能发挥同样的作用。

JavaScript实际上没有类。即使在ES6中，我们看到的是基于对象或原型的语言，而不是基于类的语言。在任何函数X(){}中，X.prototype.constructor都指向X。 当在X上使用new操作符时，将创建一个继承X.prototype的新对象。新对象中任何未定义的属性(包括构造函数)都将从那里查找。我们可以把这看作是生成对象和类属性。

截至2021年的最新浏览器(不是IE，请参阅MDN浏览器图表)实现了公共类字段，这似乎是你正在寻找的:

MyClass { 静态foo = 3; ｝ console.log (MyClass.foo);

然而，显然不可能使这是一个const:在ES6类中声明静态常量?

静态getter看起来非常接近:

MyClass { 静态获取CONST() { 返回3; ｝ ｝ MyClass。Const = 4;//财产不受影响 console.log (MyClass.CONST);

由于您的问题主要是风格上的(不想用一堆声明填充构造函数)，因此也可以从风格上解决。

The way I view it, many class based languages have the constructor be a function named after the class name itself. Stylistically we could use that that to make an ES6 class that stylistically still makes sense but does not group the typical actions taking place in the constructor with all the property declarations we're doing. We simply use the actual JS constructor as the "declaration area", then make a class named function that we otherwise treat as the "other constructor stuff" area, calling it at the end of the true constructor.

"use strict";

class MyClass
{
    // only declare your properties and then call this.ClassName(); from here
    constructor(){
        this.prop1 = 'blah 1';
        this.prop2 = 'blah 2';
        this.prop3 = 'blah 3';
        this.MyClass();
    }

    // all sorts of other "constructor" stuff, no longer jumbled with declarations
    MyClass() {
        doWhatever();
    }
}

在构造新实例时，两者都将被调用。

有点像有两个构造函数，你可以把声明和其他你想要执行的构造函数动作分开，并且在风格上让它不太难以理解这是在发生什么。

我发现当处理大量声明和/或大量需要在实例化时发生的操作并希望保持这两种思想彼此不同时，使用这种风格很好。

NOTE: I very purposefully do not use the typical idiomatic ideas of "initializing" (like an init() or initialize() method) because those are often used differently. There is a sort of presumed difference between the idea of constructing and initializing. Working with constructors people know that they're called automatically as part of instantiation. Seeing an init method many people are going to assume without a second glance that they need to be doing something along the form of var mc = MyClass(); mc.init();, because that's how you typically initialize. I'm not trying to add an initialization process for the user of the class, I'm trying to add to the construction process of the class itself.

While some people may do a double-take for a moment, that's actually the bit of the point: it communicates to them that the intent is part of construction, even if that makes them do a bit of a double take and go "that's not how ES6 constructors work" and take a second looking at the actual constructor to go "oh, they call it at the bottom, I see", that's far better than NOT communicating that intent (or incorrectly communicating it) and probably getting a lot of people using it wrong, trying to initialize it from the outside and junk. That's very much intentional to the pattern I suggest.

对于那些不想遵循这种模式的人来说，完全相反的方法也可以奏效。在开始时将声明传递给另一个函数。也许可以命名为“properties”或“publicProperties”之类的。然后把剩下的东西放在普通构造函数中。

"use strict";

class MyClass
{
    properties() {
        this.prop1 = 'blah 1';
        this.prop2 = 'blah 2';
        this.prop3 = 'blah 3';
    }

    constructor() {
        this.properties();
        doWhatever();
    }
}

请注意，第二种方法可能看起来更干净，但它也有一个固有的问题，即当使用该方法的类扩展另一个类时，属性会被覆盖。为了避免这种情况，您必须为属性提供更唯一的名称。我的第一个方法没有这个问题，因为它的伪构造函数的一半是以类唯一命名的。