Question

我有这样的输入：

var input = [{IdDevice:"1", Time: '11:01:00', Data: '1,2,3' }, 
             {IdDevice:"2", Time: '11:01:11', Data: '4,5,6' },
             {IdDevice:"1", Time: '11:02:00', Data: 'a,b,c' }, 
             {IdDevice:"2", Time: '11:02:11', Data: 'x,y,z' }]

过程 1 之后：

var output1 = input.map(a => a.Data.split(','))[0].map((_, idx) => {return {data: input.map(a => a.Data.split(',')[idx])}});
console.log(output1)

我有输出1：

[
  { data: [ '1', '4', 'a', 'x' ] },
  { data: [ '2', '5', 'b', 'y' ] },
  { data: [ '3', '6', 'c', 'z' ] }
]

过程 2 之后：

output1.forEach((each, index) => each.name = `item ${index + 1}`);
console.log(output1)

我有输出：

[
  { data: [ '1', '4', 'a', 'x' ], name: 'item 1' },
  { data: [ '2', '5', 'b', 'y' ], name: 'item 2' },
  { data: [ '3', '6', 'c', 'z' ], name: 'item 3' }
]

现在我希望输出也像这样依赖 "IdDevice":

[
  { data: [ '1', 'a'], name: 'device 1 item 1' },
  { data: [ '2', 'b'], name: 'device 1 item 2' },
  { data: [ '3', 'c'], name: 'device 1 item 3' },
  { data: [ '4', 'x'], name: 'device 2 item 1' },
  { data: [ '5', 'y'], name: 'device 2 item 2' },
  { data: [ '6', 'z'], name: 'device 2 item 3' }
]

还有一个子问题，当我输入：

var output2 = output1.forEach((each, index) => each.name = `item ${index + 1}`);
console.log(output2)

输出 2 将是未定义的。感谢您的先进。

Answer 1

我会在第一阶段收集设备 ID，并通过一些转换来进行它们，代码如下：

const convert = (input) => Object .entries (input .flatMap (
  ({IdDevice, Data}) => Data .split (',') .map (
    (x, i) => ({data: x, name: `device ${IdDevice} item ${i + 1}`})
  )
) .reduce (
  (a, {data, name}) => ((a [name] = a[name] || []), (a[name] .push(data)), a),
  {}
)) .map (
  ([name, data]) => ({data, name})
)

var input = [{IdDevice:"1", Time: '11:01:00', Data: '1,2,3' }, {IdDevice:"2", Time: '11:01:11', Data: '4,5,6' }, {IdDevice:"1", Time: '11:02:00', Data: 'a,b,c' }, {IdDevice:"2", Time: '11:02:11', Data: 'x,y,z' }]

console .log (convert (input))

.as-console-wrapper {max-height: 100% !important; top: 0}

这经历了几个阶段。在 flatMap 调用之后，我们得到

[
  {"data": "1", "name": "device 1 item 1"}, 
  {"data": "2", "name": "device 1 item 2"}, 
  // ...
  {"data": "z", "name": "device 2 item 3"}
]

然后在 reduce 之后，我们有这个：

{
  "device 1 item 1": ["1", "a"], 
  "device 1 item 2": ["2", "b"],
  // ...
  "device 2 item 3": ["6", "z"]
}

Object.entries 将其稍微调整为：

[
  ["device 1 item 1", ["1", "a"]], 
  ["device 1 item 2", ["2", "b"]], 
  // ...
  ["device 2 item 3", ["6", "z"]]
]

最后，map 将其更改为您请求的输出格式：

[
  {"data": ["1", "a"], "name": "device 1 item 1"}, 
  {"data": ["2", "b"], "name": "device 1 item 2"}, 
  // ...
  {"data": ["6", "z"], "name": "device 2 item 3"}
]

虽然其中一些步骤当然可以合并，但我发现以这种方式工作更容易，除非有证据证明这是我的应用程序中的实际热点，否则我会保留它。

Answer 2

let input = [
  { IdDevice: "1", Time: "11:01:00", Data: "1,2,3" },
  { IdDevice: "2", Time: "11:01:11", Data: "4,5,6" },
  { IdDevice: "1", Time: "11:02:00", Data: "a,b,c" },
  { IdDevice: "2", Time: "11:02:11", Data: "x,y,z" },
];


const getDeviceArrayMap = input.reduce((deviceArrayMap, device) => {
  if (deviceArrayMap[device.IdDevice]) {
    deviceArrayMap[device.IdDevice] = [
      ...deviceArrayMap[device.IdDevice],
      ...device.Data.split(","),
    ];
  } else {
    deviceArrayMap[device.IdDevice] = [...device.Data.split(",")];
  }
  return deviceArrayMap;
}, {});

const getOutput = Object.keys(getDeviceArrayMap).reduce(
  (outputArray, deviceId) => {
    for (let i = 0; i < getDeviceArrayMap[deviceId].length / 2; i++) {
      outputArray.push({
        data: [
          getDeviceArrayMap[deviceId][i],
          getDeviceArrayMap[deviceId][i + 3],
        ],
        name: `device ${deviceId} item ${i + 1}`,
      });
    }

    return outputArray;
  },
  []
);

console.log(getOutput)

Answer 3

您可以使用 map 来获得所需的结果。

<块引用>

map() 方法创建一个新数组，其中填充了以下结果对调用数组中的每个元素调用提供的函数。

var input = [
  { IdDevice: "1", Time: "11:01:00", Data: "1,2,3" },
  { IdDevice: "2", Time: "11:01:11", Data: "4,5,6" },
  { IdDevice: "1", Time: "11:02:00", Data: "a,b,c" },
  { IdDevice: "2", Time: "11:02:11", Data: "x,y,z" },
];

var output1 = input
  .map((a) => a.Data.split(","))[0]
  .map((_, idx) => {
    return { data: input.map((a) => a.Data.split(",")[idx]) };
  });

const output2 = output1.map((each, index) => ({
  data: each.data,
  name: `item ${index + 1}`,
}));

console.log(output2);

Answer 4

const input = [
    { IdDevice: '1', Time: '11:01:00', Data: '1,2,3' },
    { IdDevice: '2', Time: '11:01:11', Data: '4,5,6' },
    { IdDevice: '1', Time: '11:02:00', Data: 'a,b,c' },
    { IdDevice: '2', Time: '11:02:11', Data: 'x,y,z' },
];

const output1 = input
    .map(val => val.Data.split(','))[0]
    .map((val, i) => {
        return {
            data: input.map(diff => {
                return diff.Data.split(',')[i];
            }),
        };
    });

console.log(output1);
const output2 = output1.map((val, i) => {
    val.name = `item ${i + 1}`;
    return val;
});
console.log(output2);

const final_output = [];
let temp_index = 0;
let alphabet = 2;
let num = 0;
for (let i = 0; i < output2.length * 2; i++) {
    const new_data = { data: [], name: '' };
    if (temp_index >= output2.length) {
        temp_index = 0;
        alphabet++;
        num++;
    }
    new_data.data.push(`${i + 1}`);
    new_data.data.push(output2[temp_index].data[alphabet]);
    new_data.name = `device ${num + 1} ` + output2[temp_index].name;
    final_output.push(new_data);
    temp_index++;
}
console.log(final_output);

对数组 Javascript 中的对象进行分组和排序

4 个答案: