I'm looking for a way to implement an abstract static method in TypeScript.
Here an example:
abstract class A {
abstract static b (): any // error
}
class B extends A {
static b () {}
}
This is allowed with public, private and protected methods but not with a static method. TypeScript returns the following error:
'static' modifier cannot be used with 'abstract' modifier.ts(1243)
Is there any workaround?
Another way to handle this type of scenarios, could be to introduce a runtime check. The idea is to provide a default implementation that obviously won't work, and rely on runtime errors to throw error if the derived class hasn't overridden the method.
abstract class A {
static myStaticMethod(): any {
throw new Error('Method not implemented! Use derived class');
}
}
class B extends A {}
B.myStaticMethod(); // error: Method not implemented...
That can hint you to override the static method.
class B extends A {
static override myStaticMethod(): any {
console.log('yay!');
}
}
B.myStaticMethod(); // yay!
I think the reasoning is generally as follows:
Abstract methods are placeholders that a concrete subclass is supposed to implement.
The abstract base class will have a concrete method which uses this abstract placeholder, and thus requires it to be implemented; without this, abstract methods make little sense at all. E.g.:
abstract class Foo {
bar() {
return this.baz() + 1;
}
abstract baz(): int;
}
This can only be called on a concrete instance, e.g.:
function (foo: Foo) {
let val = foo.bar();
...
}
The result will be different here depending on what concrete subclass of Foo you get, but it's all guaranteed to work.
Now, what would this look like with static methods?
abstract class Foo {
static bar() {
return this.baz() + 1;
}
abstract static baz(): int;
}
function (F: typeof Foo) {
let val = F.bar();
...
}
This looks somewhat logical and like it should work, shouldn't it? But:
typeof typing. So, why?static method does instantiate an object, if it acts as an alternative constructor—which is entirely legitimate—then calling F.bar() to get a new instance, you'd expect to get an instance of F, but you might be getting an instance of some subclass of it. And that's arguably not desired.To rephrase the chain of argument here:
static methods at all, they should act as alternative constructors and return an instance, otherwise they have little business being part of the class.F.bar() and not getting an instance of exactly F is… weird?abstract static method, either as direct alternative constructor nor as helper function for one, since that would lead to a violation of one of the above points one way or another.As far as I see, this is pretty much the classical thinking that lead to abstract static methods not being a thing. Certain technical limitations in Java may have contributed to that and/or lead to said technical limitations in the first place.
In Javascript one can argue that this makes less sense, since even classes are objects and it would be entirely feasible to use them as described above, and in certain situations it may even make sense. But here we are.
One solution I came up with to have a static method and to make sure it's implemented via the type check system was to declare a static method that calls an abstract method on the prototype.
abstract class Foo {
static get Bar() {
return this.prototype.bar;
}
abstract bar();
}
You could even provide a custom this arg to the non-static version to remind that it won't have this defined yet:
abstract bar(this?: Foo | undefined);
I solved it the following way:
interface Selectors<N> {
selectName(node: N): string | undefined;
}
const selectors: Selectors<object> = {
selectName(node: object) {
return "my name is node";
},
};
This is obviously not the same as an abstract static class, but depending on what you are going to do with it, this might be a good solution!
