这将是一个相对较长的问题，但我真的很想了解。问题底部制定的最终问题。

我已经阅读了这个问题的答案:
ES6 class variable alternatives

关于为什么这在 ES6 中不被接受的语法的问题:

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

1)第一个答案提到:

Remember, a class definition defines prototype methods - defining variables on the prototype is generally not something you do.

我不明白；基于类的语言中的静态变量看起来与 JS 中原型(prototype)上定义的属性具有相同的目的。
显然不是像人名这样的实例变量，但它可以是车辆的默认 MAX_SPEED，或者是所有实例共享的计数器。如果实例没有覆盖原型(prototype)的 MAX_SPEED，它将返回到默认值。这不是静态变量的确切目的吗？

2) 以下post (ES6 规范提案)制定:

There is (intentionally) no direct declarative way to define either prototype data properties (other than methods) class properties, or instance property. Class properties and prototype data properties need be created outside the declaration.

我没有看到在类本身(在构造函数之外)中声明/初始化具有默认值的实例/类变量的实际区别？如果它在原型(prototype)上有什么关系？如果它涉及一个具有默认值的实例变量，该默认值可能适用于所有实例(但可覆盖)，我看不出问题是什么。那么这个意图到底是什么？

3)ES6 class variable alternatives问题的第二个答案让我感到困惑(虽然不是来自技术 pov)。

From within a class method that variable can be accessed as this.constructor.foo (or MyClass.foo).

These class properties would not usually be accessible from to the class instance. i.e. MyClass.foo gives 'bar' but new MyClass().foo is undefined

这表明很明显可以在类(或底层函数)上声明一个类变量，如本例中所实现的:http://www.es6fiddle.net/iehn0hxp/

class Car{
  constructor(){
    //Set instance variable 
    this.instance_var = 220; 
    //Set class variable 
    this.constructor.class_var = 240; 
  }
}

var Mercedes = new Car(); 
var Audi = new Car(); 

//Instance property 
console.log(Mercedes.instance_var); //220 
//Class property 
console.log(Car.class_var); //240

//Set instance property 
Mercedes.instance_var = 120; //Well I don't know really :-) 
console.log(Mercedes.instance_var); //120 

//Class property 
Car.class_var = 140; 
console.log(Car.class_var); //140 
//Can be accessed from the constructor property on the instance
console.log(Mercedes.constructor.class_var); //140 
console.log(Audi.constructor.class_var); //140 

所以最终是可以在类中声明一个静态属性；所以我看不出在构造函数中声明它与仅在类中定义它以及从外部定义它有什么区别？最后，将它作为实际的类定义放在构造函数中似乎只是一个微不足道的技术修改(结果将是相同的)。

仅使方法可用真的只是一种设计选择吗？
终极问题:

Because I don't understand how being a prototype-language changes the philosophy of having properties on the prototype against static variables on a class. It looks the same to me.

我希望我的问题很清楚，如果没有就大声说出来。

最佳答案

I don't get this; static variables in a class based language would appear to serve the same purpose as properties defined on the prototype in JS.

不，静态变量更像是在构造函数 上定义的属性。原型(prototype)上的变量将更接近实例变量，但它们几乎没有那么有用，因为它们在实例之间共享。 (因此，如果您修改原型(prototype)上的可变属性，它将反射(reflect)在该类型的所有其他实例中。)

我认为这也回答了您的其他问题，但回顾一下:

• 原型(prototype)上的变量不像静态变量，因为它们似乎属于每个实例而不仅仅是类

• 原型(prototype)上的变量不像实例变量，因为类的每个实例都没有自己的变量实例

• 因此，原型(prototype)上的变量没有那么有用，它们应该分配给构造函数(实例变量)或分配构造函数(类变量)

• 它们也是属性，不是变量

还有一个非 ES6 加糖的例子:

function Something() {
    this.instanceProperty = 5;
}

Something.staticProperty = 32;

Something.prototype.prototypeProperty = 977;

var s = new Something();
console.log(s.instanceProperty); // 5
console.log(s.prototypeProperty); // 977? If you want a class property,
                                  // this is not what you want
console.log(s.staticProperty); // undefined; it’s not on the instance
console.log(Something.staticProperty); // 32; rather, it’s on the class
console.log(Something.prototypeProperty); // undefined; this one isn’t

关于javascript - ES6 类/实例属性，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32545495/