Discovering class methods in typescript

Question

Discovering class methods in typescript

Currently, I am running TypeScript unit tests using Mocha Chai after configuring the compiler options to ts-node.

Within one of my unit tests, I am seeking a way to retrieve all methods from a utility class that I have designed and execute the same set of tests on each method. To provide a clearer picture, I aim to accomplish the following:

UtilityClass.getMethods().forEach(method=>{method(sameInputData)})

Is there a graceful approach to implementing getMethods? Alternatively, are there other strategies available to address this requirement?

typescript

Answer 1

Answer №1

Struggling with finding solutions that worked for me, I realized there was a lack of information on achieving the desired outcome without creating an instance.

After some experimentation, here is what I devised:

SomeClass.ts

import { route } from "../../lib/route_decorator";

export class SomeClass {
    index() {
        console.log("here");
    }
}

And in somefile.ts

let ctrl = require("./filepath/filename");
// Since angular exports as `exports.SomeClass = SomeClass;`
ctrl = ctrl[Object.keys(ctrl)[0]];
let ctrlObj = new ctrl();

// Accessing properties from Class without instance
console.log(Reflect.ownKeys(ctrl.prototype));
// Accessing properties from instance
console.log(Reflect.ownKeys(Object.getPrototypeOf(ctrlObj)));

This method successfully outputs:

[ 'constructor', 'index' ]
[ 'constructor', 'index' ]

Answer 2

Struggling with finding solutions that worked for me, I realized there was a lack of information on achieving the desired outcome without creating an instance.

After some experimentation, here is what I devised:

SomeClass.ts

import { route } from "../../lib/route_decorator";

export class SomeClass {
    index() {
        console.log("here");
    }
}

And in somefile.ts

let ctrl = require("./filepath/filename");
// Since angular exports as `exports.SomeClass = SomeClass;`
ctrl = ctrl[Object.keys(ctrl)[0]];
let ctrlObj = new ctrl();

// Accessing properties from Class without instance
console.log(Reflect.ownKeys(ctrl.prototype));
// Accessing properties from instance
console.log(Reflect.ownKeys(Object.getPrototypeOf(ctrlObj)));

This method successfully outputs:

[ 'constructor', 'index' ]
[ 'constructor', 'index' ]

Answer 3

Answer №2

Keep in mind that TypeScript is essentially a variant of Javascript. The TypeScript compiler translates your code into Javascript.

Therefore, just like you would in regular Javascript, you can list object members in this manner:

UtilityClass myclass = ...;

for (var member in myclass) { /* do something */ }

Going a step further

If you want to ensure you only access directly owned members:

for (var member in myclass) {
  if (myclass.hasOwnProperty(member)) {
    /* do something */
  }
}

Isolating methods

If you specifically wish to isolate methods (functions):

for (var member in myclass) { // For each member of the dictionary
  if (typeof myclass[member] == "function") { // Is it a function?
    if (myclass.hasOwnProperty(member)) { // Not inherited
      // do something...
    }
  }
}

Reflection in TypeScript

These techniques require an instance to operate on, not the class itself. Achieving true Reflection within the realm of OOP is the goal, but Javascript (non-OOP by nature) addresses this concept differently.

Answer 4

Keep in mind that TypeScript is essentially a variant of Javascript. The TypeScript compiler translates your code into Javascript.

Therefore, just like you would in regular Javascript, you can list object members in this manner:

UtilityClass myclass = ...;

for (var member in myclass) { /* do something */ }

Going a step further

If you want to ensure you only access directly owned members:

for (var member in myclass) {
  if (myclass.hasOwnProperty(member)) {
    /* do something */
  }
}

Isolating methods

If you specifically wish to isolate methods (functions):

for (var member in myclass) { // For each member of the dictionary
  if (typeof myclass[member] == "function") { // Is it a function?
    if (myclass.hasOwnProperty(member)) { // Not inherited
      // do something...
    }
  }
}

Reflection in TypeScript

