Pracuję z tablicą obiektów kategorii, które mogą mieć tablicę obiektów kategorii podrzędnych. Trudną częścią jest to, że głębokość tych zagnieżdżonych danych jest nieznana (i może się zmienić). (Patrz przykład na dole.) Próbuję przywrócić „ślad” do obiektu kategorii, ale mam wiele trudności.

Idealnie coś takiegofindCategory('b4') wróci:['c1', 'd2', 'd3', 'b4'] (Patrz próbka).

Myślę, że mój problem polega na tym, że mam problem z prawidłowym wyłamaniem się z zagnieżdżonych pętli spowodowanym przez moją rekursję. Czasami dostaję dodatkowe kategorie na mojej ścieżce lub, gdy myślę, że się zepsułem, na szlaku kończy się jakaś głębsza zagnieżdżona kategoria.

Jeden wynik może wyglądać następująco. Najwyraźniej nie zabija pętli na b4 i nie jestem pewien, dlaczego wynik został znaleziony dwukrotnie.

b4
FOUND
["c1", "d2", "d3", "b4"]
e2
FOUND
["c1", "d2", "d3", "b4", "e2"] 

Bonus, jeśli możesz również pokazać mi wersję underscore.js.

JSFiddle Link tutaj...

// Start function
function findCategory(categoryName) {
    var trail = [];
    var found = false;

    function recurse(categoryAry) {

        for (var i=0; i < categoryAry.length; i++) {
            console.log(categoryAry[i].category);
            trail.push(categoryAry[i].category);

            // Found the category!
            if ((categoryAry[i].category === categoryName) || found) {
                console.log('FOUND');
                found = true;
                console.log(trail);
                break;

            // Did not match...
            } else {

                // Are there children / sub-categories? YES
                if (categoryAry[i].children.length > 0) {

                    console.log('recurse');
                    recurse(categoryAry[i].children);

                // NO
                } else {
                    trail.pop();
                    if (i === categoryAry.length - 1) {
                        trail.pop();
                    }
                }
            }

        } 
    }

    return recurse(catalog);
}

console.clear();
console.log(findCategory('b4'));

Na przykład. Obiekty kategorii tablicowej z zagnieżdżoną tablicą obiektów kategorii. Załóżmy, że głębokość zagnieżdżania jest nieznana.

var catalog = [
{
    category:"a1",
    children:[
        {
            category:"a2",
            children:[]
        },
        {
            category:"b2",
            children:[
                {
                    category:"a3",
                    children:[]
                },
                {
                    category:"b3",
                    children:[]
                }
            ]
        },
        {
            category:"c2",
            children:[]
        }
    ]
},
{
    category:"b1",
    children:[]
},
{
    category:"c1",
    children:[
        {
            category:"d2",
            children:[
                {
                    category:"c3",
                    children:[]
                },
                {
                    category:"d3",
                    children:[
                        {
                            category:"a4",
                            children:[]
                        },
                        {
                            category:"b4",
                            children:[]
                        },
                        {
                            category:"c4",
                            children:[]
                        },
                        {
                            category:"d4",
                            children:[]
                        }
                    ]
                }
            ]
        },
        {
            category:"e2",
            children:[
                {
                    category:"e3",
                    children:[]
                }
            ]
        }
    ]
}
];