Get method name from within a typescript method

Question

I want to get the name of the current method from within an instance method of a class in Typescript.

(Pseudocode, doesn't work):

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

new Foo().bar();

I expect 'something' to return 'bar'. I realize that this can give me the class, and I could somehow get the class and its attributes from it, but I do not know how to get 'this function' (i.e, the method bar, not the class Foo).

I have seen several other questions related to finding the class name, etc. but not one that addresses getting the current method name.

@Rienk - I am trying to do something more complex (specifically, ruby's method_missing behavior in typescript) , but as a simpler example, assume I have legacy code with (a large number of methods) like getFoo() and getBar(), and I want to handle all these using a getObject(objName) function that parses the function name, and returns the object from a dictionary, by name. I want to call getObject(thisFuncName) in every such function rather than having to change each such function to say things like getObject('foo'), etc.. — Anand
– Anand, Commented Aug 17, 2017 at 21:07
There is arguments.callee.name, but it does not work in strict mode, and class methods are executed in strict mode. You could try to use Proxy for that, but not all browsers support proxies.. — artem
– artem, Commented Aug 17, 2017 at 21:09
@lilezek this is a fairly common feature in dynamic languages - ruby provides an __method__ to return current method name from within each method - see stackoverflow.com/questions/199527/… — Anand
– Anand, Commented Aug 17, 2017 at 21:12
you can call the function with parameterized name (i think): var instance = new Foo(); instance[methodNameParameter](); — R_Ice
– R_Ice, Commented Aug 17, 2017 at 21:13

Cristi Mihai · Accepted Answer · 2017-08-17 23:30:36Z

24

Besides the arguments.callee.name there is no straightforward way of getting this.

I propose 2 other methods:

Use decorators to inject 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 downside is that you have to annotate all the functions you want to get the name from. You could instead just annotate the class and in the decorator you would iterate over all prototype functions and apply the same idea.

My second option is not standardised and need more care to get consistent results across browsers. It relies on creating an Error object and getting it's stack trace.

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

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

}

new Foo().bar();

answered Aug 17, 2017 at 23:30

Cristi Mihai

2,5651 gold badge20 silver badges20 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

luukvhoudt Over a year ago

please explain where you get this and arguments from in your annotateName function.

Gerard van Helden Over a year ago

@luukvhoudt Both this and arguments are special variables within functions in javascript. Check out developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… and developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… respectively.

Avi Siboni · Accepted Answer · 2022-01-18 09:46:27Z

5

Here is my solution to get the method name.

  /**
   * @description Get log invoker name
   * @return {string} The invoker name
   */
  private static callerName(): string {
    try {
      throw new Error();
    } catch (e) {
      try {
        return e.stack.split('at ')[3].split(' ')[0];
      } catch (e) {
        return '';
      }
    }
  }

answered Jan 18, 2022 at 9:46

Avi Siboni

8041 gold badge10 silver badges20 bronze badges

2 Comments

Pauli Over a year ago

you could just do new Error().stack no need to throw it

Davos Over a year ago

I don't think I could ever bring myself to do this but it is a really interesting callstack hack.

Slai · Accepted Answer · 2017-08-17 23:53:18Z

3

Not sure if this would help, but:

class Foo {
    bar() {
        console.log(Object.getOwnPropertyNames(Foo.prototype)); // ["constructor", "bar"]
    }
}

new Foo().bar();

answered Aug 17, 2017 at 23:53

Slai

23k5 gold badges49 silver badges55 bronze badges

Comments

Christian Ivicevic · Accepted Answer · 2020-05-21 20:42:08Z

1

Keep in mind that during compilation and minification you might lose the actual name of what you're trying to use. You might consider looking into the ts-nameof babel macro that reads the name of virtually anything during compilation and returns it's actual string representation.

answered May 21, 2020 at 20:42

Christian Ivicevic

10.9k7 gold badges44 silver badges85 bronze badges

Comments

Chris Livdahl · Accepted Answer · 2021-01-20 19:31:16Z

1

I was looking for a solution as well, try this:

class Foo {
  bar() {
      console.log(this.bar.name); // <-- Print out the function name.
  }
}
  
new Foo().bar();

What is nice is that you'll get an error if you change the function name, but forget to update the console statement.

answered Jan 20, 2021 at 19:31

Chris Livdahl

4,7722 gold badges40 silver badges34 bronze badges

1 Comment

Sebastian Over a year ago

but this.bar.name is longer than just typing bar.

Will · Accepted Answer · 2020-05-21 17:53:47Z

Just to answer the question with another interesting take, you could do (but shouldn't do) something like this:

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);
            }
        }
    }
}

It certainly is not an elegant solution, and I can't really imagine a good use case for doing something like this, as I'm pretty sure the compiler doesn't recognize new Foo(http).deleteBar(). Maybe someone can come up with an elegant solution with this idea, I'll leave that as an experiment for someone.

But with this pattern (if you employ some kind of devops scaffolding or "strong copy-paste skills") you can always access your method's name via functionName

Rob · Accepted Answer · 2022-09-02 12:00:34Z


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

function foobar() {
  console.log(getFunctionName())
}

foobar() // logs 'foobar' as the currently running function

You can use the .caller property:

A Function object's caller property accessor property represents the function that invoked the specified function. For strict, async function, and generator function callers, accessing the caller property throws an exception.

Although non standard, in my experience the caller property is supported everywhere I have used it (mostly node.js). Check for compatibility before using it. I have only every used it for debugging purposes. For more information, please see

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

Shahar Hadas · Accepted Answer · 2024-05-29 20:59:06Z

Seems this question been around for a very long time, thought I'll submit my version as well.

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

  const stackPosition = 2;

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

  const currentMethod = stackList[stackPosition];
  const methodName = stackReg.exec(currentMethod);

  if (!methodName || methodName.length < 3) return `FIXME ${currentMethod}`;

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

    case 'new': // Constructor in case we want to format differently
    default:
      return methodName[2];
  }
}

Oleksii Shevchuk · Accepted Answer · 2019-02-07 11:36:05Z

-1

for class name - Foo.name for method name - this.bar.name

answered Feb 7, 2019 at 11:36

Oleksii Shevchuk

312 bronze badges

1 Comment

Troy Over a year ago

The question was regarding how to get the name of the currently-executing method.

Collectives™ on Stack Overflow

Get method name from within a typescript method

9 Answers 9

2 Comments

2 Comments

Comments

Comments

1 Comment

Comments

Comments

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

9 Answers 9

2 Comments

2 Comments

Comments

Comments

1 Comment

Comments

Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related