如何使用by TypeScript检查关联数组的值？

我想在TypeScript的bellow关联数组中获取最长的名称值。 数组中的某些对象具有子数组。 我要检查所有嵌套数组

    interface Tree {
    id: string
    name: string
    child?: Tree[]
}
const treeArray: Tree[] = [
    {
        id: "test", name: "test1", child: [
            { id: "Test#2", name: "@2ndtest" },
            {
                id: "test#2", name: "2ndtest", child: [
                    { id: "Test#2#3", name: "@3rdtestTestTest" },
                ]
            }
        ]
    },
    { id: "testtest", name: "testtest2" }
]

所以，我的预期输出如下

{ id: "Test#2#3", name: "@3rdtestTestTest" }

我让下面的代码得到输出

    const getLongestNameObjectInTreeArray = (value: Tree[]) => {
    let getObj: Tree = { id: "", name: "" }
    let longestName = 0
    value.forEach((v) => {
        let nameLength = v.name.length
        if (<any>nameLength > longestName) {
            longestName = <any>nameLength
            getObj = { id: v.id, name: v.name }
        }
    })
    return getObj
}
console.log(getLongestNameObjectInTreeArray(treeArray))

const getLongestNameObjectInTreeArray=（值：Tree[]）=>{
让getObj:Tree={id:，name:}
设longestName=0
值。forEach（（v）=>{
让nameLength=v.name.length
如果（名称长度>最长名称）{
longestName=nameLength
getObj={id:v.id，name:v.name}
}
})
返回getObj
}
console.log（getLongestNameObjectInTreeArray（Trearray））

但是这个代码输出是

{id:'testtest'，name:'testtest2'}

问题是我的函数不是循环嵌套数组。

---

有人建议我吗？

由于您在接口中使用递归结构，因此必须使用递归函数来解决问题

interface Tree {
    id: string
    name: string
    child?: Tree[]
}

const treeArray: Tree[] = [
    {
        id: "test", name: "test1", child: [
            { id: "Test#2", name: "@2ndtest" },
            {
                id: "test#2", name: "2ndtest", child: [
                    { id: "Test#2#3", name: "@3rdtestTestTest" },
                ]
            }
        ]
    },
    { id: "testtest", name: "testtest2" }
]

---

您可以像这样使用递归：

function getLongestName(tree:Tree):string{
    let treeName = tree.name;
    let longestChildName = tree.child?.reduce((a,b)=>{
        let bName=getLongestName(b);
        return (a.length>bName.length)?a:bName
    },treeName)??treeName
    return longestChildName
}
function getLongestNameArray(trees:Tree[]):string{
    return trees.map(tree=>getLongestName(tree)).reduce((nameA,nameB)=>nameA.length>nameB.length?nameA:nameB,"");
}
console.log(getLongestNameArray(treeArray))

---

令人惊叹的！！我真的很感激你的回答！！我没有任何使用递归函数的想法。我明白！！非常感谢你！！

function getLongestName(tree:Tree):string{
    let treeName = tree.name;
    let longestChildName = tree.child?.reduce((a,b)=>{
        let bName=getLongestName(b);
        return (a.length>bName.length)?a:bName
    },treeName)??treeName
    return longestChildName
}
function getLongestNameArray(trees:Tree[]):string{
    return trees.map(tree=>getLongestName(tree)).reduce((nameA,nameB)=>nameA.length>nameB.length?nameA:nameB,"");
}
console.log(getLongestNameArray(treeArray))