I have a JS class with utility static methods. Consider the following case:
class A{
static util(){
//do something
}
some_method(){
//cumbersome
this.constructor.util();
}
};
class B extends A{
static util(){
//overrides super.util
//does something different
}
};
I'm using static method as a means to manage util functions, since it is easily overridable within an extended subclass. But the problem is that the way to access them is rather lengthy. Is there a shorthand, or a creative way to make it more manageable?
Instead of using static methods, I could resort to re-writing all the affected methods in the subclass and swap all the util functions, but that would be a shotgun surgery and will result in a very unmanageable code, so I want to avoid that as much as possible.
You could make a more concise alias for constructor at the parent class level. Not sure if this is enough of an improvement to make it worthwhile...
class A {
static util() {
console.log('a')
}
static otherUtil() {
console.log('not overridden');
}
get klass() {
return this.constructor;
}
some_method() {
// less cumbersome??
const klass = this.klass;
klass.util();
klass.otherUtil();
}
};
class B extends A {
static util() {
console.log('b')
}
};
let b = new B()
b.some_method()If I understood what you need, you can create a constructor for each class and bind its own util function to a class attribute called _util. Then you can just do this._util():
class A{
constructor() {
this._util = A.util
}
static util(){
console.log("util A")
}
some_method(){
this._util();
}
};
class B extends A{
constructor() {
super();
this._util = B.util
}
static util(){
console.log("util B")
}
};
new A().some_method()
new B().some_method()