Tree shaking vs minification : ce que fait chaque levier

Tree shaking vs minification : ce que fait chaque levier

La minification raccourcit le JS conservé. Le tree shaking retire les modules inutiles. Tableau comparatif, Vite/Webpack, et quand cumuler les deux.

13.05.2026
9 min de lecture
Partager cet article:
JavaScriptTree shakingMinificationWebpackVitePerformanceOptimisationBundleTutoriel

Deux techniques souvent confondues

Quand on optimise un front moderne, on entend sans cesse parler de minification et de tree shaking des bundles. Ce ne sont pas deux noms pour la même chose. La minification réduit le code déjà présent dans le fichier final (espaces, noms plus courts). Le tree shaking retire du graphe de dépendances les modules qui ne sont jamais utilisés. Les deux réduisent les octets transférés, à des étapes différentes de la chaîne de build. Pour un fichier isolé, sans bundler, un minificateur JavaScript en ligne suffit souvent. Une application complète combine en général l'analyse statique des imports, un bundler en mode production et un minificateur (Terser, esbuild, SWC ou Oxc). Ce guide donne les définitions, un tableau comparatif, des tailles mesurées et une configuration Vite et Webpack. Pour des réglages plus fins, consultez notre guide de minification JavaScript.

Savoir quel levier réduit le nombre de modules et lequel réduit le poids des fichiers conservés
Ne plus croire que la minification supprime tout lodash quand vous n'importez qu'une seule fonction
Configurer le bundler et le minificateur pour que tree shaking et minification se cumulent
Repérer quand le CSS doit être purgé (Tailwind, PurgeCSS) avant d'être minifié
Mesurer avec un analyseur de bundle au lieu de deviner les gains

La minification et le tree shaking ont des effets différents

La minification réduit ce qui reste dans le fichier

La minification travaille sur un fichier dont le contenu est déjà décidé. Elle retire ce dont le moteur JavaScript n'a pas besoin (espaces, commentaires et, selon l'outil, noms de variables locales). Elle ne peut pas savoir si une fonction exportée servira plus tard quand elle est déjà dans le bundle. Pour les bases et une comparaison des outils, consultez notre guide complet sur la minification JavaScript. Pour retrouver un code lisible, gardez sous la main un déminificateur JavaScript ou le mode Beautifier.

Avant

function calculateTotal(price, quantity) { const taxRate = 0.2; return price * quantity * (1 + taxRate); } export { calculateTotal };

Après

function calculateTotal(n,t){return n*t*1.2}export{calculateTotal};
Le tree shaking retire les branches mortes du graphe

Le tree shaking s'appuie sur les modules ES (`import` / `export`) et sur une analyse statique. Tout ce qui n'est pas atteint depuis un point d'entrée peut être écarté avant que la minification intervienne. Les bibliothèques doivent fournir des builds compatibles (`sideEffects` dans `package.json`, pas d'effets de bord globaux cachés). Le correctif le plus parlant consiste à remplacer un import « baril » ou par défaut par un import ciblé.

Préférez un import nommé depuis lodash-es, ou un chemin précis, à l'import par défaut de lodash quand votre chaîne d'outils sait élaguer
Renseignez les champs module et exports dans le package.json de vos bibliothèques pour que les bundlers résolvent des builds analysables statiquement
Indiquez sideEffects: false (ou une liste précise) dans votre package.json quand vos fichiers n'ont pas d'effets de bord
Évitez les imports dynamiques trop larges, qui obligent à garder des chunks entiers sans analyse fine
Utilisez le code splitting pour le code que seules certaines pages utilisent : le shaking retire le code inatteignable, le splitting ne fait que différer le code atteignable

Avant

// utils/math.ts : les exports inutilisés peuvent finir dans le bundle export function square(x){return x*x} export function cube(x){return x*x*x} export function unusedLegacy(){/* ancienne API */} // main.ts import { square } from './utils/math'

Après

