Loop through JavaScript object

You have to use the for-in loop

But be very careful when using this kind of loop, because this will loop all the properties along the prototype chain.

Therefore, when using for-in loops, always make use of the hasOwnProperty method to determine if the current property in iteration is really a property of the object you're checking on:

for (prop in p) {
    if (!p.hasOwnProperty(prop)) {
        //The current property is not a direct property of p
        continue;
    }
    //Do your logic with the property here
}

If you work with jQuery, you may use jQuery.each() method. It can be used to seamlessly iterate over both objects and arrays:

$.each(obj, function(key, value) {
    console.log(key, value);
});

Under ECMAScript 5, you can combine Object.keys() and Array.prototype.forEach():

    var obj = { first: "John", last: "Doe" };
    // Visit non-inherited enumerable keys
    Object.keys(obj).forEach(function(key) {
        console.log(key);
    });

You can just iterate over it like:

for (var key in p) {
  alert(p[key]);
}

Note that key will not take on the value of the property, it's just an index value.

via prototype with forEach() which should skip the prototype chain properties:

Object.prototype.each = function(f) {
    var obj = this
    Object.keys(obj).forEach( function(key) { 
        f( key , obj[key] ) 
    });
}


//print all keys and values
var obj = {a:1,b:2,c:3}
obj.each(function(key,value) { console.log(key + " " + value) });
// a 1
// b 2
// c 3

In ECMAScript 5 you have new approach in iteration fields of literal - Object.keys

More information you can see on MDN

My choice is below as a faster solution in current versions of browsers (Chrome30, IE10, FF25)

var keys = Object.keys(p),
    len = keys.length,
    i = 0,
    prop,
    value;
while (i < len) {
    prop = keys[i];
    value = p[prop];
    i += 1;
}

You can compare performance of this approach with different implementations on jsperf.com:

• Extend Implementations
• Object keys iteration
• object literal iteration

Browser support you can see on Kangax's compat table

For old browser you have simple and full polyfill

var p =
    {
        "p1": "value1",
        "p2": "value2",
        "p3": "value3"
    };

for (var key in p) 
{
    if (p.hasOwnProperty(key))
    {
    alert(key + " = " + p[key]);
    }
}
---------------------------
---------------------------
Output:
p1 = values1
p2 = values2
p3 = values3

After looking through all the answers in here, hasOwnProperty isn't required for my own usage because my json object is clean; there's really no sense in adding any additional javascript processing. This is all I'm using:

for (var key in p) {
    console.log(key + ' => ' + p[key]);
    // key is key
    // value is p[key]
}

I have put together a little JSON sample that iterates over a JavaScript object and posts the property values to a cross domain server that is hosts an DotNet.aspx page that then converts a C# object to a JSON string that is then posted back to the browser and converted back to a JavaScript object without having to use Window.Eval()

The resultant JavaScript object is then finally past back to a call-back function that is ready to uses and the code does not need 3rd party libraries, works in net framework 2.0 and upwards and has been tested with IE6-IE9, Firefox plus it's lightweight.

Click my name or see http://www.flashinvader.com/developers_corner/simple_json_objects_using_javascript_and_aspx.html for full details

for(key in p) {
  alert( p[key] );
}

Note: you can do this over arrays, but you'll iterate over the length and other properties, too.

Besause the asker's ultimate goal is to loop through some key value pairs and finally don't looking for a loop.

var p ={"p1":"value1","p2":"value2","p3":"value3"};
if('p1' in p){
  var val=p['p1'];
  ...
}