How to Get the Value by a Key from a Super Nested Json

var object = {  "nodes": [{    "nd": "nd1",    "cat": "cat1"  }],  "links": [{    "id": 100  }],  "types": [{    "type": "one",    "image": "image001"  }, {    "type": "two",    "image": "image002"  }, {    "type": "three",    "image": "image003"  }]};

function parseJson(object){    object.types.forEach(function(key) {      console.log(key.type);    });}
parseJson(object);

How to return specific key value pair from nested json without knowing location?

The underlying question is: how can we make multiple recursive calls in a loop, return the recursive result if any of them returns something useful, and fail otherwise?

If we blindly return inside the loop, then only one recursive call can be made. Whatever it returns, gets returned at this level. If it didn't find the useful result, we don't get a useful result.

If we blindly don't return inside the loop, then the values that were returned don't matter. Nothing in the current call makes use of them, so we will finish looping, make all the recursive calls, reach the end of the function... and thus implicitly return None.

The way around this, of course, is to check whether the recursive call returned something useful. If it did, we can return that; otherwise, we keep going. If we reach the end, then we signal that we couldn't find anything useful - that way, if we are being recursively called, the caller can do the right thing.

Assuming that None cannot be a "useful" value, we can naturally use that as the signal. We don't even have to return it explicitly at the end.

After fixing some other typos (we should not overwrite the global built-in dict name, and anyway we don't need to name the dict that we pass in at the start, and the parameter should be m_dict so that it's properly defined when we make the recursive call), we get:

def recursive_json(data, attr, m_dict):
    for k,v in data.items():
        if k == attr:
            for k2,v2 in v.items():
                m_dict = {attr, v2}
                print('IF: ', m_dict)
                return m_dict
        elif isinstance(v,dict):
            result = recursive_json(v, attr, m_dict)
            if result:
                return result

# call it:
recursive_json(json_data, "Date", {})

We can see that the debug trace is printed, and the value is also returned.

Let's improve this a bit:

First off, the inner for k2,v2 in v.items(): loop doesn't make any sense. Again, we can only return once per call, so this would skip any values in the dict after the first. We would be better served just returning v directly. Also, the m_dict parameter doesn't actually help implement the logic; we don't modify it between calls. It doesn't make sense to use a set for our return value, since it's fundamentally unordered; we care about the order here. Finally, we don't need the debug trace any more. That gives us:

def recursive_json(data, attr):
    for k, v in data.items():
        if k == attr:
            return attr, v
        elif isinstance(v,dict):
            result = recursive_json(v, attr)
            if result:
                return result

To get fancier, we can separate the base case from the recursive case, and use more elegant tools for each. To check if any of the keys matches, we can simply check with the in operator. To recurse and return the first fruitful result, the built-in next is useful. We get:

def recursive_json(data, attr):
    if not isinstance(data, dict):
        # reached a leaf, can't search in here.
        return None
    if attr in data:
        return k, data[k]
    candidates = (recursive_json(v, attr) for v in data.values())
    try:
        # the first non-None candidate, if any.
        return next(c for c in candidates if c is not None)
    except StopIteration:
        return None # all candidates were None.

Related Topics