Переменные класса в Javascript

Если вы создаете экземпляр этого класса (a = new classA), то изменение этого экземпляра a не изменит сам базовый класс. Экземпляры classA унаследуют все от classA.prototype, но это не применяется в обратном направлении, изменение a не изменит classA.
Если у вас есть два экземпляра, например a1 = new classA и a2 = new classA, вы можете вносить изменения как в a1, так и в a2, не влияя на другой. С другой стороны, изменение classA.prototype будет видно в обоих из них. Переменная shared экземпляра a будет иметь значение по умолчанию, пока ей не будет присвоено новое значение. Значение по умолчанию - значение classA.prototype.shared.

Вы просто помещаете член прямо в «класс», который в JavaScript является функцией, конструирующей объекты:

function ClassA(x) { this.x = x; }
ClassA.shared = "";
ClassA.prototype.foo = function() {
    return ClassA.shared + this.x;
}

var inst1 = new ClassA("world");
var inst2 = new ClassA("mars");

ClassA.shared = "Hello ";
console.info(inst1.foo());
console.info(inst2.foo());
ClassA.shared = "Good bye ";
console.info(inst1.foo());
console.info(inst2.foo());

Если вы хотите иметь переменную класса, что-то вроде статической переменной в Java, вы можете объявить переменную в родительском классе, но тогда вы не должны обращаться к ней как к переменной дочерних объектов. эта статья имеет хороший пример класса Circle, имеющего переменную Circle.PI = 3.14, в то время как все экземпляры Circle обращаются к нему как к Circle.PI (вместо c.PI).

Итак, мой ответ таков: если вы хотите иметь переменную класса shared в classA, вы должны объявить переменную, совместно используемую в classA, а позже вы должны использовать classA.shared вместо a.shared. Замена a.shared никогда не приведет к изменению classA.shared.

Статические (на уровне класса) переменные можно сделать так:

function classA(){
    //initialize
}

classA.prototype.method1 = function(){
    //accessible from anywhere
    classA.static_var = 1;
    //accessible only from THIS object
    this.instance_var = 2;
}

classA.static_var = 1;  //This is the same variable that is accessed in method1()

Ваш вывод кажется странным из-за того, как javascript обрабатывает прототипы. Вызов любого метода / получение переменной экземпляра объекта сначала проверяет экземпляр, ЗАТЕМ прототип. т.е.

var a = new classA();
classA.prototype.stat = 1;

// checks a.stat which is undefined, then checks classA.prototype.stat which has a value
alert(a.stat); // (a.stat = undefined, a.prototype.stat = 1)

// after this a.stat will not check the prototype because it is defined in the object.
a.stat = 5;  // (a.stat = 5, a.prototype.stat = 1)

// this is essentially a.stat = a.stat + 1;
a.stat++; // (a.stat = 6, a.prototype.stat = 1) 

Увеличение свойства shared через экземпляр делает его свойством этого экземпляра, поэтому вы наблюдаете такое поведение.

Сделав это, вы никогда не получите доступ к прототипу этого свойства через экземпляр, а только к его собственному свойству.

>>> function ConstructorA() {};
>>> ConstructorA.prototype.shared = 0;
>>> var a = new ConstructorA();
>>> ConstructorA.prototype.shared++;
>>> a.shared
1
>>> a.hasOwnProperty("shared")
false
>>> a.shared++;
>>> a.hasOwnProperty("shared")
true

Вот почему правильным решением является использование ConstructorA.shared, как предлагалось до сих пор во многих ответах, и всегда доступ к нему через функцию конструктора, а не экземпляр.

Было бы полезно подумать о том, что в JavaScript нет такой вещи, как класс. «Экземпляры», созданные с помощью оператора new, - это просто объекты, которые были созданы определенной функцией-конструктором и имеют определенную цепочку прототипов. Вот почему a.shared не сможет получить доступ к ConstructorA.shared - доступ к свойству включает просмотр рассматриваемого объекта для названного свойства и, в случае неудачи, обход его цепочки прототипов в поисках свойства, но функция-конструктор, создавшая объект, не является t часть цепочки прототипов.

То, что вы определяете, не является переменной класса, это значение по умолчанию для переменной экземпляра.

Переменные класса должны быть определены непосредственно в классе, то есть непосредственно в функции-конструкторе.

function ClassA()
{
    ClassA.countInstances = (ClassA.countInstances || 0) + 1;
}
var a1 = new ClassA();
alert(ClassA.countInstances);
var a2 = new ClassA();
alert(ClassA.countInstances);

Когда вы объявляете переменную в прототипе, эта переменная будет унаследована всеми экземплярами как переменные экземпляра (точно так же, как методы) и будет иметь приоритет, если вы измените ее в экземпляре (точно так же, как методы).

I assumed that since prototypes will be shared between objects then so will their variables.

Они есть, но это:

a.shared++

не делает то, что вы думаете. Фактически (приблизительно) сахарный синтаксис для:

(a.shared= a.shared+1)-1

(-1 означает возврат значения до приращения, а не то, что вы на самом деле используете значение повторного выполнения, но все же.)

Так что на самом деле это присваивается a.shared. Когда вы назначаете член экземпляра, вы всегда пишете собственным членам этого экземпляра, нет касается любых элементов любого из его прототипов. Это то же самое, что сказать:

classA.prototype.shared= 1;
a.shared= 2;

Итак, ваш новый a.shared скрывает prototype.shared, не изменяя его. Другие экземпляры classA продолжат показывать значение прототипа 1. Если вы удалите a.shared, вы снова сможете увидеть скрытую за ним переменную прототипа.

Это потому, что прототипы не являются определениями классов. Прототипные переменные не являются статическими переменными. Подумайте о слове «прототип». Это не модель, используемая для создания объекта - это пример объекта, который нужно продублировать.