从另一个具有虚拟对象的对象数组创建对象数组

Question

我想从另一个对象数组中创建一个对象数组来绘制一个图形。

这是用于将对象的位置放置在预期对象中的数组。

let uniqueSkills = ['Using', 'Analyzing', 'Summarizing', 'Inferring', 'Predicting', 'Activating']

这是我需要修改的对象。

let data = {
      data0:[
        {count: 1, length: 1, skill: "Activating"},
        {count: 4, length: 1, skill: "Using"},
        {count: 2, length: 1, skill: "Analyzing"}
      ],
      data1: [
        {count: 2, length: 1, skill: "Summarizing"}
      ],
      data2: [
        {count: 1, length: 1, skill: "Predicting"},
        {count: 4, length: 1, skill: "Analyzing"}
      ]
    }

最终的结果对象应该如下所示。

data = {
      data0:[
        {count: 4, length: 1, skill: "Using"},
        {count: 2, length: 1, skill: "Analyzing"},
        {skill: "Summarizing"},
        {skill: "Inferring"},
        {skill: "Predicting"},
        {count: 4, length: 1, skill: "Activating"}

      ],
      data1: [
        {skill: "Using"},
        {skill: "Analyzing"},
        {count: 2, length: 1, skill: "Summarizing"},
        {skill: "Inferring"},
        {skill: "Predicting"},
        {skill: "Activating"}
      ],
      data2: [
        {skill: "Using"},
        {count: 4, length: 1, skill: "Analyzing"},
        {skill: "Summarizing"},
        {skill: "Inferring"},
        {count: 1, length: 1, skill: "Predicting"},
        {skill: "Activating"}
      ]
    }

我编写的算法在某些情况下运行良好，但在某些情况下会中断。在这里，

Object.keys(data).forEach(key => {      
      for (let i = 0; i < uniqueSkills.length; i++) {       
        if (typeof data[key][i] == 'object') {      
          if (data[key][i].skill !== uniqueSkills[i]) {     
            let index = uniqueSkills.indexOf(data[key][i].skill)
            if (typeof data[key][index] == 'object') {
              let anotherIndex = uniqueSkills.indexOf(data[key][index].skill)
              let elementAtIndex = data[key][index]
              let elementAtAnotherIndex = data[key][anotherIndex]
              data[key][i] = elementAtIndex
              data[key][index] = elementAtAnotherIndex
            }
            else {
              data[key][index] = data[key][i]
              data[key][i] = {skill: uniqueSkills[i]}
            }
          }
        } else {        
          data[key][i] = {skill: uniqueSkills[i]}       
        }       
      }     
    })

Answer 1

对于数据中的每个对象，调用Array.prototype.map For uniqueSkills并找到一个对象。如果找到对象，返回对象，如果没有返回一个新对象。

并将数组替换为原点。

​

let uniqueSkills = ['Using', 'Analyzing', 'Summarizing', 'Inferring', 'Predicting', 'Activating']
let data = {data0:[{count: 1, length: 1, skill: "Activating"},{count: 4, length: 1, skill: "Using"},{count: 2, length: 1, skill: "Analyzing"}],data1: [{count: 2, length: 1, skill: "Summarizing"}],data2: [{count: 1, length: 1, skill: "Predicting"},{count: 4, length: 1, skill: "Analyzing"}]};

Object.keys(data).forEach(key => {
  data[key] =
    uniqueSkills.map(skill => data[key].find(e => e.skill === skill) || { skill });
});

console.log(data);

​

Answer 2

您可以首先使用Map创建一个空模板，对象中只有skill属性，然后用实际的数据填充该Map。Object.entries和Object.fromEntries可以用来进行从普通对象到数组的转换，反之亦然。

由于Map保留插入顺序，因此输出顺序将得到保证。

​

let uniqueSkills = ['Using', 'Analyzing', 'Summarizing', 'Inferring', 'Predicting', 'Activating']
let data = {data0:[{count: 1, length: 1, skill: "Activating"},{count: 4, length: 1, skill: "Using"},{count: 2, length: 1, skill: "Analyzing"}],data1: [{count: 2, length: 1, skill: "Summarizing"}],data2: [{count: 1, length: 1, skill: "Predicting"},{count: 4, length: 1, skill: "Analyzing"}]};

let newData = Object.fromEntries(Object.entries(data).map(([k, arr]) =>
    [k, Array.from(arr.reduce(
        (map, o) => map.set(o.skill, o),
        new Map(uniqueSkills.map(skill => [skill, { skill }]))
    ).values())]
));

console.log(newData);

​

请注意，该解决方案的最坏情况是O(n平方)时间复杂度(就uniqueSkills的长度而言)。您自己的解决方案的时间复杂度为O(N)，有两个外部循环(forEach和for)和嵌套的indexOf调用，后者也表示一个循环。其他的解决方案，而不是indexOf，有一个嵌套的find或findIndex，时间复杂度也是O(n立方)。使用Map#get代替这些数组方法之一，将复杂度降低到O(n平方)。

此解决方案不会更改原始data对象。它产生了一个新的对象。然而，新对象仍将包括原始data数组中的原始对象。

解决方案的问题在于，您走了一条i、index、anotherIndex的路径，试图移动一个阻碍您要插入的对象的对象。但这条路可能会比这更长。这种“走”创造差距，移动到下一个位置，创造一个缺口，...etc，是一个先验的不受限制的长度。