2018年更新：

现在有一个第 3 阶段的提案 - 我期待在几个月内使这个答案过时。

同时，任何使用 TypeScript 或 babel 的人都可以使用以下语法：

varName = value

在类声明/表达式主体内，它将定义一个变量。希望在几个月/几周后，我将能够发布更新。

更新：Chrome 74 现在附带此语法。

ES wiki 中关于 ES6（最大最小类）提案的注释：

（有意）没有直接的声明方式来定义原型数据属性（方法除外）类属性或实例属性

类属性和原型数据属性需要在声明之外创建。

类定义中指定的属性被赋予与它们出现在对象文字中相同的属性。

这意味着您的要求已被考虑，并明确决定反对。

但为什么？

好问题。TC39 的好人希望类声明来声明和定义类的功能。不是它的成员。ES6 类声明为其用户定义了它的契约。

请记住，类定义定义了原型方法——在原型上定义变量通常不是您要做的。你当然可以使用：

constructor(){
    this.foo = bar
}

在您建议的构造函数中。另见共识摘要。

ES7 及更高版本

ES7 的一项新提案正在制定中，通过类声明和表达式允许更简洁的实例变量 - https://esdiscuss.org/topic/es7-property-initializers

只是为了补充本杰明的答案——类变量是可能的，但你不会prototype用来设置它们。

对于真正的类变量，您需要执行以下操作：

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

从一个类方法中，该变量可以作为this.constructor.foo（或MyClass.foo）访问。

这些类属性通常不能从类实例访问。即MyClass.foo给出'bar'但是new MyClass().foo是undefined

如果您还想从实例访问类变量，则必须另外定义一个 getter：

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

MyClass.foo = 'bar';

我只用 Traceur 测试过这个，但我相信它在标准实现中也能正常工作。

JavaScript 并没有真正的类。即使在 ES6 中，我们也在寻找一种基于对象或原型的语言，而不是基于类的语言。在任何function X () {}，X.prototype.constructor点回X。当new运算符用于 on 时X，将创建一个继承的新对象X.prototype。从那里查找该新对象（包括）中的任何未定义属性constructor。我们可以将其视为生成对象和类属性。

Babel支持 ESNext 中的类变量，查看这个例子：

class Foo {
  bar = 2
  static iha = 'string'
}

const foo = new Foo();
console.log(foo.bar, foo.iha, Foo.bar, Foo.iha);
// 2, undefined, undefined, 'string'

在你的例子中：

class MyClass {
    const MY_CONST = 'string';
    constructor(){
        this.MY_CONST;
    }
}

由于 MY_CONST 是原始的https://developer.mozilla.org/en-US/docs/Glossary/Primitive我们可以这样做：

class MyClass {
    static get MY_CONST() {
        return 'string';
    }
    get MY_CONST() {
        return this.constructor.MY_CONST;
    }
    constructor() {
        alert(this.MY_CONST === this.constructor.MY_CONST);
    }
}
alert(MyClass.MY_CONST);
new MyClass

// alert: string ; true

但是如果MY_CONST是像static get MY_CONST() {return ['string'];}警报输出这样的引用类型是string, false。在这种情况下，delete操作员可以解决问题：

class MyClass {
    static get MY_CONST() {
        delete MyClass.MY_CONST;
        return MyClass.MY_CONST = 'string';
    }
    get MY_CONST() {
        return this.constructor.MY_CONST;
    }
    constructor() {
        alert(this.MY_CONST === this.constructor.MY_CONST);
    }
}
alert(MyClass.MY_CONST);
new MyClass

// alert: string ; true

最后对于类变量不是const：

class MyClass {
    static get MY_CONST() {
        delete MyClass.MY_CONST;
        return MyClass.MY_CONST = 'string';
    }
    static set U_YIN_YANG(value) {
      delete MyClass.MY_CONST;
      MyClass.MY_CONST = value;
    }
    get MY_CONST() {
        return this.constructor.MY_CONST;
    }
    set MY_CONST(value) {
        this.constructor.MY_CONST = value;
    }
    constructor() {
        alert(this.MY_CONST === this.constructor.MY_CONST);
    }
}
alert(MyClass.MY_CONST);
new MyClass
// alert: string, true
MyClass.MY_CONST = ['string, 42']
alert(MyClass.MY_CONST);
new MyClass
// alert: string, 42 ; true

由于您的问题主要是文体问题（不想用一堆声明填充构造函数），因此也可以在文体上解决。

在我看来，许多基于类的语言的构造函数是一个以类名本身命名的函数。在风格上，我们可以使用它来创建一个在风格上仍然有意义的 ES6 类，但不会将构造函数中发生的典型操作与我们正在执行的所有属性声明组合在一起。我们简单地使用实际的 JS 构造函数作为“声明区域”，然后创建一个名为函数的类，否则我们将其视为“其他构造函数”区域，在真正的构造函数的末尾调用它。

“严格使用”；

我的课堂
{
    // 只声明你的属性，然后调用 this.ClassName(); 从这里
    构造函数（）{
        this.prop1 = '等等 1';
        this.prop2 = '等等 2';
        this.prop3 = '等等 3';
        this.MyClass();
    }

    // 各种其他“构造函数”的东西，不再与声明混淆
    我的课（） {
        做任何事情（）；
    }
}

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

有点像拥有 2 个构造函数，您可以在其中将声明和其他要执行的构造函数操作分开，并且在风格上使人们不难理解这也是正在发生的事情。

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

注意：我非常有目的地不使用典型的“初始化”（如 aninit()或initialize()方法）的惯用概念，因为它们的用法通常不同。构造和初始化的想法之间存在某种假定的差异。使用构造函数的人知道它们作为实例化的一部分被自动调用。看到一个init方法，许多人会不假思索地假设他们需要按照 的形式做一些事情var mc = MyClass(); mc.init();，因为这就是您通常初始化的方式。我不是在尝试为类的用户添加初始化过程，而是在尝试添加到类本身的构建过程中。

虽然有些人可能会暂时重复拍摄，但这实际上是重点：它向他们传达了意图是构建的一部分，即使这让他们做了一些重复拍摄并继续“那不是ES6 构造函数是如何工作的”，然后再看一下实际的构造函数，“哦，他们在底部调用它，我明白了”，这比不传达该意图（或错误地传达它）要好得多，并且可能会得到很多人们使用它错误，试图从外部和垃圾初始化它。这对我建议的模式非常有意。

对于那些不想遵循这种模式的人，完全相反的方法也可以。在开始时将声明转移到另一个函数。也许将其命名为“properties”或“publicProperties”或其他名称。然后把剩下的东西放在普通的构造函数中。

“严格使用”；

我的课堂
{
    特性（） {
        this.prop1 = '等等 1';
        this.prop2 = '等等 2';
        this.prop3 = '等等 3';
    }

    构造函数（）{
        this.properties();
        做任何事情（）；
    }
}

请注意，这第二种方法可能看起来更简洁，但它也有一个固有问题，即properties使用此方法扩展另一个类时会被覆盖。您必须提供更多独特的名称properties才能避免这种情况。我的第一个方法没有这个问题，因为它的构造函数的假一半是以类唯一命名的。