数组对象转换为二维数组应该如何转换

a: [
      {
        nodes: [
          {
            nodeId: "*"
          }
        ],
        startsAt: "2023-01-06 16:17:41",
        endsAt: "2023-01-06 16:17:41"
      },
      {
        nodes: [
          {
            clusterId: "1111",
            nodeId: "1"
          },
          {
            clusterId: "1111",
            nodeId: "2"
          }
        ],
        startsAt: "2023-01-06 16:17:41",
        endsAt: "2023-01-06 16:17:41"
      },
      {
        nodes: [
          {
            clusterId: "222",
            nodeId: "3"
          },
          {
            clusterId: "2222",
            nodeId: "5"
          }
        ],
        startsAt: "2023-01-06 16:17:41",
        endsAt: "2023-01-06 16:17:41"
      }
    ]

把a转换为b
是antd中的Cascader级联选择那种数据形式，nodeId为*时代表全部选中，做数据回填
b: [
      {
        nodes: [[*,clusterId,nodeId ]],
        timeCycle: [startsAt, endsAt],
      },
    ],

map函数：

const a = [  {    nodes: [      {        nodeId: "*"      }    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  },
  {
    nodes: [
      {
        clusterId: "1111",
        nodeId: "1"
      },
      {
        clusterId: "1111",
        nodeId: "2"
      }
    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  },
  {
    nodes: [
      {
        clusterId: "222",
        nodeId: "3"
      },
      {
        clusterId: "2222",
        nodeId: "5"
      }
    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  }
];

const b = a.map(item => {
  const nodes = item.nodes.map(node => {
    const { clusterId, nodeId } = node;
    return [nodeId === "*" ? "*" : clusterId, nodeId];
  });

  return {
    nodes,
    timeCycle: [item.startsAt, item.endsAt],
  };
});

可以使用 JavaScript 的 map 函数，遍历 a 数组，将每个元素转换为对应的 b 元素，然后存入 b 数组中。代码如下：

const b = a.map(item => {
  let nodes = item.nodes.map(node => {
    let clusterId = node.clusterId || '';
    let nodeId = node.nodeId === '*' ? node.nodeId : node.clusterId + ',' + node.nodeId;
    return [nodeId, clusterId, nodeId];
  });
  return {
    nodes: [nodes],
    timeCycle: [item.startsAt, item.endsAt],
  };
});

代码如下：

const a = [  {    nodes: [      {        nodeId: "*"      }    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  },
  {
    nodes: [
      {
        clusterId: "1111",
        nodeId: "1"
      },
      {
        clusterId: "1111",
        nodeId: "2"
      }
    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  },
  {
    nodes: [
      {
        clusterId: "222",
        nodeId: "3"
      },
      {
        clusterId: "2222",
        nodeId: "5"
      }
    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  }
];

const b = a.map(item => {
  const nodes = item.nodes.map(node => {
    return [node.nodeId, node.clusterId, node.nodeId];
  });
  return {
    nodes,
    timeCycle: [item.startsAt, item.endsAt]
  };
});

console.log(b);

你可以使用JavaScript的Array.prototype.map()方法来实现你的需求，它可以对数组中的每个元素执行一个函数，代码如下：

let b = a.map(item => {
  let nodeIds = item.nodes.map(node => {
    let nodeId = node.nodeId;
    let clusterId = node.clusterId || '';
    return [nodeId, clusterId];
  });
  return {
    nodes: nodeIds,
    timeCycle: [item.startsAt, item.endsAt]
  };
});

const a = [  {    nodes: [      {        nodeId: "*"      }    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  },
  {
    nodes: [
      {
        clusterId: "1111",
        nodeId: "1"
      },
      {
        clusterId: "1111",
        nodeId: "2"
      }
    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  },
  {
    nodes: [
      {
        clusterId: "222",
        nodeId: "3"
      },
      {
        clusterId: "2222",
        nodeId: "5"
      }
    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  }
];

const b = a.map(item => {
  const nodes = item.nodes.map(node => {
    if (node.nodeId === "*") {
      return [node.nodeId];
    } else {
      return [node.clusterId, node.nodeId];
    }
  });
  return {
    nodes,
    timeCycle: [item.startsAt, item.endsAt]
  };
});

console.log(b);

[  {    nodes: [ [ '*' ] ],
    timeCycle: [ '2023-01-06 16:17:41', '2023-01-06 16:17:41' ]
  },
  {
    nodes: [ [ '1111', '1' ], [ '1111', '2' ] ],
    timeCycle: [ '2023-01-06 16:17:41', '2023-01-06 16:17:41' ]
  },
  {
    nodes: [ [ '222', '3' ], [ '2222', '5' ] ],
    timeCycle: [ '2023-01-06 16:17:41', '2023-01-06 16:17:41' ]
  }
]

转换数组对象为二维数组可以通过循环构建新数组实现。具体实现方法如下：
在 JavaScript 中：

let arr = [{a: 1, b: 2}, {a: 3, b: 4}, {a: 5, b: 6}];

let result = arr.map(function(item) {
  return Object.values(item);
});

console.log(result);
// [[1, 2], [3, 4], [5, 6]]

在 Python 中：

arr = [{'a': 1, 'b': 2}, {'a': 3, 'b': 4}, {'a': 5, 'b': 6}]

result = [[val for key, val in item.items()] for item in arr]

print(result)
# [[1, 2], [3, 4], [5, 6]]

在上面的代码中，我们使用 map 函数或列表推导式将每个对象转换为数组，然后将结果存储到结果数组中。

这个实例的思路思维不错，你可参考下：https://blog.csdn.net/weixin_46413834/article/details/125167676

const a = [  {    nodes: [      {        nodeId: "*"      }    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  },
  {
    nodes: [
      {
        clusterId: "1111",
        nodeId: "1"
      },
      {
        clusterId: "1111",
        nodeId: "2"
      }
    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  },
  {
    nodes: [
      {
        clusterId: "222",
        nodeId: "3"
      },
      {
        clusterId: "2222",
        nodeId: "5"
      }
    ],
    startsAt: "2023-01-06 16:17:41",
    endsAt: "2023-01-06 16:17:41"
  }
];

const b = a.map(item => {
  const nodes = item.nodes.map(node => {
    if (node.nodeId === "*") {
      return ["*"];
    } else {
      return [node.clusterId, node.nodeId];
    }
  });
  return {
    nodes,
    timeCycle: [item.startsAt, item.endsAt]
  };
});

console.log(b);

输出结果：

[  {    nodes: [ [ '*' ] ],
    timeCycle: [ '2023-01-06 16:17:41', '2023-01-06 16:17:41' ]
  },
  {
    nodes: [ [ '1111', '1' ], [ '1111', '2' ] ],
    timeCycle: [ '2023-01-06 16:17:41', '2023-01-06 16:17:41' ]
  },
  {
    nodes: [ [ '222', '3' ], [ '2222', '5' ] ],
    timeCycle: [ '2023-01-06 16:17:41', '2023-01-06 16:17:41' ]
  }
]

```

该回答引用ChatGPT
你可以使用以下代码来实现数组对象转换为二维数组：

let a = [      {        nodes: [          {            nodeId: "*"          }        ],
        startsAt: "2023-01-06 16:17:41",
        endsAt: "2023-01-06 16:17:41"
      },
      {
        nodes: [
          {
            clusterId: "1111",
            nodeId: "1"
          },
          {
            clusterId: "1111",
            nodeId: "2"
          }
        ],
        startsAt: "2023-01-06 16:17:41",
        endsAt: "2023-01-06 16:17:41"
      },
      {
        nodes: [
          {
            clusterId: "222",
            nodeId: "3"
          },
          {
            clusterId: "2222",
            nodeId: "5"
          }
        ],
        startsAt: "2023-01-06 16:17:41",
        endsAt: "2023-01-06 16:17:41"
      }
    ];

let b = [];

for (let i = 0; i < a.length; i++) {
  let item = a[i];
  let nodes = [];
  for (let j = 0; j < item.nodes.length; j++) {
    let node = item.nodes[j];
    nodes.push([node.nodeId, node.clusterId, node.nodeId]);
  }
  b.push({
    nodes: nodes,
    timeCycle: [item.startsAt, item.endsAt]
  });
}

console.log(b);

输出结果

[  {    nodes: [ [ '*', undefined, '*' ] ],
    timeCycle: [ '2023-01-06 16:17:41', '2023-01-06 16:17:41' ]
  },
  {
    nodes: [ [ '1', '1111', '1' ], [ '2', '1111', '2' ] ],
    timeCycle: [ '2023-01-06 16:17:41', '2023-01-06 16:17:41' ]
  },
  {
    nodes: [ [ '3', '222', '3' ], [ '5', '2222', '5' ] ],
    timeCycle: [ '2023-01-06 16:17:41', '2023-01-06 16:17:41' ]
  }
]

• 这个问题的回答你可以参考下: https://ask.csdn.net/questions/7652086
• 这篇博客你也可以参考下：将对象转化为二维数组