These techniques require an instance to operate on, not the class itself. Achieving true Reflection within the realm of OOP is the goal, but Javascript (non-OOP by nature) addresses this concept differently.

Answer 5

Answer №3

Andry's solution is effective for ES3/ES5, but using ES6 and inheritance can lead to some quirky behavior...

Below is a more intricate example demonstrating how to access different types of methods in the case of ES6:

class ParentTest {
    parentFoo = function() {
        // perform actions
    }

    parentBar() {
        // perform actions
    }
}

class Test extends ParentTest {
    foo = function() {
        // perform actions
    }

    bar() {
        // perform actions
    }
}

let instance = new Test();

// Both of these approaches work similarly for every method declared as a property of type "function"
for(let method in instance) {
    console.log(method); // foo, foo2
}
console.log(Object.keys(instance)); // Array [ "parentFoo", "foo" ]

// This approach is suitable for methods within the class
let protoOfTest = Object.getPrototypeOf(instance);
console.log(Object.getOwnPropertyNames(protoOfTest)); // Array [ "constructor", "bar" ] 

// This method is used for accessing methods from the superclass
let protoOfParentTest = Object.getPrototypeOf(protoOfTest);
console.log(Object.getOwnPropertyNames(protoOfParentTest)); // Array [ "constructor", "parentBar" ]

Answer 6

Andry's solution is effective for ES3/ES5, but using ES6 and inheritance can lead to some quirky behavior...

Below is a more intricate example demonstrating how to access different types of methods in the case of ES6:

class ParentTest {
    parentFoo = function() {
        // perform actions
    }

    parentBar() {
        // perform actions
    }
}

class Test extends ParentTest {
    foo = function() {
        // perform actions
    }

    bar() {
        // perform actions
    }
}

let instance = new Test();

// Both of these approaches work similarly for every method declared as a property of type "function"
for(let method in instance) {
    console.log(method); // foo, foo2
}
console.log(Object.keys(instance)); // Array [ "parentFoo", "foo" ]

// This approach is suitable for methods within the class
let protoOfTest = Object.getPrototypeOf(instance);
console.log(Object.getOwnPropertyNames(protoOfTest)); // Array [ "constructor", "bar" ] 

// This method is used for accessing methods from the superclass
let protoOfParentTest = Object.getPrototypeOf(protoOfTest);
console.log(Object.getOwnPropertyNames(protoOfParentTest)); // Array [ "constructor", "parentBar" ]

Discovering class methods in typescript

Answer №1

Answer №2

Going a step further

Isolating methods

Reflection in TypeScript

Answer №3

Similar questions

Managing errors with Angular2 Observables within the HTML template

Updating the state on change for an array of objects: A step-by-step guide

What is the best method for compressing and decompressing JSON data using PHP?

mentioning a JSON key that includes a period

Applying background-image in ngStyle results in an undefined value

Looking to incorporate Functional Components in React using the package "@types/react" version "^18.0.17"? Learn how here!

Using the concat operator along with the if statement in Angular to make sequential requests based on certain conditions

Steps for running a TypeScript project as a child process within a JavaScript project

Secure Your Passwords with Encryption in NestJS using @nestjs/mongoose before saving them

The key to subscribing only once to an element from AsyncSubject in the consumer pattern

How can I only accept one of two specific function signatures in Typescript and reject any others?

Retrieve the chosen item to automatically fill in the input fields using Ionic 2 and Angular

A guide on obtaining the date format according to locale using Intl.DateTimeFormat within JavaScript

Typescript's Patch<T> type enforces strictness within the codebase

Dealing with an AWS S3 bucket file not found error: A comprehensive guide

Choose a specific div element from a collection of dynamically generated divs in Angular

Adding a baseURI to the image src in Angular 5 is causing issues with dynamically loading images

typescript: best practices for typing key and value parameters in the forEach loop of Object.entries()

Navigating through an interface array using *ngFor in TypeScript

Issue encountered when using await in Tensorflow.js sample code with TypeScript