What we think we see
Reading an object in the console seems simple. You log it, expand it, and inspect its properties. In practice, what the console shows is not always what the code had at the exact moment of the log.
This is a common source of confusion, especially when state changes quickly or when multiple parts of the code manipulate the same reference.
The console and references
When an object is displayed in the console, it often shows a live reference. This means the visible values may change after the initial log.
It can feel like the console is lying, while it is actually showing the current state of the object, not necessarily the state at log time.
What is displayed is not always what was logged.
Why this is misleading
The natural reflex is to trust what is visible on screen. When a value looks wrong, the investigation often starts in the wrong place.
Time can be wasted inspecting correct logic, simply because the displayed object no longer matches the observed moment.
Making observation more reliable
To avoid this pitfall, it often helps to force a snapshot of the state:
- log primitives instead of entire objects
- clone the object before logging it
- structure logs to provide context
These habits reduce ambiguity and make console output easier to trust.
Reading the console with perspective
The console remains a powerful tool, as long as its limits are understood. It shows something real, but not always what we think we are looking at.
Understanding this gap helps avoid false conclusions and saves time while debugging 🙂