在 TypeScript 中获取类方法的名称

Question

对于查看此问题的任何人，此问题类似于以下内容：

How do I get the name of an object's type in JavaScript?
Get an object's class name at runtime in TypeScript

但在某些方面有所不同。

我正在寻找属于某个类的方法的名称，并将其存储在 TypeScript/JavaScript 中的变量中。
看看下面的设置：

class Foo {

    bar(){
        // logic
    }

}

以上是有效的 TypeScript，我想在另一个类中创建一个方法，该方法将返回 bar() 方法的名称，即 "bar"
例如：

class ClassHelper {

    getMethodName(method: any){
        return method.name; // per say
    }

}

然后我希望能够通过以下方式使用ClassHelper：

var foo = new Foo();
var barName = ClassHelper.getMethodName(foo.bar); // "bar"

我看过很多帖子，有些建议使用以下内容：

var funcNameRegex = /function (.{1,})\(/;   
var results = (funcNameRegex).exec(obj.toString());
var result = results && results.length > 1 && results[1];

但这失败了，因为我的方法不是以function开头的
另一个建议是：

public getClassName() {
    var funcNameRegex = /function (.{1,})\(/;
    var results  = (funcNameRegex).exec(this["constructor"].toString());
    return (results && results.length > 1) ? results[1] : "";
}

这只会返回类名，但是从阅读帖子来看，使用constructor 似乎是不可靠的。

另外，当我使用其中一些方法调试代码时，像这样传递方法：ClassHelper.getMethodName(foo.bar); 将导致传递参数，如果该方法采用一个，例如：

class Foo {

    bar(param: any){
        // logic
    }

}

var foo = new Foo();
var barName = ClassHelper.getMethodName(foo.bar); // results in param getting passed through

我已经为此苦苦挣扎了一段时间，如果有人能提供有关我如何解决此问题的任何信息，将不胜感激。

我在传入的方法上的.toString() 返回：

.toString() = "function (param) { // code }"

而不是：

.toString() = "function bar(param) { // code }"

根据 MDN，它也不应该这样做：

即toString对函数进行反编译，返回的字符串包括函数关键字、参数列表、大括号、函数体的来源。
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString#Description

Answer 1

您好，我一直在进行一些测试，并找到了一个更简单的解决方案。

class Parent{
  constructor(){
    // here you initialize your stuff
  }
   parentMethod1 (){ return "I am method 1" }
   parentMethod2 (){ return "I am method 2" }

}


class Child extends Parent{
  constructor(){
    // make this if you want to pass extra args to parent class
    super()
  }
  childMethod1(){  /*child actions*/ }
  childMethod2(){ /* other child actions */ }
}

const parent = new Parent();
const child = new Child();

console.log( Object.getOwnPropertyNames(parent.__proto__)) // --> ["constructor", "parentMethod1", "parentMethod2"]
console.log(Object.getOwnPropertyNames(child.__proto__)) //--> ["constructor", "childMethod1","childMethod2"]

console.log(parent.constructor.name) // --> Parent
console.log(child.constructor.name) // --> Child

Answer 2

我找到了解决方案。我不确定它的效率和可重用性如何，但它适用于多个测试用例，包括嵌套方法，例如Class -> Class -> Method

我的解决方案：

class ClassHelpers {
    getName(obj: any): string {    
        if (obj.name) {
            return obj.name;
        }

        var funcNameRegex = /function (.{1,})\(/;   
        var results = (funcNameRegex).exec(obj.toString());
        var result = results && results.length > 1 && results[1];

        if(!result){
            funcNameRegex = /return .([^;]+)/;
            results = (funcNameRegex).exec(obj.toString());
            result = results && results.length > 1 && results[1].split(".").pop();
        }

        return result || "";
    }
}


class Foo {

    bar(param: any){
        // logic
    }

}

var foo = new Foo();
var barName = ClassHelper.getMethodName(() => foo.bar);

lambda 符号 ClassHelper.getMethodName(() => foo.bar); 是让它工作的关键，因为它允许 .toString() 包含 return foo.bar;

接下来我要做的是从.toString() 中提取方法调用，然后我使用数组和字符串函数返回最后一个子字符串，这不可避免地是方法名称。

就像我说的，它可能不是最优雅的解决方案，但它确实有效，甚至适用于嵌套方法

注意：您可以将 lambda 函数替换为常规匿名函数

var foo = new Foo();
var barName = ClassHelper.getMethodName(function() { return foo.bar; });

Answer 3

我采纳了 John White 的想法并对其进行了改进，使其适用于我能想到的所有情况。这种方法的优点是运行时不需要解析js代码。但是有一个极端情况，它根本无法推断出正确的属性名称，因为有多个正确的属性名称。

class Foo {
  bar() {}
  foo() {}
}

class ClassHelper {
  static getMethodName(obj, method) {
    var methodName = null;
    Object.getOwnPropertyNames(obj).forEach(prop => {
      if (obj[prop] === method) {
        methodName = prop;
      }
    });

    if (methodName !== null) {
      return methodName;
    }
    
    var proto = Object.getPrototypeOf(obj);
    if (proto) {
      return ClassHelper.getMethodName(proto, method);
    }
    return null;
  }
}

var foo = new Foo();
console.log(ClassHelper.getMethodName(foo, foo.bar));
console.log(ClassHelper.getMethodName(Foo.prototype, foo.bar));
console.log(ClassHelper.getMethodName(Foo.prototype, Foo.prototype.bar));

var edgeCase = { bar(){}, foo(){} };
edgeCase.foo = edgeCase.bar;
console.log(ClassHelper.getMethodName(edgeCase, edgeCase.bar));

Answer 4

Object.keys 可以帮助你。 试试这个方法

class Greeter {
    test : Function;

    constructor(message: string) {

        this.test = function(){
            return message;
        }
    }    
}

var a = new Greeter("world");

var properties = Object.keys(a);
alert(properties.join(', ')); //test

Answer 5

您可以同时传入对象和方法，获取对象上的属性键数组，然后使用属性键查看每个给定属性是否与提供的方法相同的对象引用——如果是，则存在一场比赛。

class ClassHelper {
    getMethodName(obj: any, method: any) {
        var methodName: string;

        if (method) {
            Object.keys(obj).forEach(key => {
                if (obj[key] === method) {
                    methodName = key;
                }
            });
        }

        return methodName;
    }
}

这有一个缺点，即主机 object 也必须是已知的。如果找不到方法，则返回undefined。

Answer 6

不幸的是，Typescript 类方法的名称在编译为 JS 时丢失了（正如您正确推断的那样）。通过将方法添加到 Javascript 类的原型中，将 Typescript 方法编译为 Javascript。 （查看编译后的 Javascript 以获得更多信息）。

在 Javascript 中，这是可行的：

Foo.prototype["bar"] // returns foo.bar <<the function>>

所以，你能想到的就是把类的原型倒过来，让类本身成为对象的key：

Foo.prototype[foo.bar] // return "bar"

当然，这是一个非常老套的解决方案，因为

1. 复杂度为O(N)（循环遍历数组）
2. 我不确定这是否适用于所有情况。

（工作）您的问题的示例：

class Foo{
    bar(){}
}

class ClassHelper{
    static reversePrototype(cls:any){
        let r = {};
        for (var key in cls.prototype){
            r[cls.prototype[key]] = key;
        }
        return r;
    }

    static getMethodNameOf(cls: any, method:any):string{
        let reverseObject = ClassHelper.reversePrototype(cls);
        return reverseObject[method];
    }
}

var foo = new Foo();
console.log(ClassHelper.getMethodNameOf(Foo, foo.bar)) // "bar"

更好的解决方案是一个 typescript 编译器选项，它可以改变 typescript 将类转换为 javascript 的方式。但是，我目前不知道有任何选项可以做这种事情。