What is the difference between ES modules and CommonJS?

Q: What is the difference between ES modules and CommonJS?

**Target Audience:** Engineers preparing for JavaScript/Node.js fundamentals interviews. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . The caching and environment claims below were actually run in Node, directly inside a real CommonJS script. ## 1. Why This Even Matters — A Story First CommonJS's `require()` is like asking a librarian in person for a book by a title you might decide on the spot, even conditionally ("if it's raining, get me the umbrella book") — genuinely flexible, but the librarian cannot know your FULL reading list in advance without actually watching you ask. ES modules' `import` is like submitting a complete, fixed reading list in writing before the library even opens for the day — the librarian (a bundler) can now genuinely plan the most efficient route through the shelves in advance, pulling only the specific books actually needed, because the whole list was f

The problem

Question presented to candidate: "CommonJS caches modules so that requiring the same file twice returns the exact same object. Does ES modules' import behave the same way, and what's the real, structural reason ES modules' imports are called 'static'?"

What a strong answer should cover:

📌 Interview term: CommonJS (require/module.exports) — Node's original module system, where require() is a genuine runtime function call — it can be called conditionally, inside an if, or with a dynamically-computed path — and modules are cached, so repeated require() calls for the same file genuinely return the identical object reference.
📌 Interview term: ES modules (import/export) — the standardized JavaScript module system, where import is static — its specifiers must be literal strings known at parse time, before any code runs, genuinely enabling static analysis (dead-code elimination/tree-shaking) that CommonJS's fully dynamic require() cannot reliably support.
📌 Interview term: the real, direct answer to the prompt's first question — verified directly (inside this very answer's own CommonJS verification script): CommonJS's caching is real and directly confirmed — two separate require("fs") calls genuinely returned the exact same object reference (===). ES modules provide the equivalent guarantee too — a module is genuinely evaluated only once, with every importer sharing the same live bindings, though verifying it requires a real .mjs/ES-module file rather than eval, since import cannot appear inside a CommonJS script.
📌 Interview term: the real, structural reason "static" matters — because an ES module's imports are fixed, literal strings resolved BEFORE execution, a bundler/tool can genuinely determine the complete, exact dependency graph — and which specific exports are actually used — without running any code at all; CommonJS's require(computedPathVariable) genuinely cannot be analyzed that reliably ahead of time, since the actual path might only be knowable at runtime.
A precise answer names that ES modules are strict mode by default, with no separate this/module/exports/require available inside them (this very verification script directly confirms those genuinely exist as real values in the CommonJS environment it runs in, by contrast) and support genuine top-level await, which CommonJS files do not.

Clarifying questions expected:

None — this is a definitional/comparison question; directly answering the prompt's own caching and "static" questions is the strong signal.

Code / implementation expected: Yes — verifying CommonJS's real caching behavior directly (and naming what makes ES modules' imports genuinely static) is the clearest demonstration.

modules

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript/Node.js fundamentals interviews. Difficulty: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. The caching and environment claims below were actually run in Node, directly inside a real CommonJS script.

1. Why This Even Matters — A Story First

CommonJS's require() is like asking a librarian in person for a book by a title you might decide on the spot, even conditionally ("if it's raining, get me the umbrella book") — genuinely flexible, but the librarian cannot know your FULL reading list in advance without actually watching you ask. ES modules' import is like submitting a complete, fixed reading list in writing before the library even opens for the day — the librarian (a bundler) can now genuinely plan the most efficient route through the shelves in

The solution is hidden so you can try first

6 min read · 8 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal proof, run inside an actual CommonJS environment: require/module/exports genuinely exist here, and repeated require calls return the identical cached reference