Question

我无法弄清楚为什么以下代码不起作用：

var os = new Proxy(require('os'), {});
console.log( os.cpus() ); // TypeError: Illegal invocation

，而

var os = require('os');
console.log(Reflect.apply(os.cpus, os, []));

或

var os = new Proxy(require('os'), {});
console.log( os.platform() );

按预期工作。

Answer 1

只是略读了Node repo中os package的源代码，看来cpus()是从binding.getCPUs导出的，它是Node运行时环境中的C钩子。< / p> 因此，

cpus()将binding对象作为函数上下文，然后通过代理丢失，给出IllegalInvocation错误，因为调用时函数没有上下文它 - 虽然我对细节很朦胧。

另一方面，

platform()被导出为function () { return process.platform; }，因此它只是一个返回对象的函数，并且不需要在特定的上下文下运行，因为Node函数上下文将具有默认情况下指定的process变量（除非已被覆盖）。

以下行为表明将os作为上下文应用于cpus函数将起作用 - 函数对象上的代理在调用属性时显然会丢失函数上下文。

const os = require('os');
const proxy = new Proxy(os, {});  // proxy of object, functions called get proxy context rather than os context
const cpus = new Proxy(os.cpus, {});  // proxy of function, still has os context

console.log(os.cpus());  // works (duh)
console.log(cpus());     // works
console.log(proxy.cpus.apply(os, []));  // works
console.log(proxy.cpus());  // fails with IllegalInvocation

注意：如果有人可以清除JS功能上下文的详细信息以获得答案，我也很乐意阅读。

Answer 2

组成怎么样：

const os = require('os');
const proxy = new Proxy(os, {});
Object.getOwnPropertyNames(os).forEach(k => {
    var v = os[k];
    if(typeof v === "function") proxy[k] = v.bind(os);
});

//the `!!` because I don't want the actual print
//only a `true` or an `Error`
console.log(!!os.cpus());
console.log(!!proxy.cpus());
console.log(!!proxy.cpus.apply(proxy, []));

以及所有这些作为“替换”new Proxy()的效用函数，其中handler.bindTargetFunctions可以

要绑定的keyNames数组（因此您可以是特定的）
或任何真实或虚假的值，以确定目标上的所有功能应该被绑定

代码：

function proxy(target, handler){
    const _proxy = new Proxy(target, handler);
    if(handler.bindTargetFunctions){
        let bindTargetFunctions = handler.bindTargetFunctions;
        if(!Array.isArray(bindTargetFunctions)){
            bindTargetFunctions = Object.getOwnPropertyNames(target)
                .filter(key => typeof target[key] === "function");
        }
        bindTargetFunctions.forEach(key => {
            _proxy[key] = target[key].bind(target);
        });
    }
    return _proxy;
}

const os = proxy(require('os'), { bindTargetFunctions: true });
//or
//const os = proxy(require('os'), { bindTargetFunctions: ["cpus"] });

console.log(os.cpus());

修改

目前我尝试直接在我的get处理程序中绑定函数（请参阅github.com/FranckFreiburger/module-invalidate/blob/master/...），我的解决方案的缺点是每次访问函数都会返回一个新的结合。

我在评论中提到了缓存。这就是缓存的样子：

function createProxy(mod){ var cache = Object.create(null); return new Proxy(function(){}, { get(target, property, receiver) { var val = Reflect.get(mod._exports, property, receiver); if(typeof val === "function"){ if(!(property in cache) || cache[property].original !== val){ cache[property] = { original: val, bound: bal.bind(mod._exports) } } val = cache[property].bound; }else if(property in cache){ delete cache[property]; } return val; } }); }

不，我不认为这个缓存是常规对象。不是因为它继承自null，而是因为从逻辑上讲，对我来说这是一个字典/地图。而且我不知道为什么你会扩展或代理特定的字典。

使用ES6代理和node.js的非法调用错误

2 个答案: