Stop certain sections of Typescript code from being compiled

Question

Stop certain sections of Typescript code from being compiled

In my scenario, I have two classes: class A and class B. Class B extends class A. The issue arises when we consider a method in both classes. Class A has a method that accepts AProperties enum as its first argument. However, class B has a similar method that accepts either AProperties or BProperties enum as its first argument.

enum AProperties {
    X,
    Y
}

enum BProperties {
    Z,
    W
}

class A {
    setProperty(property: AProperties, value: number) {

    }
}

class B extends A {
    setProperty(property: AProperties | BProperties, value: number) {

    }
}

It seems redundant to have the setProperty method in class B, since it is identical to the one in class A. This method is only added for the TypeScript editor to recognize that it can accept both AProperties and BProperties. However, when the code is compiled to JavaScript, having setProperty in class B serves no purpose.

Is there a way to prevent this redundant method from being included in the JavaScript compilation? Perhaps adding a comment before the method could effectively address this issue.

typescript

Answer 1

Answer №1

One way to work around the issue of skipping code without commenting it out in the compiler is by structuring your code in a way that avoids the need to implement the method in the child class. Take a look at this example:

enum AProperties {
    X,
    Y
}

enum BProperties {
    Z,
    W
}

class Base<T> {
    setProperty(property: T, value: number) {
        // ...
    }
}

class A extends Base<AProperties> {}

class B extends Base<AProperties | BProperties> {}

In this approach, a separate class (Base) is introduced to contain the implementation of setProperty, which is then extended by A and B to specify the type of the property enum.

You can also explore a potential feature that suggests default generic types to simplify the code, like this:

class A<T = AProperties> {
    setProperty(property: T, value: number) {}
}

class B extends Base<AProperties | BProperties> {}

However, until this feature is implemented, the Base class will still be required.

Edit

Alternatively, here's another solution that eliminates the need for the extra class (Base):

interface Base<T> {
    setProperty(property: T, value: number);
}

class A implements Base<AProperties> {
    setProperty(property: AProperties, value: number) {
        // ...
    }
}

class B implements Base<AProperties | BProperties> {
    setProperty: (property: AProperties | BProperties, value: number) => void;
}

let a = new A();
a.setProperty(AProperties.X, 4);

let b = new B();
b.setProperty(AProperties.X, 4);
b.setProperty(BProperties.W, 4);

Answer 2

One way to work around the issue of skipping code without commenting it out in the compiler is by structuring your code in a way that avoids the need to implement the method in the child class. Take a look at this example:

enum AProperties {
    X,
    Y
}

enum BProperties {
    Z,
    W
}

class Base<T> {
    setProperty(property: T, value: number) {
        // ...
    }
}

class A extends Base<AProperties> {}

class B extends Base<AProperties | BProperties> {}

In this approach, a separate class (Base) is introduced to contain the implementation of setProperty, which is then extended by A and B to specify the type of the property enum.

You can also explore a potential feature that suggests default generic types to simplify the code, like this:

class A<T = AProperties> {
    setProperty(property: T, value: number) {}
}

class B extends Base<AProperties | BProperties> {}

However, until this feature is implemented, the Base class will still be required.

Edit

Alternatively, here's another solution that eliminates the need for the extra class (Base):

interface Base<T> {
    setProperty(property: T, value: number);
}

class A implements Base<AProperties> {
    setProperty(property: AProperties, value: number) {
        // ...
    }
}

class B implements Base<AProperties | BProperties> {
    setProperty: (property: AProperties | BProperties, value: number) => void;
}

let a = new A();
a.setProperty(AProperties.X, 4);

let b = new B();
b.setProperty(AProperties.X, 4);
b.setProperty(BProperties.W, 4);

Stop certain sections of Typescript code from being compiled

Answer №1

Edit

Similar questions

Deleting a button from a list item or array in Angular 12

What is the proper way to define a tuple type with a specific size N for the vector class in C++?

Guide on incorporating external .d.ts files for a module

Switching between PascalCase and camelCase in TypeScript leads to unexpected behavior

Using custom hooks in JSX triggers a TypeScript error when the returned component is accessed

Tips on changing the date format in Typescript to the desired format

Semantic-ui-react cannot be located by Docker

What is the best way to utilize the next-env.d.ts file within Next.js?

Cannot perform table inserts or creates with NestJS Sequelize functionality

Go through a collection of Observables and store the outcome of each Observable in an array

In Next.js, the Typescript compiler does not halt when an error occurs

Can a constant be utilized as the property name within routerLink when specifying queryParams?

Issue encountered: "ERROR TypeError: Upon attempting to patchValue in ngOnInit(), the property 'form' is undefined."

What is the best way to declare a TypeScript type with a repetitive structure?

Angular 2: Utilize the select event to fetch and return the selected item

Issue with custom HTML5 video progress bar not syncing with video playback

Generate user-customized UI components from uploaded templates in real-time

Checking to see if the prop 'isChecked' has been modified

Why do the async functions appear to be uncovered branches in the Jest/Istanbul coverage report?

The absence of the 'profileStore' property is noticed in the '{}' type, which is necessary in the 'Readonly<AppProps>' type according to TypeScript error code ts(2741)