What is the best way to ensure a class method in typescript strictly adheres to a specific function type interface?

Question

What is the best way to ensure a class method in typescript strictly adheres to a specific function type interface?

In the process of writing a class, I have noticed that many methods within it share a common function type. To ensure consistency, I want to explicitly define this function type so that specific methods adhere to it.

For example:

interface MyFunctionType {(resource: string | Resource): Something}

My class consists of various methods that align with this interface.

class MyClass {
    // ...

    someMethod() { /*...*/ }

    someMethodThatConforms(resource: string | Resource) {
        // ...
        return new Something(/*...*/);
    }

    anotherMethodThatConforms(resource: string | Resource) {
        // ...
        return new Something(/*...*/);
    }

    someOtherMethod() { /*...*/ }

    // ...
}

I am aware that someMethodThatConforms and anotherMethodThatConforms conform to the interface. Now, I want to understand how can I enforce that these methods must adhere to the MyFunctionType interface (so that any changes to MyFunctionType will result in errors being thrown)?

typescript

Answer 1

Answer №1

If creating another interface is not your preference, here's an alternative approach:

interface MyFunctionType {(resource: string | Resource): Something}

class MyClass {
    // ...

    someMethod() { /*...*/}

    public someMethodThatConforms: MyFunctionType = (resource: string | Resource) => {
        // ...
        return new Something(/*...*/);
    }

    public anotherMethodThatConforms: MyFunctionType = (resource: string | Resource) => {
        // ...
        return new Something(/*...*/);
    }

    someOtherMethod() { /*...*/}

    // ...
}

Answer 2

If creating another interface is not your preference, here's an alternative approach:

interface MyFunctionType {(resource: string | Resource): Something}

class MyClass {
    // ...

    someMethod() { /*...*/}

    public someMethodThatConforms: MyFunctionType = (resource: string | Resource) => {
        // ...
        return new Something(/*...*/);
    }

    public anotherMethodThatConforms: MyFunctionType = (resource: string | Resource) => {
        // ...
        return new Something(/*...*/);
    }

    someOtherMethod() { /*...*/}

    // ...
}

Answer 3

Answer №2

We can establish a new interface by having MyClass carry out its implementation:

interface MyFunctionDefinition {(resource: string | Resource): Something}

interface FixedMethods {
    someMethodThatAdheres: MyFunctionDefinition;
    // additional methods can be included
}

class MyClass implements FixedMethods {
    someMethodThatAdheres(resource: string | Resource) {
        // this function will not pass the type check until we return a Something
        return 1;
    }
}

A more intricate approach: utilize mapped types to construct a generic type:

interface MyFunctionDefinition { (resource: string | Resource): Something }

// A Mapped Type for correcting methods, used instead of an interface
type FixedMethods<T extends string> = {
    [k in T]: MyFunctionDefinition
}

class MyClass implements FixedMethods<"someMethodThatAdheres" | "anotherMethodThatAdheres"> {
    someMethodThatAdheres(resource: string | Resource) {
        // this method will fail type checking until we return a Something
        return 1;
    }

    // It will also signal an error due to the absence of "anotherMethodThatAdheres" method
}

Answer 4

We can establish a new interface by having MyClass carry out its implementation:

interface MyFunctionDefinition {(resource: string | Resource): Something}

interface FixedMethods {
    someMethodThatAdheres: MyFunctionDefinition;
    // additional methods can be included
}

class MyClass implements FixedMethods {
    someMethodThatAdheres(resource: string | Resource) {
        // this function will not pass the type check until we return a Something
        return 1;
    }
}

A more intricate approach: utilize mapped types to construct a generic type:

interface MyFunctionDefinition { (resource: string | Resource): Something }

// A Mapped Type for correcting methods, used instead of an interface
type FixedMethods<T extends string> = {
    [k in T]: MyFunctionDefinition
}

class MyClass implements FixedMethods<"someMethodThatAdheres" | "anotherMethodThatAdheres"> {
    someMethodThatAdheres(resource: string | Resource) {
        // this method will fail type checking until we return a Something
        return 1;
    }

    // It will also signal an error due to the absence of "anotherMethodThatAdheres" method
}

What is the best way to ensure a class method in typescript strictly adheres to a specific function type interface?

Answer №1

Answer №2

Similar questions

What does an exclamation mark signify in Angular / Type Script?

Tips on retrieving enum values in typescript

What is the best way to extract a variable value from the subscribe method and make it available for use in an Angular 10 service method's return statement using TypeScript?

The selectors in NgRx store are failing to retrieve data from the main global store

Ensure that Template.fromStack() includes resources with the specified logical identifiers

What methods can I use to locate the circular dependency within my program?

Retrieve a specific subdirectory from the bundle

Collaborative Vue component: Clients need to manually import the CSS

TypeScript implementation of internationalization message extraction in Create React App

How to initiate a refresh in a React.js component?

Creating JSON from an array by grouping common values.Would you like another rewrite?

The Array of Objects is not being generated from Action and Effects

Tips for correctly annotating objects to address the issue of potentially being 'null'

Experiencing issues with npm while debugging: Error code ELIFECYCLE and error number 1 have occurred

Error message: Vercel is unable to locate the module or its corresponding type declarations when running the command "npm run build"

Tips for testing FormGroupDirective within a component

Cannot locate metadata for entity: Node.js TypeScript TypeORM

numerous slices of toasted bread for the latest version of Ionic

React Native bottom tab navigator not changing between tabs

Exploring intricate JSON data in Angular 4 applications