Create an instance of a class from a group of subclasses, all the while retaining the ability to access static members in Types

Question

Create an instance of a class from a group of subclasses, all the while retaining the ability to access static members in Types

I seem to have encountered a dilemma where I am looking to have both the static and abstract keywords used for a member of an abstract class in TypeScript, but it appears that this combination is not supported.

The nearest workaround I could come up with is shown below:


        abstract class A {
        
            s: string;
            n: number;
            static identifier: string;
        
            constructor(s: string, n: number) {
                this.s = s;
                this.n = n;
            }
        
        }
        
        class B extends A {
        
            static identifier: string = "B";
        
        }
        
        class C extends A {
        
            static identifier: string = "C";
        
        }
        
        function identifyAndInstantiate(identifier: string, classes: (typeof A)[]) {
        
            var identifiedClass = classes.find((classCandidateConstructor: typeof A) => { return identifier == classCandidateConstructor.identifier });
            if (!identifiedClass) return;
            
            //error here: Cannot create an instance of an abstract class.(2511)
            var instance = new identifiedClass("foo", 12);
        
        }
        
        var classes: (typeof A)[] = [
            B,
            C

I've experimented with different collection types to solve this issue. The most successful approach I found was using a Map from the static member type to instances of the class, but it required manually mapping the values to their respective classes.

Another tactic I attempted was utilizing a Newable<T> type that defines its constructor, but this resulted in losing access to the subclass' static properties (as did other methods that exposed the constructor).

Is there a way to access both a subclass' static properties and its constructor after retrieving it from a collection of classes?

typescript types abstract-class abstract typescript-types

Answer 1

Answer №1

Explanation

To differentiate between subclasses (such as B, C) within a collection, an abstract property is defined in the base abstract class (A) and implemented in each concrete subclass. This allows for unique identifiers for each subclass.

Simple Code Example

abstract class A {
  static id: string;

  abstract someMethod(): void;
}

class B extends A {
  static id = 'B';

  someMethod(): void {
    console.log('Method in B');
  }
}

class C extends A {
  static id = 'C';

  someMethod(): void {
    console.log('Method in C');
  }
}

function bar(subclassId: string, subclassesOfA: (typeof A)[]): void {
  let subclass = subclassesOfA.find(sub => sub.id === subclassId);

  if (subclass) {
    let instance = new subclass();
    instance.someMethod();
  } else {
    console.error('Subclass not found');
  }
}

// Example usage
bar('B', [B, C]); // Output: Method in B
bar('C', [B, C]); // Output: Method in C

Breakdown

Each concrete subclass (B, C, etc.) defines a static id property.
The abstract base class (A) declares a static identifier property that must be implemented by each subclass.
The bar function creates an instance of the matching subclass based on the provided identifier and an array of subclass constructors.

By utilizing static properties and constructors along with an abstract property for identification, the subclasses can be easily distinguished within a collection.

Answer 2

Explanation

To differentiate between subclasses (such as B, C) within a collection, an abstract property is defined in the base abstract class (A) and implemented in each concrete subclass. This allows for unique identifiers for each subclass.

Simple Code Example

abstract class A {
  static id: string;

  abstract someMethod(): void;
}

class B extends A {
  static id = 'B';

  someMethod(): void {
    console.log('Method in B');
  }
}

class C extends A {
  static id = 'C';

  someMethod(): void {
    console.log('Method in C');
  }
}

function bar(subclassId: string, subclassesOfA: (typeof A)[]): void {
  let subclass = subclassesOfA.find(sub => sub.id === subclassId);

  if (subclass) {
    let instance = new subclass();
    instance.someMethod();
  } else {
    console.error('Subclass not found');
  }
}

// Example usage
bar('B', [B, C]); // Output: Method in B
bar('C', [B, C]); // Output: Method in C

Breakdown

Each concrete subclass (B, C, etc.) defines a static id property.
The abstract base class (A) declares a static identifier property that must be implemented by each subclass.
The bar function creates an instance of the matching subclass based on the provided identifier and an array of subclass constructors.

By utilizing static properties and constructors along with an abstract property for identification, the subclasses can be easily distinguished within a collection.

Answer 3

Answer №2

Your code is almost correct, but a few modifications need to be made:

To reference `subclass.identifier`, ensure that the property exists in the type of `subclassesOfA`
You cannot create an instance of `typeof A`, but you can create an instance of `{ new(): A }`

function foo(subclassIdentifier: string, subclassesOfA: {
  identifier: string,
  new (): A
}[]): void {
    let subclass = subclassesOfA.find((subclass) =>
        subclass.identifier == subclassIdentifier);
    if (subclass) {
        let instance = new subclass();
       // ...
    }
}

Answer 4

Your code is almost correct, but a few modifications need to be made:

To reference `subclass.identifier`, ensure that the property exists in the type of `subclassesOfA`
You cannot create an instance of `typeof A`, but you can create an instance of `{ new(): A }`

function foo(subclassIdentifier: string, subclassesOfA: {
  identifier: string,
  new (): A
}[]): void {
    let subclass = subclassesOfA.find((subclass) =>
        subclass.identifier == subclassIdentifier);
    if (subclass) {
        let instance = new subclass();
       // ...
    }
}

Create an instance of a class from a group of subclasses, all the while retaining the ability to access static members in Types

Answer №1

Explanation

Simple Code Example

Breakdown

Answer №2

Similar questions

Just starting out with React and encountering the error: Invalid element type, a string was expected

The concept of passing arguments in Typescript

Produce new lines of code using the vscode.window.activeTextEditor.edit method in Visual Studio Code

Property of object (TS) cannot be accessed

The input of type 'Observable<true | Promise<boolean>>' cannot be assigned to the output of type 'boolean | UrlTree | Observable<boolean | UrlTree> | Promise<boolean | UrlTree>'

What is the best way to transform this date string into a valid Firestore timestamp?

"Resulting in 'undefined' due to an asynchronous function call

Is there a way to loop through objects in Angular 2

Using create-react-app with TypeScript for server-side rendering

Jest tests reveal potential errors indicating an object may be null

Compile time extraction of constant string from type field

Issue with MongoDB $push within an Array of Arrays: The shorthand property 'elements' does not have a value available in scope

Transmitting image data (blob) from the frontend to the backend using Next.js and tRPC (T3 stack)

I am unable to utilize Local Storage within NextJS

Is there a way to enable code completion for Firebase on VS Code?

Error in Typescript: Draggable function is undefined

Issues arising from an aging Angular project

I have successfully set up micro-cors on my system, and as I tried to compile, I received the following outcome

Encountering Thumbnail Type Error While Implementing Swiper in Next.js

Merge two input fields into one to send data to the backend