Is it possible to create an 'abstract class' in Javascript?

Question

When creating a Javascript class whose attributes and methods are all static (for example, for storing preset settings for a game), I wonder if it is possible to define the class as abstract in a similar way to what can be accomplished in other languages (where the clause 'Abstract' is available or you can simply set the constructor as protected).

In other words: recital this example available in Jsfiddle, Is it possible to prevent the construction of instances of the 'Statictest' class (line 36)? If the constructor (line 7) is not defined, the code does not execute (generating the exception "Uncaught Referenceerror: Statictest is not defined").

// INICIO - Apenas para evitar poluir o espaço global
(function(){

    /**
     * Construtor da classe (é realmente necessário?).
     */
    var AbstractTest = function() {
    };

    /**
     * Atributo com o texto de teste.
     */
    AbstractTest.Attribute = "O atributo diz: Olá Planeta!";

    /**
     * Método que retorna o texto do teste.
     * @return String com o texto de teste.
     */
    AbstractTest.Method = function() {
        return "O método diz: Olá Mundo!";
    }

    // Atribui a classe ao escopo global 'window'
    window.AbstractTest = AbstractTest;

// FIM - Apenas para evitar poluir o espaço global
}());

/**
 * Função de teste de instanciação.
 * @return String com o texto de teste de uma instância criada.
 */
window.testInstantiation = function() {

    // A dúvida é sobre a possibilidade de impedir a execução dessa linha:
    var oTest = new AbstractTest();

    oTest.Attribute = "O atributo na nova instância diz: Olá Brasil!";
    return oTest.Attribute + " e " + AbstractTest.Attribute;
}

Note: the question is only a curiosity about the characteristics of language; not that the possibility of class instantiation is necessarily a problem.

EDIT: Changed to correct and use the term "abstract" instead of "static".

Answer 1

It is possible to create a immutable object in Javascript through the method Object.freeze, and a immutable reference through the method Object.defineProperty:

// Atribui a classe ao escopo global 'window'
Object.freeze(StaticTest);
Object.defineProperty(window, "StaticTest", { 
    value:StaticTest,
    configurable:false,
    writable:false
});

// Todas essas tentativas vão falhar silenciosamente:
// (ou lançar uma exceção, se o modo "strict" estiver ativado)
StaticTest = outroObjeto;
window.StaticTest = outroObjeto;
StaticTest.StaticAttribute = outroValor;
delete StaticTest.StaticAttribute;

As to prevent an object from being inherited, I don’t know any way of doing that, and I don’t think it’s possible at all.

Classical vs. Prototypical OO

Notice you asked about classes, but I gave my answer by just talking about objects. Why? Simply because, strictly speaking, Javascript does not have the concept of "classes".

In classical object orientation, used by the vast majority of languages that follow this paradigm, classes and objects (or instances) are distinct concepts: the class defines the "structure" and "behavior" of its objects, and each object belongs to a single class. Class inherits from class, so that instances of the specific class have similar structure and behavior to instances of the general class.

In the prototypical OO, there are only objects. An object defines its own structure and behavior, independently of the others. To reuse these features in other objects, they inherit directly of the existing object (here called prototype), modifying what you want and keeping (sharing) the rest. There are no classes, only construction functions.

Javascript heritage

For historical reasons, although conceptually Javascript is a language that follows the prototypical OO, its syntax attempts to "hide" the fact - making it more similar to the classical one. The result is a "salad", as shown below:

// Objeto simples: sem classe, sem construtor
var obj = {
    atributo:"planeta",
    metodo:function() {
        return "Olá, " + this.atributo + "!";
    }
}

// Construindo um objeto que herda de "obj"
function herdarDeObj() { }
herdarDeObj.prototype = obj;

var obj2 = new herdarDeObj();
alert(obj2.metodo()); // "Olá, planeta!"
obj2.atributo = "mundo";
alert(obj2.metodo()); // "Olá, mundo!"

alert( obj.isPrototypeOf(obj2) ); // true
alert( obj === Object.getPrototypeOf(obj2) ); // true

// Sintaxe confusa
alert( obj === obj2.prototype ); // false
alert( obj2.prototype ); // undefined

alert( obj === herdarDeObj.prototype ); // true
alert( obj === Object.getPrototypeOf(herdarDeObj) ); // false
alert( Object.getPrototypeOf(herdarDeObj) ); // function Empty() {}
                                             // (varia conforme o browser)

alert( obj2 instanceof obj ); // false
alert( obj2 instanceof herdarDeObj ); // true
herdarDeObj.foo = "bar";
alert( obj2.foo ); // undefined
obj.foo = "baz";
alert( obj2.foo ); // "baz"

As you can see, we have two objects obj and obj2 in which the second inherits from the first (or: the first is the prototype of the second). However, Javascript "hides" this simple relation, forcing us to create a constructor method, assign it the property prototype and invoke it through the keyword new.

But note that obj is not prototype of herdarDeObj - he is prototype of the built objects through the command new herdarDeObj(). The constructor is a normal function, so much so that its prototype is the "empty function".

Probably due to this fact (from the constructor define everything about the object - both the initial attributes, placed in the constructor body through this.atr = val, as for the prototype, the one from whom the object will inherit) people confuse it with the "class" of the object. And for the convenience that this constructor method offers, rarely does anyone use [explicitly] prototypic inheritance in practice, so much so that there are plans to introduce the concepts of classical OO in future versions of Javascript. Maybe someday, what you ask is actually possible.

Completion

Since there are no Javascript classes, it makes no sense to talk about "static classes" (not even "static attributes" or "class attributes"). If you want to expose a collection of attributes and methods using a given name, it is most natural to do so using a simple object:

window.StaticTest = {
    StaticAttribute:"O atributo estático diz: Olá Planeta!",
    StaticMethod:function() {
        return "O método estático diz: Olá Mundo!";
    }
};

You can make the object and reference immutable, as I explained, but you cannot prevent other objects from inheriting from it: anyone can create a new constructor function, assign StaticTest as his prototype and call this function - producing objects they inherit from StaticTest.

Answer 2

There is serious confusion here about concepts of classes and members (attributes) in the question.

Static attributes

They are those that, regardless of the instance of the class/function used, return the same value or object instance.

The best example of this in Javascript is the use of prototype, as we can see in the @mgibsonbr reply.

Immutable, invariant or constant objects

We mustn’t confuse static with immutable. In Java, for example, an immutable attribute or variable is declared with final and not with static.

In javascript, it seems that the best option is the Object.freeze, as seen in @mgibsonbr’s reply.

Visibility

The question cited the question of preventing the external instantiation of the class. In languages like Java, this is obtained by creating a constructor private. See, again, that this has nothing to do with the concepts of static or immutable.

Completion

To achieve your goal, use a single configuration, my suggestion is simply to use a global variable.

There are some more advanced techniques for implementing the Singleton project standard in Javascript (here, here and here), but if you have control of the code, just set an access standard if you follow it throughout the development. There is no technique to save you from not following your own design, so don’t spend too much time protecting your code from yourself.

On the other hand, for the creation of libraries, frameworks and Apis the story is another.

Answer 3

In Javascript there are no static classes, properties or methods. Closest to this are properties and methods assigned directly to a constructor (as you did), or a simple literal object.

If you use a literal object to define StaticTest, then new StaticTest() will generate a Typeerror. It is a way to solve the problem (with try..catch around the line that generates the exception).

Another way is to change the return of the constructor. I don’t understand exactly what you want in the test, but it is possible to return the object itself StaticTest, or any other object:

var StaticTest = function() {
    // return StaticTest;
    // ou
    // return {};
};

But be careful: if you try to return a value that is not an object (such as false), the builder will return this, that is, the newly created instance.

---

Considering its edition that exchanges "static" for "abstract", I think the best output would be to even use a literal object, since the intention is to avoid instantiation:

var StaticTest = {
    attribute: "O atributo diz: Olá Planeta!",
    method: function(){}
    // etc.
};

Thus, StaticTest would generate an exception, which you can capture with try..catch:

try {
    new StaticTest();
} catch(e) {
    // trate a exceção aqui
}

Answer 4

One way to build an abstract "class" with the usual inheritance of Javascript prototypes is by using a constructor like the following:

/**
 * Construtor da classe abstrata.
 * @abstract
 * @constructor
 */
var Base = function() {
    if (this.constructor === Base) {
      throw new Error("Não pode instanciar classe abstrata!");
    }

    // .... código do construtor
};

The Czech constructor if it was called directing (as in new Base()) with the property constructor, and makes an exception if it happened.

This "class" can only be used if it is derived:

/**
 * Construtor da classe derivada.
 * @constructor
 */
var Derived = function() {
    Base.apply(this, arguments);
};

Derived.prototype = Object.create(Base.prototype);
Derived.prototype.constructor = Derived;

The derived class calls the constructor of the base class with apply, and creates its prototype based on the base class with Object.create. It is also very important to assign the constructor correctly to Derived, otherwise you will not be able to create instances of Derived.

A more extensive example can be found here.

Note the use of Jsdoc @abstract.