Bun inclut un minifieur JavaScript et TypeScript rapide qui peut réduire la taille des bundles de 80 % ou plus (selon la base de code) et rendre le code de sortie plus rapide à exécuter. Le minifieur effectue des dizaines d'optimisations, notamment le pliage de constantes, l'élimination du code mort et les transformations de syntaxe. Contrairement à d'autres minifieurs, le minifieur de Bun rend bun build plus rapide car il y a moins de code à imprimer.

Utilisation CLI

Activer toute la minification

Utilisez l'option --minify pour activer tous les modes de minification :

bun build ./index.ts --minify --outfile=out.js

L'option --minify active automatiquement :

• La minification des espaces
• La minification de la syntaxe
• La minification des identifiants

Mode production

L'option --production active automatiquement la minification :

bun build ./index.ts --production --outfile=out.js

L'option --production active également :

• Définit process.env.NODE_ENV sur production
• Active l'importation et la transformation JSX en mode production

Contrôle granulaire

Vous pouvez activer des modes de minification spécifiques individuellement :

# Supprimer uniquement les espaces
bun build ./index.ts --minify-whitespace --outfile=out.js

# Minifier uniquement la syntaxe
bun build ./index.ts --minify-syntax --outfile=out.js

# Minifier uniquement les identifiants
bun build ./index.ts --minify-identifiers --outfile=out.js

# Combiner des modes spécifiques
bun build ./index.ts --minify-whitespace --minify-syntax --outfile=out.js

API JavaScript

Lors de l'utilisation du bundler de Bun programmatiquement, configurez la minification via l'option minify :

await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: true, // Activer tous les modes de minification
});

Pour un contrôle granulaire, passez un objet :

await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: {
    whitespace: true,
    syntax: true,
    identifiers: true,
  },
});

Modes de minification

Le minifieur de Bun a trois modes indépendants qui peuvent être activés séparément ou combinés.

Minification des espaces (--minify-whitespace)

Supprime tous les espaces, nouvelles lignes et formats inutiles de la sortie.

Minification de la syntaxe (--minify-syntax)

Réécrit la syntaxe JavaScript en des formes équivalentes plus courtes et effectue le pliage de constantes, l'élimination du code mort et d'autres optimisations.

Minification des identifiants (--minify-identifiers)

Renomme les variables locales et les noms de fonctions en des identifiants plus courts en utilisant une optimisation basée sur la fréquence.

Toutes les transformations

Raccourcissement des littéraux booléens

Mode : --minify-syntax

Convertit les littéraux booléens en expressions plus courtes.

true
false

!0
!1

Optimisations de l'algèbre booléenne

Mode : --minify-syntax

Simplifie les expressions booléennes en utilisant des règles logiques.

!!x
x === true
x && true
x || false
!true
!false

x
x
x
x
!1
!0

Raccourcissement de undefined

Mode : --minify-syntax

Remplace undefined par un équivalent plus court.

undefined
let x = undefined;

void 0
let x=void 0;

Optimisation de l'égalité undefined

Mode : --minify-syntax

Optimise les vérifications d'égalité lâche avec undefined.

x == undefined
x != undefined

x == null
x != null

Raccourcissement de Infinity

Mode : --minify-syntax

Convertit Infinity en expressions mathématiques.

Infinity
-Infinity

1/0
-1/0

Optimisations de typeof

Mode : --minify-syntax

Optimise les comparaisons typeof et évalue les expressions typeof constantes.

typeof x === 'undefined'
typeof x !== 'undefined'
typeof require
typeof null
typeof true
typeof 123
typeof "str"
typeof 123n

typeof x>'u'
typeof x<'u'
"function"
"object"
"boolean"
"number"
"string"
"bigint"

Formatage des nombres

Mode : --minify-syntax

Formate les nombres dans la représentation la plus compacte.

10000
100000
1000000
1.0
-42.0

1e4
1e5
1e6
1
-42

Pliage arithmétique des constantes

Mode : --minify-syntax

Évalue les opérations arithmétiques au moment de la compilation.

1 + 2
10 - 5
3 * 4
10 / 2
10 % 3
2 ** 3

3
5
12
5
1
8

Pliage bitwise des constantes

Mode : --minify-syntax

Évalue les opérations bitwise au moment de la compilation.

5 & 3
5 | 3
5 ^ 3
8 << 2
32 >> 2
~5

1
7
6
32
8
-6

Concaténation de chaînes

Mode : --minify-syntax

Combine les littéraux de chaîne au moment de la compilation.

"a" + "b"
"x" + 123
"foo" + "bar" + "baz"

"ab"
"x123"
"foobarbaz"

Indexation de chaîne

Mode : --minify-syntax

