Nsryjdtyk

If you think jQuery is kind of overkill for such a primitive task, you could do something like that:

//your object

var o = { 

    foo:"bar",

    arr:[1,2,3],

    subo: {

        foo2:"bar2"

    }

};



//called with every property and its value

function process(key,value) {

    console.log(key + " : "+value);

}



function traverse(o,func) {

    for (var i in o) {

        func.apply(this,[i,o[i]]);  

        if (o[i] !== null && typeof(o[i])=="object") {

            //going one step down in the object tree!!

            traverse(o[i],func);

        }

    }

}



//that's all... no magic, no bloated framework

traverse(o,process);

A JSON object is simply a Javascript object. That's actually what JSON stands for: JavaScript Object Notation. So you'd traverse a JSON object however you'd choose to "traverse" a Javascript object in general.

In ES2017 you would do:

Object.entries(jsonObj).forEach(([key, value]) => {

    // do something with key and val

});

You can always write a function to recursively descend into the object:

function traverse(jsonObj) {

    if( jsonObj !== null && typeof jsonObj == "object" ) {

        Object.entries(jsonObj).forEach(([key, value]) => {

            // key is either an array index or object key

            traverse(value);

        });

    }

    else {

        // jsonObj is a number or string

    }

}

This should be a good starting point. I highly recommend using modern javascript methods for such things, since they make writing such code much easier.

function traverse(o ) {

    for (i in o) {

        if (!!o[i] && typeof(o[i])=="object") {

            console.log(i, o[i])

            traverse(o[i] );

        }

    }

}

There's a new library for traversing JSON data with JavaScript that supports many different use cases.

https://npmjs.org/package/traverse

https://github.com/substack/js-traverse

It works with all kinds of JavaScript objects. It even detects cycles.

It provides the path of each node, too.

Depends on what you want to do. Here's an example of traversing a JavaScript object tree, printing keys and values as it goes:

function js_traverse(o) {

    var type = typeof o 

    if (type == "object") {

        for (var key in o) {

            print("key: ", key)

            js_traverse(o[key])

        }

    } else {

        print(o)

    }

}



js> foobar = {foo: "bar", baz: "quux", zot: [1, 2, 3, {some: "hash"}]}

[object Object]

js> js_traverse(foobar)                 

key:  foo

bar

key:  baz

quux

key:  zot

key:  0

1

key:  1

2

key:  2

3

key:  3

key:  some

hash

If you're traversing an actual JSON string then you can use a reviver function.

function traverse (json, callback) {

  JSON.parse(json, function (key, value) {

    if (key !== '') {

      callback.call(this, key, value)

    }

    return value

  })

}



traverse('{"a":{"b":{"c":{"d":1}},"e":{"f":2}}}', function (key, value) {

  console.log(arguments)

})

When traversing an object:

function traverse (obj, callback, trail) {

  trail = trail || 



  Object.keys(obj).forEach(function (key) {

    var value = obj[key]



    if (Object.getPrototypeOf(value) === Object.prototype) {

      traverse(value, callback, trail.concat(key))

    } else {

      callback.call(obj, key, value, trail)

    }

  })

}



traverse({a: {b: {c: {d: 1}}, e: {f: 2}}}, function (key, value, trail) {

  console.log(arguments)

})

I wanted to use the perfect solution of @TheHippo in an anonymous function, without use of process and trigger functions. The following worked for me, sharing for novice programmers like myself.

(function traverse(o) {

    for (var i in o) {

        console.log('key : ' + i + ', value: ' + o[i]);



        if (o[i] !== null && typeof(o[i])=="object") {

            //going on step down in the object tree!!

            traverse(o[i]);

        }

    }

  })

  (json);

Most Javascript engines do not optimize tail recursion (this might not be an issue if your JSON isn't deeply nested), but I usually err on the side of caution and do iteration instead, e.g.

function traverse(o, fn) {

    const stack = [o]



    while (stack.length) {

        const obj = stack.shift()



        Object.keys(obj).forEach((key) => {

            fn(key, obj[key], obj)

            if (obj[key] instanceof Object) {

                stack.unshift(obj[key])

                return

            }

        })

    }

}



const o = {

    name: 'Max',

    legal: false,

    other: {

        name: 'Maxwell',

        nested: {

            legal: true

        }

    }

}



const fx = (key, value, obj) => console.log(key, value)

traverse(o, fx)

For a newer way to do it if you don't mind dropping IE and mainly supporting more current browsers (check kangax's es6 table for compatibility). You can use es2015 generators for this. I've updated @TheHippo's answer accordingly. Of course if you really want IE support you can use the babel JavaScript transpiler.

//your object

var o = { 

    foo:"bar",

    arr:[1,2,3],

    subo: {

        foo2:"bar2"

    }

};



