Typescript static method in an abstract class to create an instance of self

Question

Let's say I have

abstract class Foo {

}

class Bar1 extends Foo {
    constructor(someVar) { ... }
}

class Bar2 extends Foo {
    constructor(someVar) { ... }
}

I'd like to be able to create a static method that creates an instance of the final class (all constructors would have the same signature). So I want something like:

abstract class Foo {
    public static someAction(someVar) {
        const self = new this(someVar);
    }
}

But this cannot be done because Foo is abstract. Is this at all possible?

UPDATE

What if these classes have their own templates?

abstract class Foo<M> {

}

class Bar1 extends Foo<SomeModel> {...}

Now I want the someAction to know of the type SomeModel. I tried

public static someAction<A, T extends Foo<A>>(this: new (someVar: any) => T, someVar: any): T {
    const self = new this(someVar);
    return self;
  }

But unless I specifically do Bar1.someAction<SomeModel>("blah") the returned result is not available of the type of the data, i.e. Bar1.someAction("blah") doesn't know the data type

Did you ever figure out the answer to your updated question? — Tom Daniel
– Tom Daniel, Commented Dec 30, 2020 at 1:46

Titian Cernicova-Dragomir · Accepted Answer · 2018-09-26 08:28:26Z

21

You can add an annotation for the this type of the static method. In this case this will refer to the class, and adding an annotation for the this parameter will make the static method visible only on classes that satisfy the constraint (in this case that a constructor with a single argument exists) and it will also help us extract the actual instance type of the class the method is invoked on :

abstract class Foo {
  public static someAction<T extends Foo>(this: new (someVar: any) => T, someVar: any): T {
    const self = new this(someVar);
    return self;
  }
}

class Bar1 extends Foo {

  constructor(someVar: any) {
    super();
  }
}

class Bar2 extends Foo {
  constructor(someVar: any) {
    super();
  }
}
let bar1 = Bar1.someAction(0) // of type Bar1
let bar2 = Bar2.someAction(0) // of type Bar2

answered Sep 26, 2018 at 8:28

Titian Cernicova-Dragomir

253k37 gold badges465 silver badges395 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Kousha Over a year ago

This works great! I have another question, that I'll follow up with an update on this question. Would be fantastic if you know that too!

Tom Daniel Over a year ago

@Titian I am also experiencing an issue like Kousha mentioned in his update when extending a class with a generic. The type ends up being the base class and not the subclass. Any insight would be greatly appreciated!

Danielle Madeley Over a year ago

But how do you access static properties from Foo.someAction. It now only knows this is a constructor. Declaring this as extends typeof Foo results instead in it saying abstract types are not constructable. Using an intersection seems to result in a lot of confusion regarding use of the constructor (I think due to how the generic is resolved).

giorgiline · Accepted Answer · 2022-09-28 04:36:45Z

It think this problem should be managed with the factory method pattern, and move the static method from the abstract class to the factory class.

So then you will have:

a factory class with the static method responsible for creating the specific classes.
an abstract class with the shared data, logic and the required abstract components to implement.
any extending classes with implementation of the corresponding abstract properties and methods from the parent class.

So starting the same way as you had,

there is an abstract class with the shared data,

abstract class Foo{
  constructor(someVar: any){
    ...
  }
}

and then there are some classes that extend the abstract class,

class Bar1 extends Foo {
  constructor(someVar: any){
    super(someVar)
  }
}

class Bar2 extends Foo {
  constructor(someVar: any){
    super(someVar)
  }
}

to create each of those classes based on parameters, it's easy to have a factory with the creational logic:

class BarFactory {
  public static barCreator(someVar: any): Bar1 | Bar2 {
    if(someVar.x === 'whatever'){
      return new Bar1(someVar)    
    } else {
      return new Bar2(someVar)  
    }
  }
}

At last you just get and use the instance using the factory.

const bar = BarFactory.barCreator(someVar)

All abstract properties and methods are directly available.

But f you want to use specific methods or properties of the instantiated class then you will need to check the instance type.

if (bar instanceof Bar1){
  ...
} else {
  ...
}

Tom Daniel · Accepted Answer · 2020-12-30 03:31:46Z

After some monkeying around I found a way to address your problem with generics.

The key is to not use a type variable in the extends constraint for the base class but to add the base class with the type variable as an intersection of the return type.

Use any instead of T here static someAction<A, T extends Foo<any>> and to add & Foo<A> on the return type.

abstract class Foo<M> {...}

class Bar1 extends Foo<SomeModel> {...}

public static someAction<A, T extends Foo<any>>(
    this: new (someVar: any) => T, someVar: any
): T & Foo<A> {
    return new this(someVar);
}

I was facing the exact same issue while trying to create a user defined type guard, and the same technique above also solve this problem.

public static isThisType<A, T extends Foo<any>>(
    this: new (...args: any) => T, value: unknown
): value is T & Foo<A> {
    return value instanceof this;
}

Collectives™ on Stack Overflow

Typescript static method in an abstract class to create an instance of self

3 Answers 3

3 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related