Évalue l'accès aux caractères de chaîne au moment de la compilation.

"foo"[2]
"hello"[0]

"o"
"h"

Pliage des littéraux de template

Mode : --minify-syntax

Évalue les littéraux de template avec des expressions constantes.

`a${123}b`
`result: ${5 + 10}`

"a123b"
"result: 15"

Conversion de littéral de template en chaîne

Mode : --minify-syntax

Convertit les littéraux de template simples en chaînes régulières.

`Hello World`
`Line 1
Line 2`

"Hello World"
"Line 1\nLine 2"

Optimisation des guillemets de chaîne

Mode : --minify-syntax

Choisit le caractère de guillemet optimal pour minimiser les échappements.

"It's a string"
'He said "hello"'
`Simple string`

"It's a string"
'He said "hello"'
"Simple string"

Inlining du spread de tableau

Mode : --minify-syntax

Inline les opérations de spread de tableau avec des tableaux constants.

[1, ...[2, 3], 4]
[...[a, b]]

[1,2,3,4]
[a,b]

Indexation de tableau

Mode : --minify-syntax

Évalue l'accès constant au tableau au moment de la compilation.

[x][0]
['a', 'b', 'c'][1]
['a', , 'c'][1]

x
'b'
void 0

Optimisation de l'accès aux propriétés

Mode : --minify-syntax

Convertit la notation entre crochets en notation par point lorsque c'est possible.

obj["property"]
obj["validName"]
obj["123"]
obj["invalid-name"]

obj.property
obj.validName
obj["123"]
obj["invalid-name"]

Pliage des comparaisons

Mode : --minify-syntax

Évalue les comparaisons constantes au moment de la compilation.

3 < 5
5 > 3
3 <= 3
5 >= 6
"a" < "b"

!0
!0
!0
!1
!0

Pliage des opérations logiques

Mode : --minify-syntax

Simplifie les opérations logiques avec des valeurs constantes.

true && x
false && x
true || x
false || x

x
!1
!0
x

Pliage du coalescence nullish

Mode : --minify-syntax

Évalue le coalescence nullish avec des valeurs connues.

null ?? x
undefined ?? x
42 ?? x

x
x
42

Simplification des expressions virgule

Mode : --minify-syntax

Supprime les expressions sans effet de bord des séquences de virgule.

(0, x)
(123, "str", x)

x
x

Pliage des conditions ternaires

Mode : --minify-syntax

Évalue les expressions conditionnelles avec des conditions constantes.

true ? a : b
false ? a : b
x ? true : false
x ? false : true

a
b
x ? !0 : !1
x ? !1 : !0

Pliage des expressions unaires

Mode : --minify-syntax

Simplifie les opérations unaires.

+123
+"123"
-(-x)
~~x
!!x

123
123
123
123
x
~~x
!!x
x

Suppression de la double négation

Mode : --minify-syntax

Supprime les doubles négations inutiles.

!!x
!!!x

x
!x

Optimisation des instructions if

Mode : --minify-syntax

Optimise les instructions if avec des conditions constantes.

if (true) x;
if (false) x;
if (x) { a; }
if (x) {} else y;

x;
// supprimé
if(x)a;
if(!x)y;

Élimination du code mort

Mode : --minify-syntax

Supprime le code inaccessible et le code sans effets de bord.

if (false) {
  unreachable();
}
function foo() {
  return x;
  deadCode();
}

function foo(){return x}

Suppression des branches inaccessibles

Mode : --minify-syntax

Supprime les branches qui ne peuvent jamais s'exécuter.

while (false) {
  neverRuns();
}

// supprimé entièrement

Suppression des blocs vides

Mode : --minify-syntax

Supprime les blocs vides et les accolades inutiles.

{ }
if (x) { }

;
// supprimé

Déballage des blocs à instruction unique

Mode : --minify-syntax

Supprime les accolades inutiles autour des instructions uniques.

if (condition) {
  doSomething();
}

if(condition)doSomething();

Intégration des énumérations TypeScript

Mode : --minify-syntax

Intègre les valeurs d'énumération TypeScript au moment de la compilation.

enum Color { Red, Green, Blue }
const x = Color.Red;

const x=0;

Prise en charge des annotations Pure

Mode : Toujours actif

Respecte les annotations /*@__PURE__*/ pour le tree shaking.

const x = /*@__PURE__*/ expensive();
// Si x est inutilisé...

// supprimé entièrement

Renommage des identifiants

Mode : --minify-identifiers

Renomme les variables locales en des noms plus courts basés sur la fréquence d'utilisation.

function calculateSum(firstNumber, secondNumber) {
  const result = firstNumber + secondNumber;
  return result;
}

function a(b,c){const d=b+c;return d}

Stratégie de nommage :

