变量查找方式及是否为常数时间？计算机如何定位与选择变量？

Great question—let’s break this down step by step, since variable lookup is one of those foundational runtime mechanics that’s easy to overlook but critical to how code executes.

How Variables Are Looked Up #

When your program runs, each new scope (like a function call, loop block, or even a let/const block in JS) creates a new stack frame (the "layer" you mentioned). Each stack frame includes a symbol table (or variable environment) that maps variable names to their actual locations—either the value itself (for primitive types stored on the stack) or a pointer to the value in the heap (for objects/arrays).

Lookup works by traversing the scope chain:

• Start with the current stack frame’s symbol table. If the variable name exists here, grab its location/value.
• If not, move up one level to the enclosing scope’s stack frame, and repeat.
• Keep going until you reach the global scope’s symbol table. If the variable isn’t found there, you’ll get an error (like ReferenceError in JavaScript).

Is Variable Lookup Constant Time? #

It depends on the language and runtime optimizations:

• Static languages (C++, Java, Rust): Most variable lookups are O(1) (constant time). During compilation, the compiler calculates the exact offset of each variable within its stack frame (or a fixed memory address for global variables). At runtime, the CPU just adds that offset to the stack pointer to find the variable instantly—no searching needed.
• Dynamic languages (JavaScript, Python, Ruby): By default, lookups use hash tables (symbol tables are often implemented as hash maps), which have average O(1) time complexity. However, worst-case is O(n) if there are hash collisions. Modern engines (like V8 for JS) optimize this with techniques like hidden classes or inline caches, which can turn dynamic lookups into near-O(1) operations for frequently accessed variables.

How Does the Computer Know a Variable’s Location? #

Again, split into static vs dynamic languages:

• Static languages: The compiler does all the work upfront. It assigns each local variable an offset from the stack pointer (e.g., "this variable lives 8 bytes below the top of the stack") and global variables get fixed memory addresses. At runtime, the CPU uses these precomputed values to jump directly to the variable’s location.
• Dynamic languages: The runtime maintains a symbol table for each scope. When you declare a variable, it adds an entry to the current scope’s table mapping the name to its value (or heap pointer). When you reference the variable, the runtime looks up the name in the table to get the location. Optimized engines might even cache the location of frequently used variables to avoid repeated hash table lookups.

Handling Name Collisions (Shadowing) #

When variables share the same name across different scopes, the rule is simple: the closest (most local) scope takes priority. This is called variable shadowing.

For example, in JavaScript:

const x = "global";

function foo() {
  const x = "local";
  console.log(x); // Logs "local"—the local x shadows the global one
}

foo();
console.log(x); // Logs "global"

The runtime stops traversing the scope chain as soon as it finds a matching name, so the local variable is used instead of any higher-level ones with the same name.

内容的提问来源于stack exchange，提问作者TheCommoner282