Javascript 如何更新自引用对象文字中的动态属性？

我试图用Javascript实现，但在更新自引用对象文本时遇到了问题

此函数获取一个二进制矩阵并返回一个矩阵，其中矩阵的每个“1”都是一个对象，在所有基数方向上引用它的闭合“1”

export const constructDataObjects = matrix => {
  for (let i = 0; i < matrix.length; i++) {
    for (let j = 0; j < matrix.length; j++) {
      let u = j - 1;
      let d = j + 1;
      let l = i - 1;
      let r = i + 1;

      if (matrix[i][j] === 0) continue;

      // Check edge cases.
      if (u < 0) u = matrix.length - 1;
      if (d >= matrix.length) d = 0;
      if (l < 0) l = matrix.length - 1;
      if (r >= matrix.length) r = 0;

      // Increment and decrement directions, with bound checks.
      // On hitting a bound, circle around and start from the other side.
      while (matrix[i][u] === 0) u = u - 1 < 0 ? matrix.length - 1 : u - 1;
      while (matrix[i][d] === 0) d = d + 1 >= matrix.length ? 0 : d + 1;
      while (matrix[l][j] === 0) l = l - 1 < 0 ? matrix.length - 1 : l - 1;
      while (matrix[r][j] === 0) r = r + 1 >= matrix.length ? 0 : r + 1;


      matrix[i][j] = {
        _u: undefined,
        _d: undefined,
        _l: undefined,
        _r: undefined,
        get u () { return this._u },
        set u (v) { return this._u = v },
        get d () { return this._d },
        set d (v) { return this._d = v },
        get l () { return this._l },
        set l (v) { return this._l = v },
        get r () { return this._r },
        set r (v) { return this._r = v },
        c : null,
        debug: `i:${i}, j:${j}, u:${u}, d:${d}, l:${l}, r:${r}`
      };
      matrix[i][j].u = matrix[i][u]
      matrix[i][j].d = matrix[i][d]
      matrix[i][j].l = matrix[l][j]
      matrix[i][j].r = matrix[r][j]

    }
  }

  return matrix;
};

export const constructDataObjects=matrix=>{
for（设i=0；i=矩阵长度）d=0；
如果（l<0）l=matrix.length-1；
如果（r>=矩阵长度）r=0；
//增量和减量方向，带有边界检查。
//击中边界时，绕一圈，从另一侧开始。
而（矩阵[i][u]==0）u=u-1<0？矩阵长度-1:u-1；
而（矩阵[i][d]==0）d=d+1>=matrix.length？0:d+1；
而（矩阵[l][j]==0）l=l-1<0？矩阵长度-1:l-1；
而（矩阵[r][j]==0）r=r+1>=matrix.length？0:r+1；
矩阵[i][j]={
_u：未定义，
_d：未定义，
_l:未定义，
_r：未定义，
获取u（）{返回这个。_}，
设置u（v）{返回这个。_=v}，
获取d（）{返回这个。\u d}，
集合d（v）{返回这个。_d=v}，
获取l（）{返回这个。_l}，
集合l（v）{返回这个。_l=v}，
获取r（）{返回这个。\u r}，
set r（v）{返回这个。_r=v}，
c:空，
调试：`i:${i}，j:${j}，u:${u}，d:${d}，l:${l}，r:${r}`
};
矩阵[i][j].u=矩阵[i][u]
矩阵[i][j].d=矩阵[i][d]
矩阵[i][j].l=矩阵[l][j]
矩阵[i][j].r=矩阵[r][j]
}
}
收益矩阵；
};

当我在对象文字声明中创建自引用遇到问题时，我问了一个问题。现在在DLX中，数据结构中的对象需要能够更改如何创建可编辑的自引用对象文字？

---

我相信这个问题可以归结为