• Les identifiants les plus fréquemment utilisés obtiennent les noms les plus courts (a, b, c...)
• Lettres simples : a-z (26 noms)
• Lettres doubles : aa-zz (676 noms)
• Lettres triples et au-delà selon les besoins

Identifiants préservés :

• Mots-clés JavaScript et mots réservés
• Identifiants globaux
• Exports nommés (pour maintenir l'API)
• Noms CommonJS : exports, module

Suppression des espaces

Mode : --minify-whitespace

Supprime tous les espaces inutiles.

function add(a, b) {
    return a + b;
}
let x = 10;

function add(a,b){return a+b;}let x=10;

Optimisation des points-virgules

Mode : --minify-whitespace

Insère des points-virgules uniquement lorsque c'est nécessaire.

let a = 1;
let b = 2;
return a + b;

let a=1;let b=2;return a+b

Suppression des espaces autour des opérateurs

Mode : --minify-whitespace

Supprime les espaces autour des opérateurs.

a + b
x = y * z
foo && bar || baz

a+b
x=y*z
foo&&bar||baz

Suppression des commentaires

Mode : --minify-whitespace

Supprime les commentaires sauf les commentaires de licence importants.

// Ce commentaire est supprimé
/* Et celui-ci aussi */
/*! Mais ce commentaire de licence est conservé */
function test() { /* commentaire en ligne */ }

/*! Mais ce commentaire de licence est conservé */
function test(){}

Formatage des objets et tableaux

Mode : --minify-whitespace

Supprime les espaces dans les littéraux d'objets et de tableaux.

const obj = {
    name: "John",
    age: 30
};
const arr = [1, 2, 3];

const obj={name:"John",age:30};const arr=[1,2,3];

Formatage du flux de contrôle

Mode : --minify-whitespace

Supprime les espaces dans les structures de contrôle.

if (condition) {
    doSomething();
}
for (let i = 0; i < 10; i++) {
    console.log(i);
}

if(condition)doSomething();for(let i=0;i<10;i++)console.log(i);

Formatage des fonctions

Mode : --minify-whitespace

Supprime les espaces dans les déclarations de fonctions.

function myFunction(param1, param2) {
    return param1 + param2;
}
const arrow = (a, b) => a + b;

function myFunction(a,b){return a+b}const arrow=(a,b)=>a+b;

Minimisation des parenthèses

Mode : Toujours actif

Ajoute des parenthèses uniquement lorsque c'est nécessaire pour la précédence des opérateurs.

(a + b) * c
a + (b * c)
((x))

(a+b)*c
a+b*c
x

Mangle des propriétés

Mode : --minify-identifiers (avec configuration)

Renomme les propriétés d'objets en des noms plus courts lorsque configuré.

obj.longPropertyName

obj.a

Pliage des valeurs de littéraux de template

Mode : --minify-syntax

Convertit les valeurs interpolées non-chaînes en chaînes et les intègre dans le template.

`hello ${123}`
`value: ${true}`
`result: ${null}`
`status: ${undefined}`
`big: ${10n}`

"hello 123"
"value: true"
"result: null"
"status: undefined"
"big: 10"

Pliage de la longueur de chaîne constante

Mode : --minify-syntax

Évalue la propriété .length sur les littéraux de chaîne au moment de la compilation.

"hello world".length
"test".length

11
4

Simplification des appels de constructeur

Mode : --minify-syntax

Simplifie les appels de constructeur pour les types intégrés.

new Object()
new Object(null)
new Object({a: 1})
new Array()
new Array(x, y)

{}
{}
{a:1}
[]
[x,y]

Intégration des objets à propriété unique

Mode : --minify-syntax

Intègre l'accès aux propriétés pour les objets avec une seule propriété.

({fn: () => console.log('hi')}).fn()

(() => console.log('hi'))()

Pliage constant de charCodeAt de chaîne

Mode : Toujours actif

Évalue charCodeAt() sur les littéraux de chaîne pour les caractères ASCII.

"hello".charCodeAt(1)
"A".charCodeAt(0)

101
65

Égalité void 0 vers égalité null

Mode : --minify-syntax

Convertit les vérifications d'égalité lâche avec void 0 en null car elles sont équivalentes.

x == void 0
x != void 0

x == null
x != null

Optimisation de l'opérateur de négation

Mode : --minify-syntax

Déplace l'opérateur de négation à travers les expressions virgule.

-(a, b)
-(x, y, z)

a,-b
x,y,-z

Intégration des propriétés import.meta

Mode : Mode bundle

Intègre les propriétés import.meta au moment de la construction lorsque les valeurs sont connues.

import.meta.dir
import.meta.file
import.meta.path
import.meta.url

"/chemin/vers/repertoire"
"nomfichier.js"
"/chemin/complet/vers/fichier.js"
"file:///chemin/complet/vers/fichier.js"

Fusion des déclarations de variables

Mode : --minify-syntax

Fusionne les déclarations de variables adjacentes du même type.

let a = 1;
let b = 2;
const c = 3;
const d = 4;

let a=1,b=2;
const c=3,d=4;

Fusion des instructions d'expression

Mode : --minify-syntax

Fusionne les instructions d'expression adjacentes en utilisant l'opérateur virgule.

console.log(1);
console.log(2);
console.log(3);

console.log(1),console.log(2),console.log(3);

Fusion des instructions return

Mode : --minify-syntax

Fusionne les expressions avant return avec l'opérateur virgule.

console.log(x);
return y;

return console.log(x),y;

Fusion des instructions throw

Mode : --minify-syntax

Fusionne les expressions avant throw avec l'opérateur virgule.

console.log(x);
throw new Error();

throw(console.log(x),new Error());

Intégration des énumérations TypeScript entre modules

Mode : --minify-syntax (mode bundle)

Intègre les valeurs d'énumération à travers les limites des modules.

// lib.ts
export enum Color { Red, Green, Blue }

// Input (main.ts)
import { Color } from './lib';
const x = Color.Red;

const x=0;

Intégration des énumérations de propriétés calculées

Mode : --minify-syntax

Intègre les valeurs d'énumération utilisées comme propriétés d'objets calculées.

enum Keys { FOO = 'foo' }
const obj = { [Keys.FOO]: value }

const obj={foo:value}

Nombre de chaîne vers index numérique

Mode : --minify-syntax

Convertit l'accès aux propriétés numériques de chaîne en index numérique.

obj["0"]
arr["5"]

obj[0]
arr[5]

Raccourcissement du corps de fonction fléchée

Mode : Toujours actif

Utilise la syntaxe de corps d'expression lorsqu'une fonction fléchée retourne uniquement une valeur.

() => { return x; }
(a) => { return a + 1; }

() => x
a => a + 1

Raccourcissement des propriétés d'objet

Mode : Toujours actif

Utilise la syntaxe raccourcie lorsque le nom de propriété et l'identifiant de valeur correspondent.

{ x: x, y: y }
{ name: name, age: age }

{ x, y }
{ name, age }

Raccourcissement de méthode

Mode : Toujours actif

Utilise la syntaxe raccourcie de méthode dans les littéraux d'objet.

{
  foo: function() {},
  bar: async function() {}
}

{
  foo() {},
  async bar() {}
}

Suppression des instructions debugger

Mode : --drop=debugger

Supprime les instructions debugger du code.

function test() {
  debugger;
  return x;
}

function test(){return x}

Suppression des appels console

Mode : --drop=console

Supprime tous les appels de méthode console.* du code.

console.log("debug");
console.warn("warning");
x = console.error("error");

void 0;
void 0;
x=void 0;

Suppression des appels de fonctions personnalisées

Mode : --drop=<name>

Supprime les appels aux fonctions ou méthodes globales spécifiées.

assert(condition);
obj.assert(test);

void 0;
void 0;

Conserver les noms

Lors de la minification des identifiants, vous pouvez souhaiter préserver les noms de fonctions et de classes originaux à des fins de débogage. Utilisez l'option --keep-names :

bun build ./index.ts --minify --keep-names --outfile=out.js

Ou dans l'API JavaScript :

await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: {
    identifiers: true,
    keepNames: true,
  },
});

Cela préserve la propriété .name sur les fonctions et les classes tout en minifiant toujours les noms d'identifiants réels dans le code.

Exemple combiné

Utilisation des trois modes de minification ensemble :

const myVariable = 42;

const myFunction = () => {
  const isValid = true;
  const result = undefined;
  return isValid ? myVariable : result;
};

const output = myFunction();

// Sortie avec --minify (49 octets, réduction de 69%)
const a=42,b=()=>{const c=!0,d=void 0;return c?a:d},e=b();

Quand utiliser la minification

Utilisez --minify pour :

• Les bundles de production
• Réduire les coûts de bande passante CDN
• Améliorer les temps de chargement de page

Utilisez des modes individuels pour :

• --minify-whitespace : Réduction rapide de la taille sans changements sémantiques
• --minify-syntax : Sortie plus petite tout en gardant des identifiants lisibles pour le débogage
• --minify-identifiers : Réduction maximale de la taille (combiner avec --keep-names pour de meilleures traces de pile)

Évitez la minification pour :

• Les builds de développement (plus difficiles à déboguer)
• Lorsque vous avez besoin de messages d'erreur lisibles
• Les bibliothèques où les consommateurs peuvent lire la source