Obtain the name of a method within a typescript function

Question

Obtain the name of a method within a typescript function

Is there a way to retrieve the name of the current method within an instance method of a class in Typescript?

(Pseudocode, it's not functional):

class Foo {
    bar() {
        console.log(something); //what should something be?
    }
}

new Foo().bar();

I'm looking for 'something' to return 'bar'. I know that this can provide me with the class, and I could potentially extract the class and its properties from it, but I am uncertain on how to access 'this function' (specifically, the method bar rather than the class Foo).

I have come across multiple questions regarding determining the class name, etc. however none seem to address retrieving the current method name.

javascript typescript

Answer 1

Answer №1

Besides using arguments.callee.name, there is no direct method to achieve this.

I present two alternative approaches:

1. Implement decorators to include the method name:

function annotateName(target, name, desc) {
    var method = desc.value;
    desc.value = function () {
        var prevMethod = this.currentMethod;
        this.currentMethod = name;
        method.apply(this, arguments);
        this.currentMethod = prevMethod;   
    }
}

class Foo {
    currentMethod: string;

    @annotateName
    bar() {
        alert(this.currentMethod);
        this.tux();
        alert(this.currentMethod);
    }

    @annotateName
    tux() {
        alert(this.currentMethod);
    }
}

new Foo().bar();

The drawback here is that you need to add annotations for each function where you want to retrieve the name. Alternatively, you could implement a decorator at the class level and iterate over all prototype functions in the decorator.

2. Another option involves creating an Error object and extracting its stack trace, although it may not yield consistent results across different browsers due to lack of standardization:

class Foo {
    bar() {
        console.log(getMethodName());    
    }
}

function getMethodName() {
    var err = new Error();
    return /at \w+\.(\w+)/.exec(err.stack.split('\n')[2])[1]; // extract the second method from the call stack

}

new Foo().bar();

Answer 2

Besides using arguments.callee.name, there is no direct method to achieve this.

I present two alternative approaches:

1. Implement decorators to include the method name:

function annotateName(target, name, desc) {
    var method = desc.value;
    desc.value = function () {
        var prevMethod = this.currentMethod;
        this.currentMethod = name;
        method.apply(this, arguments);
        this.currentMethod = prevMethod;   
    }
}

class Foo {
    currentMethod: string;

    @annotateName
    bar() {
        alert(this.currentMethod);
        this.tux();
        alert(this.currentMethod);
    }

    @annotateName
    tux() {
        alert(this.currentMethod);
    }
}

new Foo().bar();

The drawback here is that you need to add annotations for each function where you want to retrieve the name. Alternatively, you could implement a decorator at the class level and iterate over all prototype functions in the decorator.

2. Another option involves creating an Error object and extracting its stack trace, although it may not yield consistent results across different browsers due to lack of standardization:

class Foo {
    bar() {
        console.log(getMethodName());    
    }
}

function getMethodName() {
    var err = new Error();
    return /at \w+\.(\w+)/.exec(err.stack.split('\n')[2])[1]; // extract the second method from the call stack

}

new Foo().bar();

Answer 3

Answer №2

My solution for determining the method name is outlined below.

  /**
   * @summary Function to retrieve the caller's name
   * @returns {string} The name of the invoker
   */
  private static getCallerName(): string {
    try {
      throw new Error();
    } catch (e) {
      try {
        return e.stack.split('at ')[3].split(' ')[0];
      } catch (e) {
        return '';
      }
    }
  }

Answer 4

My solution for determining the method name is outlined below.

  /**
   * @summary Function to retrieve the caller's name
   * @returns {string} The name of the invoker
   */
  private static getCallerName(): string {
    try {
      throw new Error();
    } catch (e) {
      try {
        return e.stack.split('at ')[3].split(' ')[0];
      } catch (e) {
        return '';
      }
    }
  }

Answer 5

Answer №3

Here is a potential solution:

function SomeFunction() {
    console.log("Hello world!");
}

SomeFunction();

Answer 6

Here is a potential solution:

function SomeFunction() {
    console.log("Hello world!");
}

SomeFunction();

Answer 7

Answer №4

It's important to remember that when compiling and minifying your code, you could potentially lose the original names of variables or functions. One solution is to explore using the ts-nameof Babel macro, which can extract the actual name of almost anything during compilation and provide its string representation.

Answer 8

It's important to remember that when compiling and minifying your code, you could potentially lose the original names of variables or functions. One solution is to explore using the ts-nameof Babel macro, which can extract the actual name of almost anything during compilation and provide its string representation.

Answer 9

Answer №5

While searching for a resolution, I stumbled upon this helpful snippet:

class Widget {
  display() {
      console.log(this.display.name); // <-- Show the method name.
  }
}
  
new Widget().display();

An interesting aspect is that an error will be triggered if the function name is modified without updating the corresponding console output.

Answer 10

While searching for a resolution, I stumbled upon this helpful snippet:

class Widget {
  display() {
      console.log(this.display.name); // <-- Show the method name.
  }
}
  
new Widget().display();

An interesting aspect is that an error will be triggered if the function name is modified without updating the corresponding console output.

Answer 11

Answer №6

use Foo.name for the class name and this.bar.name for the method name.

Answer 12

use Foo.name for the class name and this.bar.name for the method name.

Answer 13

Answer №7

To provide a different perspective on this question, consider the following unconventional approach:

class Foo {
    constructor(private http: HttpClient) {

        const apiUrl = 'http://myapi.com/api/';

        {
            const functionName = 'getBar';
            this[functionName] = function () {
                return http.get(apiUrl + functionName);
            }
        }

        {
            const functionName = 'postBar';
            this[functionName] = function () {
                return http.get(apiUrl + functionName);
            }
        }

        {
            const functionName= 'putBar';
            this[functionName] = function () {
                return http.get(apiUrl + functionName);
            }
        }

        {
            const functionName= 'deleteBar';
            this[functionName] = function () {
                return http.get(apiUrl + functionName);
            }
        }
    }
}

This method is not elegant and it's hard to find a practical use case for such implementation. The compiler may not recognize new Foo(http).deleteBar(), making it even more challenging. Perhaps someone can devise a more refined solution based on this concept as an experimental challenge.

Despite its drawbacks, this pattern allows you to access the method names using functionName if combined with devops scaffolding or strong copy-paste skills.

Answer 14

To provide a different perspective on this question, consider the following unconventional approach:

class Foo {
    constructor(private http: HttpClient) {

        const apiUrl = 'http://myapi.com/api/';

        {
            const functionName = 'getBar';
            this[functionName] = function () {
                return http.get(apiUrl + functionName);
            }
        }

        {
            const functionName = 'postBar';
            this[functionName] = function () {
                return http.get(apiUrl + functionName);
            }
        }

        {
            const functionName= 'putBar';
            this[functionName] = function () {
                return http.get(apiUrl + functionName);
            }
        }

        {
            const functionName= 'deleteBar';
            this[functionName] = function () {
                return http.get(apiUrl + functionName);
            }
        }
    }
}

This method is not elegant and it's hard to find a practical use case for such implementation. The compiler may not recognize new Foo(http).deleteBar(), making it even more challenging. Perhaps someone can devise a more refined solution based on this concept as an experimental challenge.

Despite its drawbacks, this pattern allows you to access the method names using functionName if combined with devops scaffolding or strong copy-paste skills.

Answer 15

Answer №8


function retrieveCallerFunctionName() {
   return retrieveCallerFunctionName.caller.name
}

function displayCallerName() {
  console.log(retrieveCallerFunctionName())
}

displayCallerName() // logs the name of the caller function

To access the calling function, use the .caller property:

The .caller property of a Function object allows you to reference the function that called the current function. Keep in mind that for strict mode, async functions, and generator functions, using the caller property will result in an exception being thrown.

Although not a standardized feature, I have found the .caller property to be widely supported in my usage (primarily in node.js). Prior to implementation, always verify compatibility. I typically utilize this property for debugging purposes. For further details, refer to

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/caller

Answer 16


function retrieveCallerFunctionName() {
   return retrieveCallerFunctionName.caller.name
}

function displayCallerName() {
  console.log(retrieveCallerFunctionName())
}

displayCallerName() // logs the name of the caller function

To access the calling function, use the .caller property:

The .caller property of a Function object allows you to reference the function that called the current function. Keep in mind that for strict mode, async functions, and generator functions, using the caller property will result in an exception being thrown.

Although not a standardized feature, I have found the .caller property to be widely supported in my usage (primarily in node.js). Prior to implementation, always verify compatibility. I typically utilize this property for debugging purposes. For further details, refer to

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/caller

Answer 17

Answer №9

It seems like this question has been circulating for quite some time, so I wanted to share my own take on it.

function getMethodName(): string {
  const stackRegex = /at (\w+|new)[\.|\s]?(\w+|<anonymous>)/gi;

  const position = 2;

  const stackTrace = (new Error().stack || '').split('\n');
  if (stackTrace.length <= position) {
    return 'ERROR: unknown';
  }

  const currentStack = stackTrace[position];
  const methodMatch = stackRegex.exec(currentStack);

  if (!methodMatch || methodMatch.length < 3) return `FIXME: ${currentStack}`;

  switch (methodMatch[1]) {
    case 'Object':
      return '<node.js>'; // Represents "run_main" of Node.JS

    case 'new': // Handle constructors differently
    default:
      return methodMatch[2];
  }
}

Answer 18

It seems like this question has been circulating for quite some time, so I wanted to share my own take on it.

function getMethodName(): string {
  const stackRegex = /at (\w+|new)[\.|\s]?(\w+|<anonymous>)/gi;

  const position = 2;

  const stackTrace = (new Error().stack || '').split('\n');
  if (stackTrace.length <= position) {
    return 'ERROR: unknown';
  }

  const currentStack = stackTrace[position];
  const methodMatch = stackRegex.exec(currentStack);

  if (!methodMatch || methodMatch.length < 3) return `FIXME: ${currentStack}`;

  switch (methodMatch[1]) {
    case 'Object':
      return '<node.js>'; // Represents "run_main" of Node.JS

    case 'new': // Handle constructors differently
    default:
      return methodMatch[2];
  }
}

Obtain the name of a method within a typescript function

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Answer №6

Answer №7

Answer №8

Answer №9

Similar questions

Switch the URL of the current tab to a different one by clicking a button within a Chrome extension with the help of JavaScript

The issue with AngularJS ng-show and $timeout functionality not functioning as expected

What is the best way to group by date only from an ISODate field in a Node.js application?

Transform a string format of an array into a JavaScript array

What is the best way to verify the relationship between parent and children nodes in a tree structure?

When links are hovered over, the cursor hand does not vanish even when using the style code "cursor: none;"

What causes my page to refresh every time I click on a blank link?

Instructions for setting a default value for ng-options when dealing with nested JSON data in AngularJS

Developing a counter/timer feature in a web application using PHP and MySQL

How can I turn off warnings for angular-translation?

Ember's route-refreshing event

What is the impact on socket IDs when a Node.js server undergoes a restart?

Creating a dynamic effect to blur slideshow content located underneath a specific div

I am experiencing a strange situation in node.js where the `then` condition of a Promise is not being executed as expected

Executing two distinct SQL queries within one nodejs function

Adding a method to an object with TypeScript: A step-by-step guide

Tips for transferring contact information from a webpage to an Android or iPhone using an HTML button and integrating JavaScript or PHP

When using Nuxt JS and Jest, a warning message may appear stating "[Vue warn]: Invalid Component definition" when importing an SVG file

What measures can I take to ensure TypeScript transpiles prototype methods effectively?

Securing your Node.js connect-rest REST API with OAuth: A comprehensive guide