// Après l'analyse du bundler, seules les définitions // réellement référencées peuvent rester dans le chunk, // puis la minification raccourcit encore la syntaxe. // cube() et unusedLegacy() peuvent être retirés // si aucun autre fichier ne les importe.
Pour le CSS, la purge joue le rôle du tree shaking

Le CSS n'a pas de tree shaking par modules ES comme le JavaScript. PostCSS, Tailwind et PurgeCSS jouent pourtant le même rôle : ils retirent les règles inutilisées avant que vous passiez un minificateur CSS en ligne ou cssnano sur la sortie finale.

Analysez vos templates JSX et HTML pour ne livrer que les classes Tailwind réellement utilisées
Retirez les anciennes feuilles de style globales une fois les styles rapprochés de leurs composants
Contrôlez le rendu après une purge : une classe construite par concaténation peut être supprimée à tort
Minifiez après la purge pour gagner encore quelques octets

Mesurer ce qui change vraiment dans le bundle

Comparer avant et après

Les deux techniques apparaissent à des endroits différents d'un rapport de bundle. Le tree shaking réduit le nombre et la taille des modules. La minification réduit les octets des modules qui restent. Dans un test avec Vite 8.3.4 et la seule fonction debounce de lodash-es, le bundle pesait 85,0 KB minifié avec le tree shaking désactivé. Il pesait 13,9 KB élagué, mais non minifié, et 2,9 KB avec les deux. Utilisez un treemap pour repérer les régressions après une mise à jour de dépendances.

Schéma comparant un bundle volumineux et un bundle réduit après optimisation
rollup-plugin-visualizer, webpack-bundle-analyzer ou vite-bundle-visualizer
Source Map Explorer pour relier les octets aux fichiers sources
Chrome DevTools Coverage pour comparer le JavaScript et le CSS exécutés à ceux livrés
Comparaison gzip et Brotli après le build pour mesurer le gain réel sur le réseau
Construire en mode production

Construisez en mode production : `vite build` et `mode: 'production'` de Webpack définissent `NODE_ENV` pour vous. Avec d'autres outils, définissez vous-même `NODE_ENV=production`. Sans cela, certains bundlers sautent des optimisations et des bibliothèques comme React gardent leur code de développement.

Vérifiez que votre CI exécute la même commande que le build qui produit vos artefacts de staging
Définissez des budgets de taille de bundle et contrôlez-les dans le pipeline
Comparez les builds autour d'une mise à jour npm majeure : une dépendance peut casser le shaking

Les deux techniques côte à côte

Synthèse comparée

Servez-vous de ce récapitulatif pour estimer un ticket d'optimisation. Demandez-vous d'abord si ce code doit exister dans le graphe, puis comment réduire sa taille en texte.

Minification

objectif:Réécrire le code conservé pour retirer la syntaxe superflue
moment:Après le bundling, ou sur un fichier isolé
exemple:13,9 KB ramenés à 2,9 KB sur un bundle élagué (test ci-dessus)
limites:Ne retire pas un module importé mais inutilisé

Tree shaking

objectif:Retirer les exports et les modules qu'aucun point d'entrée n'atteint
moment:Pendant la résolution du graphe de modules ES
exemple:85,0 KB ramenés à 2,9 KB sur un bundle minifié (test ci-dessus)
limites:Échoue avec du code dynamique opaque ou du CommonJS non analysé
Questions rapides à vous poser

Ces contrôles évitent les optimisations hors sol.

Ai-je encore des imports « tout le package » là où un chemin précis existe ?
Mes bibliothèques déclarent-elles correctement le champ sideEffects pour que le bundler ose élaguer ?
La minification passe-t-elle après le shaking pour réduire ce qui reste ?
Me faut-il un outil en ligne pour un extrait hors bundle, ou une reconstruction complète de l'application ?
Pour le CSS, ai-je purgé avant de mesurer ce que la minification seule apporte ?

Minifier un fichier hors bundler

FastMinify pour une passe ponctuelle

Quand Webpack ou Vite n'est pas encore en place, ou que vous livrez un script isolé, collez votre JavaScript dans notre outil exécuté dans le navigateur. Il renvoie un code compact et propose le mode Beautifier pour le relire.

