JavaScript递归仅触发一次问题排查求助

Hey there! Let’s figure out why your recursive code is only picking up the first "complexType" node and missing the other 7. This is a super common pitfall with tree traversal—let’s break down the likely issues and fix them.

The Most Common Culprit: Premature Termination #

Chances are your current recursive function stops as soon as it finds the first match. For example, if you’re using return the moment you hit a "complexType" key, you’ll cut off the traversal before checking the rest of the JSON tree. Here’s what that might look like (a typical wrong approach):

# ❌ This code stops at the first match
def find_complex_types(node):
    if isinstance(node, dict):
        if "complexType" in node:
            return node["complexType"]  # Returns immediately, no further traversal
        for key, value in node.items():
            result = find_complex_types(value)
            if result:
                return result
    elif isinstance(node, list):
        for item in node:
            result = find_complex_types(item)
            if result:
                return result
    return None

Fix: Collect All Matches Instead of Returning Early #

The fix is to build a list of all "complexType" nodes instead of returning the first one. This way, your recursion keeps going through every branch of the JSON tree. Here’s a corrected version in Python:

# ✅ This collects all "complexType" nodes
def find_all_complex_types(node, results=None):
    # Initialize results list if it's the first call
    if results is None:
        results = []
    
    if isinstance(node, dict):
        # Check if current node has the target key
        if "complexType" in node:
            results.append(node["complexType"])
        # Recurse through all values in the dictionary
        for value in node.values():
            find_all_complex_types(value, results)
    elif isinstance(node, list):
        # Recurse through every item in the list
        for item in node:
            find_all_complex_types(item, results)
    
    return results

Key Changes Explained: #

• We use a mutable list (results) to accumulate matches across all recursive calls.
• Even after finding a "complexType" node, we keep traversing all other child nodes—no early returns.
• We handle both dictionaries (check keys, recurse values) and lists (recurse each item) to cover all parts of the JSON structure.

If You’re Using JavaScript (or Another Language) #

The logic translates directly. Here’s a JavaScript equivalent:

function findAllComplexTypes(node) {
    let results = [];

    if (typeof node === 'object' && node !== null) {
        // Check for the target key
        if ('complexType' in node) {
            results.push(node.complexType);
        }
        // Traverse all object properties
        for (const key in node) {
            if (node.hasOwnProperty(key)) {
                results = results.concat(findAllComplexTypes(node[key]));
            }
        }
    } else if (Array.isArray(node)) {
        // Traverse each array element
        node.forEach(item => {
            results = results.concat(findAllComplexTypes(item));
        });
    }

    return results;
}

Quick Checks to Verify #

• Double-check that your JSON’s remaining "complexType" nodes aren’t hidden in unexpected places (like nested arrays or deeply nested dictionaries)—the code above will handle these as long as you pass the root node to the function.
• Make sure you’re not filtering out any parts of the JSON before passing it to your traversal function.
• Test the function with a small subset of your JSON first to confirm it’s picking up multiple matches.

Once you implement this approach, you should get all 8 "complexType" nodes you’re expecting!

内容的提问来源于stack exchange，提问作者Andre.Santarosa