Javascript 比较结果为单个对象数组，如果值在同一对象数组中匹配，则追加

Question

我正在尝试将数组连接到基本文件夹层次结构。

在下面的示例中，“级别 1”是最低级别，该级别没有子文件夹。 “其他级别”将在“顶级”下有许多不同的文件夹

我有数据的数组如下：

[{ id: "Top Level", outerpath: "test plan", innerpath: "Regression" },
 { id: "other level", outerpath: "Regression", innerpath: "area 1" },
 { id: "Level 1", outerpath: "area 1", innerpath: "Subarea 1" },
 { id: "Level 1", outerpath: "area 1", innerpath: "Subarea 2" },
 { id: "Level 1", outerpath: "Regression", innerpath: "area 2" }]

现在我需要对象数组中数据的串联结果如下所示：

test plan/Regression/area 1/Subarea 1
test plan/Regression/area 1/Subarea 2
test plan/Regression/area 2

但是我不知道如何开始。也许它通过匹配“innerpath”和“outpath”值的数组循环，然后将完成的数据推送到另一个数组？

任何想法都会非常有用。

更新：

为了扩展我的问题，数组是动态的，根据 API 的结果，它可能像这个数组

[{ id: "Top Level", outerpath: "test plan", innerpath: "Regression" }
{ id: "other level", outerpath: "Regression", innerpath: "area 1" }
{ id: "Level 1", outerpath: "area 1", innerpath: "Subarea 1" }
{ id: "other level", outerpath: "area 1", innerpath: "Subarea 2" }
{ id: "Level 1", outerpath: "Regression", innerpath: "area 2" }
{ id: "Top Level", outerpath: "test plan", innerpath: "other testing" }
{ id: "Level 1", outerpath: "other testing", innerpath: "other testing area 1" }
{ id: "other level", outerpath: "other testing", innerpath: "other testing area 2" }
{ id: "Level 1", outerpath: "other testing area 2", innerpath: "other testing subarea 1" }
{ id: "Level 1", outerpath: "Subarea 2", innerpath: "SubSubArea 1" }]

因此不会只有一个顶层，它可能是多个顶层，因为文件夹“测试计划”将有多个文件夹，其中一些文件夹有自己的子文件夹。

我从 API 调用的回调中整理数据的代码在这里：

let testSuiteData = res;
           testSuiteData.value.forEach(async testSuiteItem => {
                  console.log(testSuiteItem);
    
                  if(!testSuiteItem.hasChildren === true) // Level 1
                  {
                      console.log(testSuiteItem.parentSuite.name + '/' + testSuiteItem.name)
                      folderHierarchy.path.push({
                          id: 'Level 1',
                          outerpath: testSuiteItem.parentSuite.name,
                          innerpath: testSuiteItem.name
                      })
                            
                  }
                  else if(testSuiteItem.hasChildren === true ) // other levels
                  {
                      if(testSuiteItem.parentSuite.name === testSuiteItem.plan.name) // Top Level
                      {
                          console.log(testSuiteItem.parentSuite.name + '/' + testSuiteItem.name)
                          folderHierarchy.path.push({
                              id: 'Top Level',
                              outerpath: testSuiteItem.parentSuite.name,
                              innerpath: testSuiteItem.name
                          })
                      }
                      else{ // Other Levels
                          console.log(testSuiteItem.parentSuite.name + '/' + testSuiteItem.name)
                          folderHierarchy.path.push({
                              id: 'other level',
                              outerpath: testSuiteItem.parentSuite.name,
                              innerpath: testSuiteItem.name
                          })
                      }
                  }
    
                        
                  console.log(folderHierarchy.path);

Answer 1

我认为我们可以更简化这一点，首先创建一个列表，其中包含所有唯一的 innerpath 值，这些值不会也显示为 outerpath 值，然后从每个值向后遍历。

使用最新的动态对象数组如下所示：

我从您的原始数据中排除了 id 属性值，因为它似乎没有在任何地方使用，只是为了使此示例保持简洁，但您当然可以将其添加回您的最终版本。

const data = [
  { outerpath: "test plan", innerpath: "Regression" },
  { outerpath: "Regression", innerpath: "area 1" },
  { outerpath: "area 1", innerpath: "Subarea 1" },
  { outerpath: "area 1", innerpath: "Subarea 2" },
  { outerpath: "Regression", innerpath: "area 2" },
  { outerpath: "test plan", innerpath: "other testing" },
  { outerpath: "other testing", innerpath: "other testing area 1" },
  { outerpath: "other testing", innerpath: "other testing area 2" },
  { outerpath: "other testing area 2", innerpath: "other testing subarea 1" },
  { outerpath: "Subarea 2", innerpath: "SubSubArea 1" }
];

const outerpaths = data.map(({ outerpath }) => outerpath),
      innerpaths = data.map(({ innerpath }) => innerpath).filter(innerpath => !outerpaths.includes(innerpath));

const concatenated = innerpaths.map(innerpath => {
  let obj = data.find(obj => obj.innerpath === innerpath),
      str = obj.outerpath + '/' + innerpath;
  if (obj) do {
    obj = data.find(({ innerpath }) => obj.outerpath === innerpath);
    if (obj) str = obj.outerpath + '/' + str;
  } while (obj)
  return str;
});

console.log(concatenated.join('\n'));

这段代码的输出是：

test plan/Regression/area 1/Subarea 1
test plan/Regression/area 2
test plan/other testing/other testing area 1
test plan/other testing/other testing area 2/other testing subarea 1
test plan/Regression/area 1/Subarea 2/SubSubArea 1

Answer 2

你可以这样做

const array = [{ id: "Top Level", outerpath: "test plan", innerpath: "Regression" },
{ id: "other level", outerpath: "Regression", innerpath: "area 1" },
{ id: "Level 1", outerpath: "area 1", innerpath: "Subarea 1" },
{ id: "Level 1", outerpath: "area 1", innerpath: "Subarea 2" },
{ id: "Level 1", outerpath: "Regression", innerpath: "area 2" }]

const obj = {}; // a map of all our paths
const topLevel = array.splice(0, 1)[0]; // removing the top level from array as it is not needed, and for further reference
const base = `${topLevel.outerpath}/${topLevel.innerpath}`; // creating our default path, which we will use as a reference later

for (let i = 0; i < array.length; i++) {
    const path = array[i].outerpath.split(' '); // creating a unique key for our map
    const key = path[1] ? path[1] : path[0];
    if (!obj[key]) obj[key] = [];
    if (path[0] == 'area')
        obj[key].push(`${base}/${array[i].outerpath}/${array[i].innerpath}`);
    else if (path[0] == 'Regression')
        obj[key].push(`${base}/${array[i].innerpath}`)
}

console.log(obj);