The advantage of saying

SomeClass.prototype.variable = value;

is that it’s completely dynamic — the variable does not have to have been declared as a property in SomeClass.as, and it can be set by any code outside the class — and it can be accessed as though it were a property of any instance of SomeClass or of any derived class — either by declaring the class dynamic, or by using the bracket notation:

someClassInstance["variable"]

A protected variable would have to have been declared in the class file, would have to be set on every instance that needs it, and cannot be accessed from unrelated code.

To be more specific about a use case, consider a specific function that a game character must execute whenever he arrives at any Flower, whether it be a Daisy or a Pansy or whatever derived class instance. If I set

Flower.prototype.myTask = flowerTask;

then on arrival, my character can call

target["myTask"]();

and the flowerTask is the one that will be executed if the target is any Flower derivative. Of course every potential target class has myTask defined on its prototype or on an ancestor prototype; I set a default myTask on Sprite.prototype to cover the undefined cases.

Eh, isn’t the answer here “protected”, or am I not following you correctly?

My question was really about using a function instead of a class as a constructor. And that indeed does look rather useless.