What is globalThis in JavaScript, and what problem does it solve that window, self, and global did not?

## The problem globalThis solves JavaScript has always had a global object — the object that holds the global bindings and the built-ins — but for most of its history it had no standard *name*. Each host invented its own: - a browser page exposes it as `window` (and, historically, `frames` and `self`); - a Web Worker exposes it as `self`, and has no `window` at all; - Node exposes it as `global`, and has neither `window` nor `self`. So any code meant to run in more than one of those places could not simply write the global object's name. That is a real problem for polyfills, feature detection, and any library that wants to stash or read something globally. ## The workarounds, and why each one broke The sniffing chain was the common approach: ```js var root = typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : typeof global !== 'undefined' ? global : undefined; ``` It works but has to be extended for every new host, and it silently produces `undefined` in one it does not know about. The clever alternative was `Function('return this')()`. A function created from a string is not in strict mode by default, and a non-strict function called with no receiver gets the global object as `this`. That is portable in principle, but it constructs code from a string, which is exactly what environments that forbid dynamic code evaluation block — so the trick throws in precisely the hardened environments where you least want a surprise. A third habit was `var root = this;` at the top of a file. That works only in a classic script; in an ES module top-level `this` is `undefined`, and in a CommonJS module it is `module.exports`. ## What globalThis actually is ES2020 added `globalThis` as a property of the global object whose value is the global object. Its attributes are writable, configurable, and non-enumerable — it is an ordinary data property, not magic syntax. That means all of these hold in their respective hosts: ```js // browser page globalThis === window; // true // Web Worker globalThis === self; // true // Node globalThis === global; // true ``` Because it is a normal property and a normal identifier, a local binding named `globalThis` shadows it inside that scope, and `globalThis` itself can be reassigned. In practice nobody does either, but it explains why very defensive library code still guards. ## Portable name, not portable capabilities The most common misreading is that `globalThis` unifies the *environments*. It does not — it unifies the *name*. Whatever the host does or does not provide is unchanged: reading `globalThis.document` in a non-browser environment gives `undefined` rather than a document, and the correct check is still a capability check (`typeof globalThis.document !== 'undefined'`) rather than an environment check. ## Which declarations end up on globalThis A related detail that interviewers like: in a **classic script**, top-level `var` declarations and function declarations create properties on the global object, while `let`, `const` and `class` create bindings in a separate global declarative scope that is *not* reflected on the global object. ```js // classic script var a = 1; let b = 2; globalThis.a; // 1 globalThis.b; // undefined ``` In an **ES module** none of them touch the global object — module top-level scope is module-local. So the only deliberate way to publish something globally from a module is an explicit assignment: `globalThis.myThing = myThing`. Being explicit is a feature, not a limitation: it makes global writes greppable instead of an accident of declaration keyword. ## When you should reach for it Use `globalThis` when you genuinely need the global object: installing or detecting a polyfill, reading a global injected by another script, or writing environment-agnostic library code. Do not use it as a general-purpose place to hang application state — a global is a global, with all the coupling and testing pain that implies, no matter how portable its name is.