Introduction

“View all defined variables” sounds simple, but the real answer depends on scope, language, and tool. In practice, you are usually asking for one of three things: all local variables in the current function, all globals in the current module, or the current variable state inside a debugger.

Scope Comes First

Before listing variables, decide which scope you care about:

• local scope inside a function
• global scope for a module or script
• object attributes on a specific instance
• debugger-visible variables at a breakpoint

Without that distinction, “all variables” is misleading because programs can contain many overlapping symbol tables.

Python: locals(), globals(), and vars()

In Python, the standard tools are built in.

List local variables:

1def demo():
2    count = 3
3    name = "Ada"
4    print(locals())
5
6demo()

List global variables:

1project = "codemia"
2version = 1
3
4print(globals())

Inspect attributes on an object:

1class User:
2    def __init__(self, name, age):
3        self.name = name
4        self.age = age
5
6user = User("Grace", 37)
7print(vars(user))

These tools are useful, but they return dictionaries containing more than the variables you might casually expect, especially in module scope.

Python Debugging Is Often Better Than Printing

For real debugging, stopping the program and inspecting variables is often more useful than dumping a large dictionary.

1def divide(a, b):
2    result = a / b
3    breakpoint()
4    return result
5
6divide(10, 2)

At the breakpoint, you can inspect current names interactively. This is usually clearer than printing every symbol table in a large program because you can focus on the variables that matter in the failing context.

JavaScript: Browser and Node Scope Tools

In JavaScript, scope inspection depends heavily on the environment.

In a browser console, console.log(window) or console.log(globalThis) shows globally available names:

1const userName = "Ada";
2let score = 42;
3
4console.log(globalThis);

Inside a function, you usually inspect values directly or rely on DevTools scope panels:

1function demo() {
2  const count = 3;
3  const status = "ready";
4  debugger;
5}
6
7demo();

When execution stops at debugger, browser DevTools show local, closure, and global scope separately. That is often the most useful “view all variables” answer in JavaScript.

Shell and REPL Environments

Interactive environments often provide their own commands. In a Python REPL, the current namespace can be viewed with locals() or globals(). In shells, variable listing is usually environment-specific.

For example in a Unix shell:

name="Ada"
count=3
set

This is a reminder that “all variables” is not a language concept alone. It is also a runtime and tooling concept.

IDEs and Debuggers Are Usually the Best Option

If your real goal is debugging, use the debugger’s variables view instead of writing custom code to print symbol tables. IDEs and debuggers usually separate:

• locals
• globals
• captured variables
• object members

That is better than a raw dump because the display is structured around program state, not just raw name dictionaries.

This is especially important in larger applications where blindly printing everything creates more noise than insight.

Know the Cost of Introspection

Listing variables can be helpful, but it is not always the right production technique. Problems include:

• large outputs that hide the important value
• accidental logging of secrets
• confusion between names that exist and names that actually matter

Introspection tools are best used for debugging, learning, or targeted inspection, not as a permanent substitute for clear program structure.

Common Pitfalls

• Asking for “all variables” without deciding whether local, global, object, or debugger scope is the real target.
• Printing entire symbol tables in production logs and leaking sensitive data.
• Assuming globals() or window represents only user-defined variables when many built-in names are also present.
• Ignoring debugger tooling and writing noisy introspection code instead.
• Confusing object attributes with variables in the current function or module scope.

Summary

• The right way to view variables depends on scope and environment.
• In Python, use locals(), globals(), and vars() for explicit introspection.
• In JavaScript, debugger scope panels and globalThis are common inspection tools.
• IDE debuggers are usually the clearest way to inspect current variable state.
• Introspection is useful for debugging, but it should be targeted and used carefully.