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.

Answer 1

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

Answer 2

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

Answer 3

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

Answer 4

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.

Answer 5

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.

Answer 6

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

Answer 7

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

Answer 8

Not sure if this would help, but:

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

new Foo().bar();

Answer 9

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