ES6 代理变通方法"TypeError: Cannot create proxy with a non-object as target"？

Question

我在这里的最后一个问题：如何存储单体列表功能链的数据？

得到了很多很好的回应，其中一个建议在JavaScript中实现某种类型结构：

const TYPE = Symbol();
const typeOf = t => x => x == null
? x
: Object.assign(x, {
[TYPE]: t
});
const isType = t => x => x == null
? false
: x[TYPE] === t;
const Foo = x => typeOf(Foo)(x);
console.log(
isType(Foo)(1) // false
, isType(Foo)([]) // false
, isType(Foo)({}) // false
, isType(Foo)(x => x) // false
, isType(Foo)(true) // false
, isType(Foo)(undefined) // false
, isType(Foo)(null) // false
);

console.log(
isType(Foo)(Foo(1)) // true
, isType(Foo)(Foo([])) // true
, isType(Foo)(Foo({})) // true
, isType(Foo)(Foo(x => x)) // true
, isType(Foo)(Foo(true)) // true
, isType(Foo)(Foo(undefined)) // false
, isType(Foo)(Foo(null)) // false
);
console.log(Foo(1) + Foo(2)); //3

虽然我认为这是一个好主意，但另一位成员认为这是不一致的，因为Object.assign是一个可变操作，在函数式编程上下文中不应该允许它。

作为回应，还有另一个想法是使用Proxy，所以我尝试自己实现类似的系统。

不幸的是，结果非常糟糕，因为Proxy似乎只接受Object。

用作示例

var target = {};
var p = new Proxy(target, {});
p.a = 37; // operation forwarded to the target
console.log(target.a); // 37. The operation has been properly forwarded

"；未捕获的类型错误：无法使用非对象作为目标或处理程序创建代理">

var target = 5;
var p = new Proxy(target, {});
p.a = 37; // operation forwarded to the target
console.log(target.a); // 37. The operation has been properly forwarded

我也考虑过利用Object.create，但它的工作方式与Proxy不同。

基本上，我认识到在具有动态类型/鸭子类型和反射的函数式编程中实现继承(面向对象编程(是一个挑战。

因此，我真的想让这个实现在ES6Proxy上下文中工作。

有什么好主意吗？谢谢

Answer 1

事实证明，

• 符号((
• Object.assign((
• 代理

至少对于本主题而言，所有这些都不是实现反射(计算机编程(所必需的。

请参阅下面的代码：

const selfAware = i => i[i] = i;
const isAware = i => (i[i] === i);
const I = i => (i === I) || (i == null)
? i
: selfAware(Object(i));
const amI = i => (i === I)
? true
: (i == null)
? false
: isAware(i);
const ss = I(6);
console.log(ss);
console.log(ss[ss]);
//self-similarity
console.log(ss[ss][ss]);
const obj1 = {
a: 2
};
const obj2 = I(obj1);
console.log(obj1);
console.log(obj2);
console.log(
I("Hello world!").toString() //Yes, it works!
);
console.log(I(1) + I(2)); //3
console.log(
(I) //[Function: I]
);
console.log(
(I)(I) //[Function: I]
);
console.log(
(I)(I)(I) //[Function: I]
);
console.log(
(I)(I)(I)(I) //[Function: I]
);
console.log("============================");
console.log(
amI(I) //true
, amI(1) // false
, amI([]) // false
, amI({}) // false
, amI(x => x) // false
, amI(true) // false
, amI(false) // false
, amI(undefined) // false
, amI(null) // false
);
console.log(
amI(I(I)) // true
, amI(I(1)) // true
, amI(I([])) // true
, amI(I({})) // true
, amI(I(x => x)) // true
, amI(I(true)) // true
, amI(I(false)) // true
, amI(I(undefined)) // false
, amI(I(null)) // false
);