Suggestion: static constructors

[omidkrad]

A static constructor is a function that is run only once when the class is loaded. It can be used to initialize static class members and maybe as entry point to the application.

Suggested syntax is:

class MyClass {
    static initialized = false;

    static constructor() {
        MyClass.initialized = true;
    }
}

alert(MyClass.initialized);

That would be same as the following:

class MyClass {
    static initialized = false;

    static __ctor = (() => {
        MyClass.initialized = true;
    })();
}

alert(MyClass.initialized);

Except that __ctor does not need to be assigned to the class in the output code, and only needs to be invoked in an anonymous function. Also compiler can check that no more than one static constructor is defined in a class.

Update: Since this generates an Immediately-Invoked Function Expression (IIFE), compiler should make sure to move it to the end of the class definition in the output JavaScript.

TypeScript:

class MyClass {
    static constructor() {
        MyClass.initialized = true;
    }

    static initialized = false;
}

Expected JavaScript output:

var MyClass = (function () {
    function MyClass() {
    }
    MyClass.initialized = false;

    // run last
    (function () {
        MyClass.initialized = true;
    })();
    return MyClass;
})();

Note that body of the static constructor is moved to the bottom and invoked.

Related suggestion in codeplex: Please add static constructors to classes

[basarat]

👍

[ahejlsberg]

You can already accomplish this with a merged class/module:

class MyClass {
    static initialize() {
        // Initialization
    }
}
module MyClass {
    MyClass.initialize();
}

Or, for that matter, you can just have the call to initialize immediately follow the class declaration:

class MyClass {
    static initialize() {
        // Initialization
    }
}
MyClass.initialize();

[omidkrad]

Pleasure hearing from Mr. Hejlsberg...

The only limitation I see there is that you can't make it private, whereas in my example you can :)

[knazeri]

👍 for class/module merge suggestion

[NoelAbrahams]

The merged class/module code requires that the developer remember to call MyClass.initialise().

The suggestion I believe is that given the following:

class MyClass {
    static initialized = false;

    static constructor() {
        MyClass.initialized = true;
    }
}

We get JavaScript

var MyClass = (function () {
    function MyClass() {
    }
    MyClass.initialized = false;

    MyClass.__ctor = (function () {
        MyClass.initialized = true;
    })();
    return MyClass;
})();

[omidkrad]

@NoelAbrahams Yes, good point about having to remember to call it in the merged class/module pattern.

However, @ahejlsberg's code has the benefit that call to the static method is made at the very end when the class is completely loaded. I updated the suggestion above to reflect that. The static constructor syntax should only generate an anonymous function invocation at the end of the JavaScript class output.

[DanielRosenwasser]

Privacy is a good point here, but it's worth pointing out that you can be a little "evil" to achieve the same goal without having to modify the language. ;)

class C {
    private static initialize(): void {
        // do stuff
        C.initialize = undefined;
    }
}
(<any>C).initialize();

You can even replace C.initialize = undefined with delete C.initialize if you're afraid someone will iterate over your class in a for..of loop.

But yes, here the user is still responsible with calling initialize.

[omidkrad]

The suggested static constructor syntax remains to be superior IMO and has best of everything: 😌

• Does not pollute the class structure (even better than private)
• Does not need the developer to remember to call it
• Makes sure it is invoked last
• Makes sure a class does not have multiple static constructors
• Provides a convention, and
• It is concise and intuitive

[RyanCavanaugh]

Closing as Too Complex - we would need a more compelling use case since module merging provides a very close approximation to the desired behavior.