Formateur Babel

Formatez votre code JavaScript ES6+ et JSX moderne.

ES6+ / JSX

Formatage

Options

Code Formaté

Guide complet : JavaScript moderne avec Babel et ES6+

Babel : le pont entre le JavaScript moderne et la compatibilité

Depuis ES6 (2015), JavaScript a connu une évolution spectaculaire. Chaque année apporte de nouvelles fonctionnalités : arrow functions, destructuring, async/await, optional chaining, modules natifs... Le problème ? Les navigateurs n'implémentent pas tous ces features au même rythme. C'est là qu'intervient Babel.

Babel est un transpileur (ou compilateur source-to-source) qui transforme votre code JavaScript moderne en une version compatible avec des environnements plus anciens. Écrivez avec la syntaxe la plus récente, Babel génère du code qui fonctionne partout — même sur IE11 si nécessaire (bien que ce soit de moins en moins le cas).

L'écosystème Babel expliqué

Babel fonctionne avec un système de presets et plugins :

  • @babel/preset-env : Le preset intelligent. Il analyse votre browserslist et ne transpile que ce qui est nécessaire pour vos cibles. Si vous ne supportez que les navigateurs modernes, il ne fait presque rien.
  • @babel/preset-react : Transforme JSX en React.createElement() ou le nouveau JSX runtime automatique.
  • @babel/preset-typescript : Supprime les annotations de type TypeScript (sans vérification de types, utilisez tsc pour ça).
  • Plugins individuels : Pour les proposals TC39 pas encore en stage 4, ou des transformations spécifiques.

Les fonctionnalités ES6+ essentielles

→ Arrow Functions

Syntaxe concise avec this lexical. const double = x => x * 2; Parfait pour les callbacks et les méthodes courtes. Attention : pas de this propre, pas de arguments, ne peut pas être utilisé comme constructeur.

📦 Destructuring

Extraction élégante : const { name, age = 0 } = user; pour les objets, const [first, ...rest] = arr; pour les arrays. Valeurs par défaut, renommage ({ name: userName }), imbrication — très puissant.

📝 Template Literals

Strings multilignes et interpolation : `Hello ${name}!`. Tagged templates pour des DSL avancés (styled-components, GraphQL). Fini la concaténation avec +.

✨ Spread & Rest

Spread : {...obj, newProp: 1} pour copier/fusionner. Rest : function fn(...args) pour collecter les arguments. Remplace Object.assign() et Array.prototype.slice.call(arguments).

⏳ async/await

Code asynchrone lisible : const data = await fetch(url); Sucre syntaxique sur les Promises. Try/catch pour la gestion d'erreurs. Transforme le callback hell en code séquentiel.

📥 Modules ESM

import { fn } from './module'; et export const x = 1;. Imports statiques (tree-shakable), exports nommés ou par défaut. Le standard qui remplace CommonJS et AMD.

Fonctionnalités ES2020+ : le JavaScript ultra-moderne

  • Optional chaining ?. : user?.address?.city retourne undefined au lieu de crasher si une propriété est null/undefined. Fonctionne aussi pour les appels de fonctions (obj.method?.()) et les accès tableaux (arr?.[0]).
  • Nullish coalescing ?? : value ?? defaultValue. Contrairement à ||, ne remplace que null et undefined, pas 0, '' ou false.
  • Logical assignment : x ||= y, x &&= y, x ??= y. Raccourcis pour l'assignation conditionnelle.
  • Private class fields : #privateField pour de vrais champs privés en JavaScript.
  • Top-level await : await au niveau module sans fonction async englobante (dans les modules ESM).
  • Array.at() : arr.at(-1) pour accéder au dernier élément. Plus besoin de arr[arr.length - 1].

JSX : la syntaxe de React

JSX n'est pas du HTML dans JavaScript — c'est une extension syntaxique que Babel transforme en appels de fonctions :

  • Ancien runtime : <div>Hello</div> devient React.createElement('div', null, 'Hello')
  • Nouveau runtime (React 17+) : Utilise jsx() automatiquement importé, plus besoin de import React dans chaque fichier
  • Cet outil formate le JSX correctement avec indentation des props et enfants

Babel vs les alternatives modernes

Babel n'est plus le seul choix pour la transpilation :

  • esbuild : 10-100x plus rapide que Babel, écrit en Go. Parfait pour le développement. Moins de plugins disponibles.
  • SWC : Alternative Rust ultra-rapide, utilisé par Next.js. Compatible avec la plupart des plugins Babel.
  • TypeScript (tsc) : Peut transpiler tout seul si vous n'avez pas besoin de plugins Babel spécifiques.

Babel reste pertinent pour : plugins spécifiques (macros, instrumentations), proposals TC39 récentes, configurations complexes.

Traitement 100% local : vos données restent privées

Cet outil utilise js-beautify pour formater votre code ES6+/JSX. Tout le traitement s'effectue dans votre navigateur — aucun code n'est envoyé à nos serveurs. Vous pouvez formater du code propriétaire ou sensible en toute confiance.

