javascript - 需要根据连续的对象属性或对象数组中的属性获取元素我有一个要搜索的值

Question

const levels = [
    {
      indexId: 'A',
      level: 1,
      name: 'A',
      parent: '0',
    },
    {
      indexId: 'A-A1',
      level: 2,
      name: 'A1',
      parent: 'A',
    },
    {
      indexId: 'A-A1-A11',
      level: 3,
      name: 'A11',
      parent: 'A-A1',
    },
    {
      indexId: 'A-A1-A11-A111',
      level: 4,
      name: 'A111',
      parent: 'A-A1-A11',
    },
    {
      indexId: 'A-A1-A11-A112',
      level: 4,
      name: 'A112',
      parent: 'A-A1-A11',
    },
    {
      indexId: 'A-A1-A12',
      level: 3,
      name: 'A12',
      parent: 'A-A1',
    },
    {
      indexId: 'A-A1-A12-A121',
      level: 4,
      name: 'A121',
      parent: 'A-A1-A12',
    },
    {
      indexId: 'A-A1-A12-A121-A1211',
      level: 5,
      name: 'A1211',
      parent: 'A-A1-A12-A121',
    },
    {
      indexId: 'A-A2',
      level: 2,
      name: 'A2',
      parent: 'A',
    },
    {
      indexId: 'A-A2-A21',
      level: 3,
      name: 'A21',
      parent: 'A-A2',
    },

    {
      indexId: 'A-A2-A22',
      level: 3,
      name: 'A22',
      parent: 'A-A2',
    },
    {
      indexId: 'A-A3',
      level: 2,
      name: 'A3',
      parent: 'A',
    },
    {
      indexId: 'A-A3-A31',
      level: 3,
      name: 'A31',
      parent: 'A-A3',
    },
    {
      indexId: 'A-A3-A32',
      level: 3,
      name: 'A32',
      parent: 'A-A3',
    },
  ]

 
  const maxLevel = levels.filter(
    l => l.level === Math.max(...levels.map(l => l.level))
  )

  const arrayStrings = []

  function stackLetter(l) {
    for (let index = 1; index <= l.length; index++) {
      arrayStrings.push(l.slice(0, index))
    }
  }

stackLetter(maxLevel[0].indexId.split('-'))
  console.log(arrayStrings)

const buildTree = arrayStrings
    .map(arr => arr.join('-'))
    .map(s => {
      return levels.filter(l => l.indexId === s)
    })

  console.log(buildTree)

最初我得到了最高级别的最长分支

output array = [["A"],["A-A1"],["A-A1-A12"],["A-A1-A12-A121"],["A-A1-A12-A121-A1211"]]

如果我选择 indexId = 'A-A1-A12' > 我得到 [["A"], ["A-A1"],["A-A1-A12"] ]
但预期输出是代码是与我选择的节点相关的任何分支
它可能是 =
[["A"],["A-A1"],["A-A1-A12"],["A-A1-A12-A121"],["A-A1-A12-A121-A1211"] ]
或者
如果我选择“A-A3”
它应该给
[["A"],["A-A3"],["A-A3-A31"]]
或者
[["A"],["A-A3"],["A-A3-A32"]]

Answer 1

以下代码输出 OP 中所需的内容。它reduce s 原始数组，“记住”迄今为止“最深”的 id和 level .如果为已处理 item level不连续或 indexId不适合 selection或“记住”id ，它不会添加到输出数组中。
返回的分支是“深度优先”的，即它找到的第一个，不一定是最深的。

const levels = [
    {
      indexId: 'A',
      level: 1,
      name: 'A',
      parent: '0',
    },
    {
      indexId: 'A-A1',
      level: 2,
      name: 'A1',
      parent: 'A',
    },
    {
      indexId: 'A-A1-A11',
      level: 3,
      name: 'A11',
      parent: 'A-A1',
    },
    {
      indexId: 'A-A1-A11-A111',
      level: 4,
      name: 'A111',
      parent: 'A-A1-A11',
    },
    {
      indexId: 'A-A1-A11-A112',
      level: 4,
      name: 'A112',
      parent: 'A-A1-A11',
    },
    {
      indexId: 'A-A1-A12',
      level: 3,
      name: 'A12',
      parent: 'A-A1',
    },
    {
      indexId: 'A-A1-A12-A121',
      level: 4,
      name: 'A121',
      parent: 'A-A1-A12',
    },
    {
      indexId: 'A-A1-A12-A121-A1211',
      level: 5,
      name: 'A1211',
      parent: 'A-A1-A12-A121',
    },
    {
      indexId: 'A-A2',
      level: 2,
      name: 'A2',
      parent: 'A',
    },
    {
      indexId: 'A-A2-A21',
      level: 3,
      name: 'A21',
      parent: 'A-A2',
    },

    {
      indexId: 'A-A2-A22',
      level: 3,
      name: 'A22',
      parent: 'A-A2',
    },
    {
      indexId: 'A-A3',
      level: 2,
      name: 'A3',
      parent: 'A',
    },
    {
      indexId: 'A-A3-A31',
      level: 3,
      name: 'A31',
      parent: 'A-A3',
    },
    {
      indexId: 'A-A3-A32',
      level: 3,
      name: 'A32',
      parent: 'A-A3',
    },
]

// auxiliary function to compare if 1st string starts with the second one or vice versa (according to legth)
function stringMatch(s1,s2) {
   return s1.length > s2.length ? s1.startsWith(s2) : s2.startsWith(s1);
}

// main function
function extract(input,selection="") {
   var id = "", level = 0; // initial conditions, storing "last" added item data
   return input.reduce((answer,item) => { // loop the input array and reduce it ...
      // do nothing (return unchenged answer) if ... 
      if (item.level !== level + 1) return answer; // ... level is not plus one from current level
      if (!item.indexId.startsWith(id)) return answer; // ... indexId does not start with current id
      if (!stringMatch(item.indexId,selection)) return answer; // ... item.indexId does not fit selection
      // update "last" data
      level = item.level;
      id = item.indexId;
      // return updated answer
      return [...answer,id];
   },[]); // reduction starts from empty array
}

// test
console.log(extract(levels));
// [ 'A', 'A-A1', 'A-A1-A11', 'A-A1-A11-A111' ]
console.log(extract(levels,"A-A2"));
// [ 'A', 'A-A2', 'A-A2-A21' ]
console.log(extract(levels,"A-A3"));
// [ 'A', 'A-A3', 'A-A3-A31' ]