How can I make console.log show the current state of an object?
I think you're looking for console.dir()
.
console.log()
doesn't do what you want because it prints a reference to the object, and by the time you pop it open, it's changed. console.dir
prints a directory of the properties in the object at the time you call it.
The JSON idea below is a good one; you could even go on to parse the JSON string and get a browsable object like what .dir() would give you:
console.log(JSON.parse(JSON.stringify(obj)));
console.log/console.dir showing last state of object, not current
That's a known issue -- sounds like you are running under Chrome.
The easiest work-around is to JSON encode the value as you log in.
console.log(JSON.stringify(a));
How can I display a JavaScript object?
If you want to print the object for debugging purposes, use the code:
var obj = {
prop1: 'prop1Value',
prop2: 'prop2Value',
child: {
childProp1: 'childProp1Value',
},
}
console.log(obj)
will display:
Note: you must only log the object. For example, this won't work:
console.log('My object : ' + obj)
Note ': You can also use a comma in the log
method, then the first line of the output will be the string and after that, the object will be rendered:
console.log('My object: ', obj);
Console.log showing only the updated version of the object printed
You have no problem with the sort but this is a well known peculiarity (an optimization) of most browser consoles : the tree is only built when you open the object, with the new values of the object.
If you want to see the state of the object at the time of logging, supposing it's a small enough and not self referencing object, you may clone it like this :
console.log(JSON.parse(JSON.stringify(annoObj.anno)));
console.log() shows the changed value of a variable before the value actually changes
Pointy's answer has good information, but it's not the correct answer for this question.
The behavior described by the OP is part of a bug that was first reported in March 2010, patched for Webkit in August 2012, but as of this writing is not yet integrated into Google Chrome. The behavior hinges upon whether or not the console debug window is open or closed at the time the object literal is passed to console.log()
.
Excerpts from the original bug report (https://bugs.webkit.org/show_bug.cgi?id=35801):
Description From mitch kramer 2010-03-05 11:37:45 PST
1) create an object literal with one or more properties
2) console.log that object but leave it closed (don't expand it in the console)
3) change one of the properties to a new value
now open that console.log and you'll see it has the new value for some reason, even though it's value was different at the time it was generated.
I should point out that if you open it, it will retain the correct value if that wasn't clear.
Response from a Chromium developer:
Comment #2 From Pavel Feldman 2010-03-09 06:33:36 PST
I don't think we are ever going to fix this one. We can't clone object upon dumping it into the console and we also can't listen to the object properties' changes in order to make it always actual.
We should make sure existing behavior is expected though.
Much complaining ensued and eventually it led to a bug fix.
Changelog notes from the patch implemented in August 2012 (http://trac.webkit.org/changeset/125174):
As of today, dumping an object (array) into console will result in objects' properties being
read upon console object expansion (i.e. lazily). This means that dumping the same object while
mutating it will be hard to debug using the console.This change starts generating abbreviated previews for objects / arrays at the moment of their
logging and passes this information along into the front-end. This only happens when the front-end
is already opened, it only works for console.log(), not live console interaction.
Can't access object property, even though it shows up in a console log
The output of console.log(anObject)
is misleading; the state of the object displayed is only resolved when you expand the Object tree displayed in the console, by clicking on >
. It is not the state of the object when you console.log
'd the object.
Instead, try console.log(Object.keys(config))
, or even console.log(JSON.stringify(config))
and you will see the keys, or the state of the object at the time you called console.log
.
You will (usually) find the keys are being added after your console.log
call.
JavaScript logging object with mutating state
I would solve this by making a "deep copy" of what you are logging, and passing the copy to console.dir(). Something like this works pretty well:
function deep_copy(ref)
{
var r;
var i;
if(isHash(ref))
{
r = {};
for(i in ref)
r[i] = deep_copy(ref[i]);
}
else if(isArray(ref))
{
r = [];
for(i = 0; i < ref.length; i++)
r[i] = deep_copy(ref[i]);
}
else
{
r = ref;
}
return r;
}
If you don't want to bother with something like this, then using JSON.stringify
is a great workaround and won't be much slower if it's native in the browser.
console.dir(JSON.parse(JSON.stringify(o));
Related Topics
Group Array of Object Nesting Some of the Keys With Specific Names
Graph Visualization Library in JavaScript
Display Data Streamed from a Flask View as It Updates
What's the Right Way to Decode a String That Has Special HTML Entities in It
Leaflet Map Not Displayed Properly Inside Tabbed Panel
Toggle Visibility Property of Div
Jquery Animate() and Backgroundcolor
Detecting Touch Screen Devices with JavaScript
Why Doesn't Indexof Work on an Array IE8
Difference Between Innertext, Innerhtml and Value
Use of .Apply() With 'New' Operator. Is This Possible
Static Variables in JavaScript
Crockford'S Prototypal Inheritance - Issues With Nested Objects
What Is the JavaScript ≫≫≫ Operator and How to Use It
Synchronized Scrolling Using Jquery
Change CSS of Class in JavaScript
Combination of Animation and Transition Not Working Properly