Typescript: instance of an abstract class

Question

I have an abstract class Router:

export abstract class Router {
}

And an interface like this

interface IModule {
    name: string;
    forms: Array<IForm>,
    route: typeof Router
}

Now I have a class which looks like this, and many others based on Router abstract

export class Module1 extends Router {
}

Now, I want to instantiate the route like this:

let module: IModule = { 
    name: "My Module",
    forms: [],
    route: Module1
}

let router = new module.route(); 
// TS2511: Cannot create an instance of an abstract class.

The code run just fine, and the instance of router = new Module1() is made properly, but I obviously doesn't write it properly in Typescript because I see TS2511: Cannot create an instance of an abstract class. when transpiling.

What is the correct way to define this?

are you sure Module1 implements all the abstract method defined in Router?? — Massimo Costa
– Massimo Costa, Commented Sep 16, 2018 at 20:38
I realize this is an older question, but I ran into the same issue recently, and found a way that is clean and type-safe using more recent TypeScript features (at the time the question was asked and answered, it was just merged so it wasn't well-known). For people visiting, please see my answer below. — goose_lake
– goose_lake, Commented Jan 31 at 9:29

Titian Cernicova-Dragomir · Accepted Answer · 2018-09-17 06:09:14Z

27

When you have an abstract class, it's constructor is only invokable from a derived class, since the class is abstract and should not be instantiated. This carries over when you type something as typeof AbstractClass, the constructor will not be callable.

The solution would to be to not use typeof Router but rather a constructor signature that returns a Router

interface IModule {
    name: string;
    forms: Array<IForm>,
    route: new () => Router
}

Another solution if you need to access static methods of Router is to create an interface derived from typeof Router which will erase the abstractness of the constructor:

export abstract class Router {
    static m(): void { console.log("Router"); }
}
type RouterClass = typeof Router;
interface RouterDerived extends RouterClass { }

interface IModule {
    name: string;
    route: RouterDerived
}

export class Module1 extends Router {
    static m(): void { console.log("Module1"); }
}

let module: IModule = { 
    name: "My Module",
    route: Module1
}

module.route.m();
let router = new module.route();

edited Sep 17, 2018 at 6:09

answered Sep 16, 2018 at 20:39

Titian Cernicova-Dragomir

253k37 gold badges465 silver badges395 bronze badges

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

4 Comments

spinkus Over a year ago

Wait. I copied and pasted the code above (playground) and still get the same "Cannot create an instance of an abstract class." error.

Henrique Bruno Over a year ago

Same issue as @semisecure

Meron Over a year ago

This solution is outdated, It doesn't work with TypeScript 4.4.3, but it works with TypeScript 3.9.9.

jon Over a year ago

and what solution for 4.4> ?

spinkus · Accepted Answer · 2021-05-28 04:46:20Z

10

Note, second part of the accepted answer covers:

if you need to access static methods of Router ...

The proposed solution doesn't actually work. Just spent fair bit of time trying to figure this out so though I'd add: the way to do this is:

type RouterDerived = {new (): Router} & typeof Router;

Full example playground.

edited May 28, 2021 at 4:46

answered May 28, 2021 at 3:30

spinkus

8,7604 gold badges44 silver badges74 bronze badges

2 Comments

Victor Schröder Over a year ago

I guess it should be new () => Router (instead of :), shouldn't it?

Benoît Lahoz Over a year ago

Unfortunately it doesn't work when new must accept parameters, new(...args: any[]).

Parzh · Accepted Answer · 2024-05-16 08:48:04Z

Your intention is to say that .route property of IModule is any class (a.k.a constructor, a.k.a new-able function) that returns an instance derived from Router, while the following definition:

interface IModule {
    route: typeof Router
}

… basically says that .route is the Router class itself (this is not exactly true but it is fine for our intents and purposes). Since Router class is abstract, and abstract classes cannot be instantiated, you get an error:

new module.route()
// Error: Cannot create an instance of an abstract class

You need to fix the definition from "the Router constructor itself" to "any class that returns an instance derived from Router". You can do it in two ways.

If you do it loosely (similar to setting the type to any or unknown), you get the basic functionality you need, but you can't use methods and properties of the actual constructor you provide there, because you don't give this information to TypeScript:

interface IModule {
    route: new () => Router
}

const module: IModule = {
    route: Module1,
}
 
new module.route()

Try it

Alternatively, you can do it strictly (similar to specifying an exact type of a variable), which would mean creating a type argument, which would mean defining IModule as a generic:

interface IModule<R extends new () => Router> {
    route: R
}

const module: IModule<typeof Module1> = { 
    route: Module1
}

new module.route()

Try it

goose_lake · Accepted Answer · 2025-01-31 11:11:12Z

In short, the type-safe and non-duplicating way to define type for a non-abstract contructor of the same signature as given abstract class is new (...args: ConstructorParameters<typeof AbstractClass>) => AbstractClass;. See TS docs. So for case in this question, it would be:

let module: IModule = { 
    name: "My Module",
    forms: [],
    route: new (...args: ConstructorParameters<typeof Router>) => Router
}

Longer explanation:

What existing answers don't mention is the case when a constructor of the base class has a non-empty signature, i.e.

abstract class Router {
  constructor(name: string) {
  }
}
export class Module1 extends Router {
}

, creating a type with new () => Router won't work, as the new () function needs params in the definition. As suggested in a comment, it's possible to use new (...args: any[]) => Router, but that erases the type-safety of constructor, and allows calling it with any arbitrary arguments, potentially leading to issues. Defining the new () signature manually, like so new (name: string) => Router, leads to code duplication, as you're defining the same signature in two places.

That's why the ConstructorParameters<T> utility type is needed.

Collectives™ on Stack Overflow

Typescript: instance of an abstract class

4 Answers 4

4 Comments

2 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

4 Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related