Modules: ESM and CommonJS, and what an import really gives you

Node has two module systems. CommonJS (CJS) is the original: require() and module.exports. ES modules (ESM) are the language standard: import and export, used by browsers, bundlers and modern Node. In Node, a .mjs file is ESM, a .cjs file is CommonJS, and a .js file is whichever the nearest package.json says with its "type" field. With no "type" it is treated as CommonJS — unless it contains import/export syntax, in which case current Node 22 loads it as ESM instead (the second example shows it). Set "type" explicitly rather than rely on that guess.

// CommonJS
const { readFile } = require("node:fs");
module.exports = { parse };

// ESM
import { readFile } from "node:fs";
export function parse() {}

The differences that matter

Static imports are what let bundlers remove unused exports ("tree-shaking"): the full dependency graph is known without running anything.

Each module runs once

Both systems cache a module the first time it is loaded. Later require calls or imports get the same module instance, and the module's top-level code does not run again. That is why a module holding a database pool or a counter acts as a singleton within one process.

Copy versus live binding

const { count } = require("./counter") copies whatever count was at that moment into a new local variable; later changes inside the module do not reach it. An ESM import { count } is not a copy: it reads the exporter's variable every time, so it always shows the current value — and the importer cannot assign to it.

Circular dependencies

If a requires b while a is still running, and b requires a, CommonJS does not loop forever: b gets a's exports object as it is at that moment, partly filled. Anything a exports after its require("b") line is missing when b looks. This works only because the module is put in the cache before its code runs.

The first example writes small CommonJS files and loads them; the second runs two ES modules, and then an untyped .js file, in a separate Node process.

1const fs = require("node:fs");2const os = require("node:os");3const path = require("node:path");4 5export function run() {6  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "cjs-"));7  const write = (name, src) => fs.writeFileSync(path.join(dir, name), src);8  globalThis.evaluations = [];9 10  write("counter.js", `11    globalThis.evaluations.push("counter.js");12    let count = 0;13    exports.count = count;14    exports.increment = () => { count++; exports.count = count; };15  `);16  write("a.js", `17    globalThis.evaluations.push("a.js");18    exports.early = "set before requiring b";19    const b = require("./b.js");20    exports.late = "set after requiring b";21    exports.bSaw = b.sawFromA;22  `);23  write("b.js", `24    globalThis.evaluations.push("b.js");25    exports.sawFromA = Object.keys(require("./a.js"));26  `);27 28  const counter = require(path.join(dir, "counter.js"));29  const { count } = require(path.join(dir, "counter.js"));30  counter.increment();31  counter.increment();32  const a = require(path.join(dir, "a.js"));33 34  return {35    evaluations: globalThis.evaluations,36    destructuredCount: count,37    propertyCount: counter.count,38    sameObject: counter === require(path.join(dir, "counter.js")),39    bSawFromA: a.bSaw,40  };41}

1const fs = require("node:fs");2const os = require("node:os");3const path = require("node:path");4const { execFileSync } = require("node:child_process");5 6export function run() {7  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "esm-"));8  // One line in quotes: this sandbox rewrites any line of the example9  // itself that starts with "export", so the module text avoids that.10  const counterSource =11    "export let count = 0; export function increment() { count++; }";12  fs.writeFileSync(path.join(dir, "counter.mjs"), counterSource);13  fs.writeFileSync(path.join(dir, "main.mjs"), `14    import { count, increment } from "./counter.mjs";15    const before = count;16    increment();17    increment();18    let assign;19    try { count = 5; } catch (e) { assign = e.name + ": " + e.message; }20    const waited = await Promise.resolve("top-level await works");21    console.log(JSON.stringify({22      before,23      after: count,24      assign,25      waited,26      typeofRequire: typeof require,27      typeofDirname: typeof __dirname,28      topLevelThis: String(this),29    }));30  `);31  const node = (file) =>32    execFileSync(process.execPath, [path.join(dir, file)], {33      encoding: "utf8",34      stdio: ["ignore", "pipe", "pipe"],35    }).trim();36  const result = JSON.parse(node("main.mjs"));37 38  // A .js file, no package.json anywhere above it, using import syntax.39  fs.writeFileSync(40    path.join(dir, "untyped.js"),41    'import { sep } from "node:path"; console.log(typeof require);',42  );43  result.untypedJsWithImport =44    node("untyped.js") === "undefined" ? "loaded as ESM" : "loaded as CommonJS";45  return result;46}

Common mistakes

• Destructuring a value that the module changes later. With require, the destructured copy is frozen at load time; read mod.count instead, or export a function that returns it.
• Assigning to an import. count = 5 on an imported binding throws a TypeError, as the second example shows.
• Reaching for __dirname or require in an ES module. Neither exists; use import.meta.url and import.
• A circular import that reads an export at load time. It sees the partly filled exports (or, in ESM, a binding that is not initialised yet); move the access into a function called later.

What interviewers ask

• What are the main differences between CommonJS and ES modules? — Synchronous runtime require versus static, possibly asynchronous import; values copied out of module.exports versus live bindings; ESM is always strict and supports top-level await.
• Why is a module a singleton? — It is evaluated once and cached; every importer shares the same instance.
• How does Node handle requiring requiring ? — The second returns 's exports as they are so far, partly filled, because is already in the cache.