function* traverse(o,func) {

    for (var i in o) {

        yield [i,o[i]]; 

        if (o[i] !== null && typeof(o[i])=="object") {

            //going one step down in the object tree!!

            yield* traverse(o[i],func);

        }

    }

}



//that's all... no magic, no bloated framework

for(var [key, value] of traverse(o)) {

  console.log(key, value);

}

If you want only own enumerable properties (basically non-prototype chain properties) you can change it to iterate using Object.keys and a for...of loop instead:

//your object

var o = { 

    foo:"bar",

    arr:[1,2,3],

    subo: {

        foo2:"bar2"

    }

};



function* traverse(o,func) {

    for (var i of Object.keys(o)) {

        yield [i,o[i]]; 

        if (o[i] !== null && typeof(o[i])=="object") {

            //going one step down in the object tree!!

            yield* traverse(o[i],func);

        }

    }

}



//that's all... no magic, no bloated framework

for(var [key, value] of traverse(o)) {

  console.log(key, value);

}

My Script:

op_needed = ;

callback_func = function(val) {

  var i, j, len;

  results = ;

  for (j = 0, len = val.length; j < len; j++) {

    i = val[j];

    if (i['children'].length !== 0) {

      call_func(i['children']);

    } else {

      op_needed.push(i['rel_path']);

    }

  }

  return op_needed;

};

Input JSON:

[

    {

        "id": null, 

        "name": "output",   

        "asset_type_assoc": , 

        "rel_path": "output",

        "children": [

            {

                "id": null, 

                "name": "output",   

                "asset_type_assoc": , 

                "rel_path": "output/f1",

                "children": [

                    {

                        "id": null, 

                        "name": "v#",

                        "asset_type_assoc": , 

                        "rel_path": "output/f1/ver",

                        "children": 

                    }

                ]

            }

       ]

   }

]

Function Call:

callback_func(inp_json);

Output as per my Need:

["output/f1/ver"]

The best solution for me was the following:

simple and without using any framework

    var doSomethingForAll = function (arg) {

       if (arg != undefined && arg.length > 0) {

            arg.map(function (item) {

                  // do something for item

                  doSomethingForAll (item.subitem)

             });

        }

     }

You can get all keys / values and preserve the hierarchy with this

// get keys of an object or array

function getkeys(z){

  var out=; 

  for(var i in z){out.push(i)};

  return out;

}



// print all inside an object

function allInternalObjs(data, name) {

  name = name || 'data';

  return getkeys(data).reduce(function(olist, k){

    var v = data[k];

    if(typeof v === 'object') { olist.push.apply(olist, allInternalObjs(v, name + '.' + k)); }

    else { olist.push(name + '.' + k + ' = ' + v); }

    return olist;

  }, );

}



// run with this

allInternalObjs({'a':[{'b':'c'},{'d':{'e':5}}],'f':{'g':'h'}}, 'ob')

This is a modification on (https://stackoverflow.com/a/25063574/1484447)

             var localdata = [{''}]// Your json array

              for (var j = 0; j < localdata.length; j++) 

               {$(localdata).each(function(index,item)

                {

                 $('#tbl').append('<tr><td>' + item.FirstName +'</td></tr>);

                 }

I've created library to traverse and edit deep nested JS objects. Check out API here: https://github.com/dominik791

You can also play with the library interactively using demo app:
https://dominik791.github.io/obj-traverse-demo/

Examples of usage:
You should always have root object which is the first parameter of each method:

var rootObj = {

  name: 'rootObject',

  children: [

    {

      'name': 'child1',

       children: [ ... ]

    },

    {

       'name': 'child2',

       children: [ ... ]

    }

  ]

};

The second parameter is always the name of property that holds nested objects. In above case it would be 'children'.

The third parameter is an object that you use to find object/objects that you want to find/modify/delete. For example if you're looking for object with id equal to 1, then you will pass { id: 1} as the third parameter.

And you can:

1. 
   findFirst(rootObj, 'children', { id: 1 }) to find first object
   with id === 1
   


2. 
   findAll(rootObj, 'children', { id: 1 }) to find all objects
   with id === 1
   


3. 
   findAndDeleteFirst(rootObj, 'children', { id: 1 }) to delete first matching object


4. 
   findAndDeleteAll(rootObj, 'children', { id: 1 }) to delete all matching objects

replacementObj is used as the last parameter in two last methods:

1. 
   findAndModifyFirst(rootObj, 'children', { id: 1 }, { id: 2, name: 'newObj'}) to change first found object with id === 1 to the { id: 2, name: 'newObj'}
   


2. 
   findAndModifyAll(rootObj, 'children', { id: 1 }, { id: 2, name: 'newObj'}) to change all objects with id === 1 to the { id: 2, name: 'newObj'}