Questions fréquentes sur Babel et ES6+

Babel est-il encore nécessaire en 2024 ?

Ça dépend de votre contexte :

  • Oui, toujours utile pour : JSX/React, TypeScript (avec @babel/preset-typescript), proposals TC39 expérimentales, plugins spécifiques (macros, instrumentations)
  • Souvent remplaçable par : esbuild ou SWC pour la vitesse, TypeScript seul si vous n'avez pas besoin de plugins Babel
  • Quasi-inutile pour : Projets ciblant uniquement les navigateurs modernes (Chrome/Firefox/Safari récents), où ES6+ est supporté nativement

Vérifiez votre browserslist : si vous ciblez last 2 versions de navigateurs evergreen, @babel/preset-env ne transformera presque rien.

Comment configurer Babel pour un projet React moderne ?

Configuration minimale (babel.config.json) :

  • Installez : npm install -D @babel/core @babel/preset-env @babel/preset-react
  • Config : { "presets": ["@babel/preset-env", ["@babel/preset-react", { "runtime": "automatic" }]] }

Le runtime: "automatic" utilise le nouveau JSX transform de React 17+ — plus besoin d'import React dans chaque fichier.

Note : Create React App, Next.js, Vite configurent tout automatiquement. Babel manuel est rarement nécessaire pour les nouveaux projets.

Babel vs TypeScript : quand utiliser l'un ou l'autre ?

TypeScript seul (ma recommandation générale) :

  • Vérification de types + transpilation en un seul outil
  • Moins de configuration, moins de dépendances
  • Suffisant pour 90% des projets

Babel + TypeScript (cas avancés) :

  • TypeScript pour le type-checking (tsc --noEmit)
  • Babel pour la transpilation avec plugins spécifiques
  • Utile pour : macros Babel, proposals TC39, instrumentations spéciales

Babel seul : Projets JavaScript sans typage, ou si vous avez des besoins Babel spécifiques sans vouloir TypeScript.

Que sont les proposals TC39 et les stages ?

TC39 est le comité qui fait évoluer JavaScript. Chaque nouvelle fonctionnalité passe par 5 stages :

  • Stage 0 - Strawperson : Idée informelle, peut être abandonnée
  • Stage 1 - Proposal : Idée formalisée, mais syntaxe/sémantique peuvent changer radicalement
  • Stage 2 - Draft : Spécification initiale, changements encore possibles
  • Stage 3 - Candidate : Spécification complète, feedback des implémentations. Généralement sûr pour la production
  • Stage 4 - Finished : Inclus dans la prochaine version ECMAScript. Tous les navigateurs modernes l'implémenteront

Babel permet d'utiliser les proposals via des plugins. Conseil : évitez Stage 0-1 en production, Stage 3+ est raisonnablement sûr.

Comment optimiser le bundle size avec Babel ?

Stratégies pour réduire le code généré :

  • Ciblez les bons navigateurs : browserslist: "last 2 versions" évite de transpiler pour IE11
  • useBuiltIns: "usage" : N'inclut que les polyfills réellement utilisés dans votre code
  • Évitez les helpers dupliqués : @babel/plugin-transform-runtime factorise les helpers Babel
  • Analysez ce que Babel transforme : DEBUG=@babel/preset-env npm run build montre les transformations appliquées

Souvent, passer à esbuild ou SWC réduit aussi le bundle car ils génèrent du code plus compact.

Puis-je utiliser les dernières fonctionnalités JavaScript sans Babel ?

Oui, dans beaucoup de cas ! Les navigateurs modernes supportent nativement :

  • Toutes les fonctionnalités ES6-ES2023 (arrow functions, classes, async/await, optional chaining...)
  • Modules ESM natifs (<script type="module">)

Vous avez encore besoin de transpilation pour :

  • JSX (React/Preact/Vue JSX)
  • TypeScript (annotations de types)
  • Proposals Stage 0-3 pas encore implémentées
  • Support de navigateurs anciens (IE, vieux Safari)

Vérifiez caniuse.com pour chaque fonctionnalité si vous hésitez.

Quelle différence entre .babelrc et babel.config.js ?

  • babel.config.js (ou .json) : Configuration à la racine du projet, s'applique à tout (y compris node_modules si nécessaire). Recommandé pour les monorepos et la plupart des projets.
  • .babelrc (ou .babelrc.json) : Configuration locale, cherchée récursivement depuis le fichier transformé. Utile pour des configs différentes par sous-dossier.

Recommandation : Utilisez babel.config.json pour les nouveaux projets. Plus simple, plus prévisible.

Mes données sont-elles sécurisées avec cet outil ?

Oui, totalement. Tout le formatage s'effectue dans votre navigateur :

  • js-beautify s'exécute localement en JavaScript
  • Aucune requête réseau n'est envoyée avec votre code
  • Votre code ES6+/JSX ne quitte jamais votre machine
  • L'outil fonctionne même hors ligne une fois la page chargée

Vérifiez dans l'onglet Réseau des DevTools : aucune donnée n'est transmise.