通过方法引用在类上调用方法

Question

I have a reference called func that links to a static method called method , and when I call func() , the method cannot find the static method _open . I am not sure why, but I assume it is because func is a method and I am calling it as such.

It looks something like this:

class A {
  static method() {
    this._open()
  }
  static _open() {
    // Do stuff
  }
}

I have tried to call the method like this:

/**
 * Finds the data in a object/array if it exists
 * `a.b.c` -> `{a: {b: {c: 'some value'}}}`
 */
function find(query, data) {
  return query.split('.').reduce((obj, val) => {
    return obj ? obj[val] : obj
  }, data)
}

// func is a reference to `method`
let func = find('A.method', {A: A})
func.constructor.prototype[func](...params)

However, it gives me this error:

TypeError: func.constructor.prototype[func] is not a function

When logging func it looks like this:

console.log(func.toString())
// Output:
// method() {
//   this._open()
// }

How can I call a static method on a class with only the reference to the method?

Answer 1

You need to ensure that find returns the method, as bound to A, otherwise, when method is called, this will refer to the global this ( window or undefined), and then you can just call func() :

 class A { static method(...args) { console.log('args', args); this._open() } static _open() { console.log('opening'); } } const find = () => A.method.bind(A); const func = find('method'); func('abc', 'def'); 

If you only have a reference to func , and not to the class A, there's no way to get to A again. Referencing func.constructor would only make sense if func was an instance (in which case referencing its .constructor would take you to A ) - but func is a method of the class, not an instance of the class.

If you need to dynamically detect what the last object before the return value from find is, so you can bind the function if necessary, add a bit more logic to the find function, to get to the last object and the last key:

 class A { static method() { this._open() } static _open() { console.log('opening'); } } function find(query, data) { const keys = query.split('.'); const lastKey = keys.pop(); const lastObj = keys.reduce((obj, val) => { return obj ? obj[val] : obj }, data); const ret = lastObj[lastKey]; return typeof ret === 'function' ? ret.bind(lastObj) : ret; } // func is a reference to `method` let func = find('A.method', { A: A }); func('param 1', 'param 2') 

Answer 2

Not really sure, what you are doing this for:

 class A { static method() { return this._open(...arguments) } static _open() { return arguments; // Do stuff } } function find(classHere, method){ return classHere[method].bind(classHere); } var func = find(A, 'method'); console.log(func('test', 'is', 'this', 'what', 'you', 'want'));