Propriétés de classe / instance ES6

Ce sera une question relativement longue, mais j'aimerais vraiment comprendre. Question finale formulée au bas de la question.

J'ai lu les réponses à cette question:
Alternatives de classe variable ES6

La question de savoir pourquoi cette syntaxe n'est pas acceptée dans ES6:

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

1) La première réponse mentionne:

Rappelez-vous, une définition de classe définit des méthodes prototypes: définir des variables sur le prototype n'est généralement pas quelque chose que vous faites.

Je n'obtiens pas cela; Les variables statiques dans une langue basée sur la classe semblent servir le même but que les propriétés définies sur le prototype dans JS.
Évidemment, pas une variable d'instance comme le nom d'une personne, mais il pourrait s'agir d'un MAX_SPEED par défaut pour un véhicule ou d'un compteur partagé par toutes les instances. Si l'instance ne remplace pas le prototype MAX_SPEED, il revient à la valeur par défaut. N'est-ce pas le but exact d'une variable statique?

2) Le post suivant (proposition de spécification ES6) formule:

Il existe (intentionnellement) aucun moyen déclaratif direct de définir les propriétés de la propriété des prototypes (autres que les méthodes) ou la propriété de l'instance. Les propriétés de la classe et les propriétés des prototypes de données doivent être créées en dehors de la déclaration.

Je ne vois pas la différence réelle dans la déclaration / l'initialisation d'une variable instance / classe avec une valeur par défaut dans la classe elle-même (en dehors du constructeur)? Qu'importe si c'est sur le prototype? Si cela concerne une variable d'instance avec une valeur par défaut qui sera vraisemblable pour toutes les instances (mais surpassable), je ne vois pas quel est le problème. Alors, quelle est cette intention exactement?

3) La deuxième réponse à la question des variantes de classe ES6 qui me confond (mais pas à partir d'un pov technique).

Dans une méthode de classe, cette variable peut être consultée comme this.constructor.foo (ou MyClass.foo ).

Ces propriétés de classe ne seraient généralement pas accessibles à partir de l'instance de classe. C'est-à-dire MyClass.foo donne 'bar' mais new MyClass().foo est undefined

Cela indique qu'il est clairement possible de déclarer une variable de classe sur la classe (ou la fonction sous-jacente) telle que mise en œuvre dans cet exemple: 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

Donc, en fin de compte, il est possible de déclarer une propriété statique dans la classe; Donc je ne vois pas quelle est la différence qui le déclare dans le constructeur, plutôt que de le définir sur la classe, en la définissant de l'extérieur? En fin de compte, cela semble être une modification technique banale pour le mettre dans le constructeur vs comme une définition de classe réelle (le résultat sera le même).

Est-ce vraiment un choix de conception pour ne rendre disponibles que les méthodes?
Question ultime:

Parce que je ne comprends pas comment être un prototype, la langue change la philosophie d'avoir des propriétés sur le prototype contre les variables statiques sur une classe. Cela me paraît le même.

J'espère que ma question est claire, criez sinon.

Je n'obtiens pas cela; Les variables statiques dans une langue basée sur la classe semblent servir le même but que les propriétés définies sur le prototype dans JS.

Non, les variables statiques ressemblent davantage à des propriétés définies sur le constructeur . Les variables sur le prototype seraient plus proches des variables d'instance, mais elles ne sont pas aussi utiles car elles sont partagées entre les instances. (Donc, si vous modifiez une propriété mutable sur le prototype, elle sera reflétée dans toutes les autres instances de ce type).

Cela répond également à vos autres questions, je pense, mais à récapituler:

Les variables sur le prototype ne sont pas comme des variables statiques dans la mesure où elles semblent appartenir à chaque instance plutôt que simplement la classe
Les variables sur le prototype ne sont pas comme des variables d'instance dans la mesure où chaque instance de la classe n'a pas sa propre instance de la variable
Par conséquent, les variables sur le prototype ne sont pas utiles et doivent être affectées dans le constructeur (variables d'instance) ou attribuées au constructeur (variables de classe)
Ils sont également des propriétés, pas des variables

Et un exemple non-ES6-Sugared:

 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