1

Coller ou charger votre fichier

Utilisez le minificateur JavaScript en ligne. Votre code reste dans votre navigateur.

2

Comparer avec Beautifier

Choisissez le mode Beautifier pour obtenir une mise en forme lisible. C'est pratique avant de recopier le code dans votre chaîne d'outils.

3

Ne pas confondre avec le shaking

L'outil minifie les fichiers que vous lui donnez et n'analyse pas quels modules sont utilisés. Pour retirer les modules inutilisés, il faut un bundler en mode production qui travaille sur le graphe de modules.

L'intégrer aux flux de travail modernes

Quand votre base de code grossit, appuyez-vous sur notre comparatif minificateurs en ligne vs outils de build. L'outil en ligne garde sa place pour les exceptions et les prototypes.

Prototype ou page de destination statique : minificateur en ligne
Application SPA ou SSR : bundler + shaking + minification
Audit ponctuel : déminifier avec FastMinify puis corriger à la source

Combiner tree shaking et minification dans le build

Vite (Rolldown sous le capot depuis la version 8)

`vite build` applique le tree shaking et minifie avec Oxc par défaut (Vite 8, construit sur Rolldown). Vite 7 et les versions antérieures utilisaient Rollup et esbuild. Gardez des imports compatibles avec les modules ES.

Configuration

// vite.config.ts (extrait) import { defineConfig } from 'vite' export default defineConfig({ build: { minify: 'oxc', // valeur par défaut dans Vite 8 ; 'terser' reste disponible sourcemap: true, // garde des traces d'appel lisibles en production }, })

Utilisation

# Build de production npm run build # Inspectez dist/assets/*.js : les chunks montrent # ce que le bundler a gardé après le tree shaking, puis minifié.
Webpack 5

`mode: 'production'` active `usedExports`, `sideEffects` et la minification avec Terser. Vérifiez que les bibliothèques que vous utilisez déclarent correctement `sideEffects`.

Configuration

// webpack.config.js (extrait) module.exports = { mode: 'production', optimization: { usedExports: true, sideEffects: true, // respecte le champ "sideEffects" de package.json minimize: true, // Le minificateur par défaut est TerserPlugin. Pour en ajouter un autre // tout en gardant Terser, utilisez minimizer: ['...', new MyPlugin()]. }, };

Utilisation

// Point d'entrée : // webpack suit les exports depuis les points d'entrée, // marque ceux qui ne sont pas utilisés, puis le minificateur réduit les octets. import { initApp } from './app' initApp()
CSS en production

Enchaînez la purge Tailwind ou PurgeCSS, puis la minification, comme dans notre guide sur la minification CSS. La purge fait le travail de shaking, et la minification réduit ensuite les octets de ce qui reste.

Exemple de base

/* Après la purge des classes inutilisées */ .btn{padding:.5rem 1rem;border-radius:.375rem}

Minification de fichier

/* postcss avec cssnano en fin de chaîne */ .btn{padding:.5rem 1rem;border-radius:.375rem} /* la sortie tient sur une seule ligne compacte */

Conclusion

Le tree shaking et la minification se complètent. L'un élague le graphe de dépendances, l'autre écrit ce qui reste avec moins d'octets. Sans tree shaking, vous livrez des modules morts. Sans minification, vous livrez une sortie verbeuse pour un graphe pourtant allégé. Un minificateur en ligne couvre les extraits hors dépôt. Automatisez votre bundler pour tout le reste et gardez FastMinify sous la main pour les cas limites.

Minifiez votre JavaScript dans votre navigateur

Combinez des imports ES précis, une déclaration sideEffects honnête et des builds de production
Mesurez avec un analyseur de bundle après chaque changement de dépendances
Pour le CSS, purgez d'abord, puis minifiez, comme dans notre guide sur la minification CSS
Gardez le comparatif minificateurs en ligne et outils de build sous la main pour les décisions d'équipe
Pour relire du JavaScript compact, utilisez Beautifier ou un déminificateur avant de déboguer
Partager cet article
Partager cet article: