Question

尝试一个想法。给定类似这样的对象：

T = {
  a: 2,
  b: 9,
  c: {
    a: 3,
    d: 6,
    e: {
      f: 12
    }
  }
}

我想要对其进行突变，以使作为对象的每个值都更改为同一对象，并且父对象为原型。

意思是我希望能够得到以下输出：

> T.c.b
9
> T.c.e.b
9
> T.c.e.a
3
> T.c.c.c
{a: 3, d: 6, e:[Object]}

我已经创建了几乎可以按预期工作的以下功能：

function chainer(object) {
    for (const key in object) {
        if (object[key] !== null && typeof (object[key]) === 'object') {
            let Constructor = function () {
            };
            Constructor.prototype = object;
            let objectValue = {...object[key]};
            object[key] = new Constructor();
            for (const savedKey in objectValue) {
                object[key][savedKey] = objectValue[savedKey];
            }
        }
    }
}

function chain(object) {
    chainer(object);
    for (const key in object) {
        if (object[key] !== null && typeof (object[key]) === 'object') {
            chainer(object[key]);
        }
    }
}

在前面的示例中，它可以按预期工作。不过，当我尝试以下操作时：

T = {a:4, g:{g:{g:{g:{g:{g:{g:{}}}}}}}}

发生以下输出：

> T.a
4
> T.g.a
4
> T.g.g.a
4
> T.g.g.g.a
undefined
> T.g.g.g.g.a
undefined

我觉得这很奇怪，它只能发挥到一定程度，这让我觉得也许这是一个我不知道的限制问题。

反正我头晕目眩，没有想法，有什么想法吗？

Answer 1

这似乎很好：

ouroboros = (x, parent = null) => {
    if (!x || typeof x !== 'object')
        return x;
    let r = Object.create(parent);
    Object.entries(x).forEach(([k, v]) => r[k] = ouroboros(v, r));
    return r;
};

//


T = ouroboros({x: 4, a: {b: {c: {d: {e: {}}}}}});
console.log(T.a.b.c.a.b.c.a.b.c.a.b.c.a.b.c.x);

或更改对象，而不是复制：

ouroboros = (x, parent = null) => {
    if (x && typeof x === 'object') {
        Object.setPrototypeOf(x, parent);
        Object.values(x).forEach(v => ouroboros(v, x));
    }
};

Answer 2

如果我没有记错的话，你想做这样的事情：

rec = function (o) {
  return Object.keys(o).reduce((acc, key) => {

    if (typeof acc[key] === "object") { 
      const kv = {...rec(acc[key]), ...o}
      return {...acc, ...kv, get [key]() { return this}} 
    }
    return acc;
  },o)
}

将嵌套对象更改为同一对象，该对象的值是具有父对象作为原型的对象

2 个答案: