Hur kontrollerar man värdet av en associativ array med TypeScript?

Jag vill få det längsta namnvärdet i nedanstående associativa array i TypeScript. Vissa objekt i arrayen har barnarray. Jag vill kontrollera alla nästlade array.

    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" }
]

Så, mitt förväntade resultat var som nedan.

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

Jag fick koden nedan att ge output.

    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))

men denna kods utdata var { id: 'testtest', name: 'testtest2' }

Problemet är att min funktion inte är en loopnästad array. Kan någon ge mig råd, snälla?

Svar #1

Du kan använda rekursion på detta sätt:

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))

Svar #2

Eftersom du använder en rekursiv struktur i ditt gränssnitt, måste du därför använda en rekursiv funktion för att lösa ditt problem.

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" }
]

const getLongestNameObjectInTreeArray = (arr: Tree[])  => {
    let longestlength = 0
    let output: Tree;
    arr.forEach(e => {
        if (e.name.length > longestlength) {
            longestlength = e.name.length;
            output = { id: e.id, name: e.name };
        }

        if (e.child) {
            const childOutput = getLongestNameObjectInTreeArray(e.child);
            if (childOutput.name.length > longestlength) {
                longestlength = childOutput.name.length;
                output = { id: childOutput.id, name: childOutput.name };
            }
        }
    });

    return output;
}

console.log(getLongestNameObjectInTreeArray(treeArray))