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

Dynamically loading classes in TypeScript without using default export

The Angular Ivy strictTemplates error message states that the type 'Event' cannot be assigned to the type 'InputEvent' parameter

Tips on exporting a basic TypeScript class in an Angular 4 module

What is the purpose of the 'unique' keyword in TypeScript?

What is the best way to retrieve a specific property from an array of objects in Angular 6 using typescript?

Internet Explorer is throwing unexpected routing errors in Angular 2

Is it possible to enable full screen window functionality in Angular 2 by simply clicking a button? Let's find out

Navigating through object keys in YupTrying to iterate through the keys of an

Learning the process of configuring neo4j connection details without relying on environment variables

Error: The identifier HTMLVideoElement has not been declared

Designing functional components in React with personalized properties utilizing TypeScript and Material-UI

What could be the reason for the component not receiving data from the service?

Adjusting the IntelliSense Functionality in Monaco Editor

Tips for accessing a URL page in Ionic 3 without using the ionic-native plugin

Using string interpolation within the onclick event (Ionic 2 + Angular 2)

Encountering a problem with TypeScript while employing Promise.allSettled

retrieve document data from firestore using the service

Tips for invoking a function from one React component to another component

Update the data and paginator status

What is the best method for choosing visible elements within a scrollable container?