Question

我试图拦截ES6代理上的方法调用，以便能够在我从代理获取的信息之间进行处理。现在在我的情况下，在从某种工厂创建和返回代理之前，还有一些事情正在发生。由于所有这些原因，我决定将先决条件包装到promise函数中，以便我可以将代理创建链接到它上面并通过promise链返回结果代理。这是重现问题的代码：

proxy_factory.min.js

'use strict';

// require('harmony-reflect');

class ProxyFactory {

  create(options) {

    const self = this;

    const handler = {

      get(target, propertyKey, receiver) {

        if (propertyKey === 'then') {

          return function proxyPromiseWrapper(thenCallback) {
            const innerProxy = self.create(options);
            return thenCallback(innerProxy);
          };
        }

        return function resourceFunctionProxy() {

          const callContext = {
            target: target,
            method: propertyKey,
            args: arguments,
            thisContext: this
          };

          const resourceInstanceMethod = Reflect.get(options.originalObject, callContext.method);
          return resourceInstanceMethod.apply(callContext.thisContext, callContext.arguments);

        };
      }
    };

    return new Proxy(options.originalObject, handler);
  }

}

module.exports = ProxyFactory;

test.js

'use strict';

const Promise = require('bluebird');
const ProxyFactory = require('./proxy_factory.min.js');

const proxyFactory = new ProxyFactory();

function createProxyWithPromise() {

  const TestClass = class {
    doSomething() {
      return Promise.resolve('promise return value');
    }
  };

  const options = {
    originalObject: new TestClass()
  };

  return Promise.resolve()
    .then(() => {
      return proxyFactory.create(options);
    });
}

function test() {

  createProxyWithPromise()
    .then((proxy) => {

      const result = proxy.doSomething();

      console.log(result); // should output 'promisereturnvalue'
    });
}

test();

在代理上调用doSomething（）之前，一遍又一遍地调用then（） - 函数，导致堆栈溢出。我已经在node.js github问题中问了这个问题，你可以在这里找到之前的对话：https://github.com/nodejs/node/issues/8082 也许它可以帮助别人帮助我;）

Answer 1

您的问题是您的代理始终返回任何属性访问的函数，包括then。这将使promises实现将其视为一个可靠的，试图解决它 - 你的代码严重错误。但你应该解决问题的根源：

get (target, propertyKey, receiver) {
    if (!(propertyKey in target))
        return undefined;
    else if (typeof target[propertyKey] != "function")
        return …;
    else
        return function resourceFunctionProxy() {
            …

Answer 2

这是一个蓝色的镜头，但你可能正在寻找

return function proxyPromiseWrapper(thenCallback) {
    return options.originalObject.then(function(result) {
        const resultOptions = Object.assign({}, options, {target: result});
        const innerProxy = self.create(resultOptions);
        return thenCallback(innerProxy);
    });
};

通过promise

2 个答案: