Exploring TypeScript by defining a parent class with identical methods but varying constructors

Question

Exploring TypeScript by defining a parent class with identical methods but varying constructors

Here is the code snippet I am currently working on:

class X {
    constructor(
        private _x: number,
    ) {}

    method1() {}
    method2() {}
}

class Y {
    constructor(
        private _y: number,
    ) {}

    method1() {}
    method2() {}
}

class Z {
    constructor(
        private _z: number,
    ) {}

    method1() {}
    method2() {}
}

let itemList = [new X(1), new Y(2), new Z(3)];
itemList.forEach((item: any) => {
    item.method1();
})

I have these three classes (X, Y, and Z) each with different constructors and methods that share the same name.

How can I specify a specific type other than any in TypeScript to ensure that method1 is recognized by the compiler?

typescript class object oop inheritance

Answer 1

Answer №1

Essentially, the solution was hinted at in the comments, but since the answer wasn't provided, here's the most direct approach: creating a new type.

class A {
    constructor(
        private _a: number,
    ) {}

    public commonMethod() {
      console.log("A")
    }
}

class B {
    constructor(
        private _b: number,
    ) {}

    public commonMethod() {
      console.log("B")
    }
}

class C {
    constructor(
        private _c: number,
    ) {}

    public commonMethod() {
      console.log("C")
    }
}

type letters = A | B | C

let list = [new A(1), new B(2), new C(3)];
list.forEach((element: letters) => {
    element.commonMethod();
})

Answer 2

Essentially, the solution was hinted at in the comments, but since the answer wasn't provided, here's the most direct approach: creating a new type.

class A {
    constructor(
        private _a: number,
    ) {}

    public commonMethod() {
      console.log("A")
    }
}

class B {
    constructor(
        private _b: number,
    ) {}

    public commonMethod() {
      console.log("B")
    }
}

class C {
    constructor(
        private _c: number,
    ) {}

    public commonMethod() {
      console.log("C")
    }
}

type letters = A | B | C

let list = [new A(1), new B(2), new C(3)];
list.forEach((element: letters) => {
    element.commonMethod();
})

Exploring TypeScript by defining a parent class with identical methods but varying constructors

Answer №1

Similar questions

Distinguishing between Javascript Array Objects and Array-Like Objects: An Elucidation

Exploring JSON Array Data and Its Sub-Properties in React

An error is triggered by the EyeDropper API stating that 'EyeDropper' has not been defined

Angular 14: Enhance Your User Experience with Dynamic Angular Material Table Row Management

How to modify a specific item in a React list using TypeScript

Spacing Problem with Title Tooltips

tsconfig.json respects the baseUrl for absolute imports inconsistently

Is passing data through interfaces a suitable practice in TypeScript?

What is the best way to iterate through an array and dynamically output the values?

The Azure function application's automatic reload feature does not function properly with the v4 model

Implementing JavaScript Code in TypeScript

Enhance your ReactJS form with added values

Having trouble obtaining React 15.6.1 type definitions: "ERROR: Repository not found."

Using Conditional Types in Supabase Query results in the TypeScript error, "Type is incompatible with type 'never'."

What is the best way to verify if the text values of a collection of DOM-nodes in an array match a specific string

Is there a way in typescript to transform empty strings into null values?

What are the methods used in TypeScript to implement features that are not available in JavaScript, despite TypeScript ultimately being compiled to JavaScript?

Looking to develop a dynamic password verification form control?

Variable storing an array of strings in TypeScript with React JS

Is there a way to deactivate keyup loopback in Angular 2?