Is there a method to categorize class methods' parameters in a universally applicable manner?

Question

Is there a method to categorize class methods' parameters in a universally applicable manner?

Consider the code snippet below.

class MyClass {
  method1(arg1: string, arg2: number, arg3: number) {}
    
  method2(arg1: string, arg2: number, arg3: number) {}
}

I want to abstract out the argument types

arg1: string, arg2: number, arg3: number

for reuse.
Although not functional, the example below illustrates my intention.

interface MyClassMethodArgs {
  arg1: string;
  arg2: number; 
  arg3: number;
}

interface MyClass {
  // How can I represent "arg1: string, arg2: number, arg3: number" as MyClassMethodArgs?
  method1(arg1: string, arg2: number, arg3: number): void;
  method2(arg1: string, arg2: number, arg3: number): void;
}

class MyClassImpl implements MyClass {
  // How can I avoid repeating the type definitions of MyClass here?
  method1(arg1, arg2, arg3) {}
    
  method2(arg1, arg2, arg3) {}
}

typescript

Answer 1

Answer №1

One possible approach is as follows:

type ThreeNumFunction = (a: number, b: number, c: number) => void

class NewClass {
  func1: ThreeNumFunction = (a, b, c) => {
    // ...
  };
  func2: ThreeNumFunction = (a, b, c) => {
    // ...
  };
}

It's worth noting that this method creates new functions for each instance of the class rather than referencing existing ones within the class itself. This can impact performance and memory usage. In most cases, unless complex method signatures are required or explicit binding to instances is needed, the slight duplication may not be a major concern.

Furthermore, it's important to understand that achieving similar results with an interface is not feasible due to the inability to infer parameter types from method signatures within the interface:

interface NewInterface {
  func1: ThreeNumFunction;
  func2: ThreeNumFunction;
}

// Parameters are implicitly of type 'any'
class AnotherClass implements NewInterface {
  func1(a, b, c) {
    // ...
  }
  func2(a, b, c) {
    // ...
  }
}

Interactive Code Sample

Answer 2

One possible approach is as follows:

type ThreeNumFunction = (a: number, b: number, c: number) => void

class NewClass {
  func1: ThreeNumFunction = (a, b, c) => {
    // ...
  };
  func2: ThreeNumFunction = (a, b, c) => {
    // ...
  };
}

It's worth noting that this method creates new functions for each instance of the class rather than referencing existing ones within the class itself. This can impact performance and memory usage. In most cases, unless complex method signatures are required or explicit binding to instances is needed, the slight duplication may not be a major concern.

Furthermore, it's important to understand that achieving similar results with an interface is not feasible due to the inability to infer parameter types from method signatures within the interface:

interface NewInterface {
  func1: ThreeNumFunction;
  func2: ThreeNumFunction;
}

// Parameters are implicitly of type 'any'
class AnotherClass implements NewInterface {
  func1(a, b, c) {
    // ...
  }
  func2(a, b, c) {
    // ...
  }
}

Interactive Code Sample

Is there a method to categorize class methods' parameters in a universally applicable manner?

Answer №1

Similar questions

Sending information from a parent component to a child component within an Angular application

Event listener for iframe video player click in Angular 2+

Creating a TypeScript generic type for the "pick" function to define the types of values in the resulting object

The rule result is invalid due to the occurrence of the Function()

Customizable parameters in a React component

Receiving feedback from an http.post request and transferring it to the component.ts file in an Angular

Guide on Linking a Variable to $scope in Angular 2

The declaration file (d.ts) is unable to access the type declaration

Changes were made to React Context, however, the components are not reflecting these updates

What is the best way to create a type that excludes the character 'a' from a string?

Creating an object with mapped properties from enumeration values using Typescript

Tips for managing local storage asynchronously

Encountering an issue while trying to npm install, can someone offer some assistance?

The 'required' validator in Mongoose seems to be malfunctioning

Retrieving a Promise's value for an HTML Element

Arranging data in a table by date with "."

modification of class into hooks, receiving error message 'then' property is not found in type '(dispatch: any) => Promise<void>'

Developing a constructor method that is conscious of data types

Filtering Typescript by property values of an interface that match its own values

Having trouble importing an object from another file in Typescript?