a=arr=>{
for（设i=0；ilog（a（[1,2]）

在创建对象之前，不能创建引用该对象的属性。我建议您给每个单元格一个getter方法（或属性），在调用它时访问下一个单元格，而不是在构造单元格时

export function constructDataObjects(matrix) {
  const size = matrix.length; // assumed quadratic
  for (let i = 0; i < size; i++) {
    for (let j = 0; j < size; j++) {
      if (matrix[i][j] === 0) continue;

      // Increment and decrement directions, with bound checks.
      // On hitting a bound, circle around and start from the other side.
      let u = j;
      do { u--; if (u < 0) u = size - 1; } while (matrix[i][u] === 0);
      let d = j;
      do { d++; if (d >= size) d = 0; } while (matrix[i][d] === 0);
      let l = i;
      do { l--; if (l < 0) l = size - 1; } while (matrix[l][j] === 0);
      let r = i;
      do { r++; if (r >= size) r = 0; } while (matrix[r][j] === 0);

      matrix[i][j] = {
        u,
        d,
        l,
        r,
        getUp()    { return matrix[i][this.u] },
        getDown()  { return matrix[i][this.d] },
        getLeft()  { return matrix[this.l][j]; },
        getRight() { return matrix[this.r][j]; },
        c : null,
        debug: `i:${i}, j:${j}, u:${u}, d:${d}, l:${l}, r:${r}`
      };
    }
  }
  return matrix;
}

导出函数constructDataObjects（矩阵）{
const size=matrix.length；//假定为二次型
for（设i=0；i=size）d=0；}而（矩阵[i][d]==0）；
设l=i；
do{l--；如果（l<0）l=size-1；}而（矩阵[l][j]==0）；
设r=i；
do{r++；如果（r>=size）r=0；}而（矩阵[r][j]==0）；
矩阵[i][j]={
U
D
L
R
getUp（）{返回矩阵[i][this.u]}，
getDown（）{返回矩阵[i][this.d]}，
getLeft（）{返回矩阵[this.l][j]；}，
getRight（）{返回矩阵[this.r][j]；}，
c:空，
调试：`i:${i}，j:${j}，u:${u}，d:${d}，l:${l}，r:${r}`
};
}
}
收益矩阵；
}

或者，要真正创建一个圆形结构，您应该先创建具有空属性的对象，然后再填充它们。您甚至可以避免在两个方向上进行迭代

export function constructDataObjects(matrix) {
  const size = matrix.length; // assumed quadratic
  for (let i = 0; i < size; i++) {
    for (let j = 0; j < size; j++) {
      if (matrix[i][j] !== 0) {
        matrix[i][j] = {
          i,
          j,
          u: null,
          d: null,
          l: null,
          r: null,
          c: null
        };
      }
    }
  }
  for (let i = 0; i < size; i++) {
    let j = 0;
    while (matrix[i][j] === 0 && j < size) j++;
    const first = matrix[i][j];
    let cur = first;
    while (j < size) {
      do { j++; } while (j < size && matrix[i][j] === 0);
      const next = matrix[i][j];
      cur.d = next;
      next.u = cur;
      cur = next;
    }
    if (first) {
      cur.d = first;
      first.u = cur;
    }
  }
  for (let j = 0; j < size; j++) {
    let i = 0;
    while (matrix[i][j] === 0 && i < size) i++;
    const first = matrix[i][j];
    let cur = first;
    while (i < size) {
      do { i++; } while (i < size && matrix[i][j] === 0);
      const next = matrix[i][j];
      cur.r = next;
      next.l = cur;
      cur = next;
    }
    if (first) {
      cur.r = first;
      first.l = cur;
    }
  }
  return matrix;
}

导出函数constructDataObjects（矩阵）{
const size=matrix.length；//假定为二次型
for（设i=0；i

是否使用getter并不重要。原语是按值传递的。当我只使用getter并在添加setter后释放它时，为什么会得到我想要的结果？谁让你使用getter/setter的？！这完全是不可能的——也许只需在Javascript中实现一个LinkedList，就像Knuth在他的解决方案中所做的那样。只需删除getter/setter。他们什么也不做。非常感谢Bergi的回复。我可以看到这将如何工作。聪明的使用了做，而有！正如另一位SO用户所建议的，我正在研究矩阵上的第一个映射，以将“1”原语转换为我可以引用的对象，然后构建数据结构。这似乎也很管用。无论如何，我认为你的回答是可以接受的。给我点时间把这个编出来