为何在JavaScript中window.alert()比alert()调用速度更慢？

Great question—this is super counterintuitive at first glance, right? Let’s unpack why modern JavaScript engines behave this way, even though it feels like explicitly referencing the global object should be faster.

1. How direct global calls get optimized #

When you call alert() directly, the JavaScript engine looks up the identifier in the scope chain, ending at the global scope. But modern engines (like V8 in Chrome/Node.js, SpiderMonkey in Firefox) have aggressive optimizations for commonly used global identifiers:

• They cache these identifiers (like alert, console, fetch) in an internal fast-access table, so the scope chain lookup is almost instantaneous—no actual traversal happens.
• The engine treats these global variables as "direct" references, skipping the full scope chain check entirely once cached.

2. The extra overhead of window.alert() #

When you use window.alert(), you’re adding an extra layer of property lookup:

• First, the engine still needs to find the window identifier (which is also a global variable, so it gets the same cached treatment).
• Then, it has to look up the alert property on the window object. This involves checking:
  • The window object’s own properties.
  • Traversing its prototype chain (even though window’s prototype is short, it’s an extra step that direct global calls skip).
• Some browsers also have special logic for window properties (like dynamic getters for certain APIs), which adds tiny but measurable overhead compared to the cached global identifier.

3. A quick note on engine evolution #

Early JavaScript engines did make explicit global object calls faster, because scope chain traversal was less optimized. But as engines evolved, they prioritized optimizing frequent global identifier access—since developers often call alert(), console.log(), etc., directly—making the direct call path faster than going through window.

If you want to test this yourself, you can use a simple performance benchmark (avoid actual alert() since it blocks execution; use a dummy global function instead):

// Setup a dummy global function
window.myTestFn = () => {};

console.time('direct call');
for (let i = 0; i < 1000000; i++) {
  myTestFn();
}
console.timeEnd('direct call');

console.time('window call');
for (let i = 0; i < 1000000; i++) {
  window.myTestFn();
}
console.timeEnd('window call');

You’ll almost always see the direct call finish faster in modern browsers.

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