Moduli JavaScript: ES Modules (`import`/`export`) vs. CommonJS (`require`)

Per anni, JavaScript non ha avuto un sistema di moduli nativo. Questo ha portato alla creazione di diversi standard, i due più importanti dei quali sono CommonJS e ES Modules.

CommonJS (`require` / `module.exports`)

CommonJS è il sistema di moduli che è stato adottato da Node.js fin dai suoi inizi. È sincrono, il che significa che quando si richiede un modulo, l'esecuzione del codice si ferma finché il modulo non è stato caricato e processato. Questo funziona bene sul server, dove i file sono letti dal disco velocemente.

Sintassi CommonJS

Per esportare da un file (`matematica.js`):

function somma(a, b) { return a + b; }
const PI = 3.14;

module.exports = { somma, PI };

Per importare in un altro file (`app.js`):

const matematica = require('./matematica.js');
console.log(matematica.somma(2, 3)); // 5

ES Modules (`import` / `export`)

ES Modules (ESM) è lo standard ufficiale introdotto in JavaScript con ES6 (ECMAScript 2015). È asincrono, il che lo rende adatto all'uso nei browser, dove il caricamento dei file dalla rete può richiedere tempo. È anche supportato nativamente nelle versioni moderne di Node.js.

Sintassi ES Modules

Per esportare da un file (`matematica.mjs`):

export function somma(a, b) { return a + b; }
export const PI = 3.14;

// O con un export di default
// export default function somma(a, b) { ... }

Per importare in un altro file (`app.mjs`):

import { somma, PI } from './matematica.mjs';
// Se ci fosse un export di default: import somma from '...'

console.log(somma(2, 3)); // 5

Quale Usare Oggi?

ES Modules è lo standard del futuro (e del presente). Tutti i browser moderni lo supportano nativamente, e anche l'ecosistema di Node.js si sta spostando progressivamente verso ESM. Uno dei vantaggi di ESM è che permette l'analisi statica: gli strumenti di build (come Webpack o Vite) possono analizzare le dipendenze `import`/`export` senza eseguire il codice, abilitando ottimizzazioni come il "tree shaking" (rimozione del codice non utilizzato).