Blog
Point de vue

Démarrer avec l'API Bun

Bun : outil JS rapide et complet pour productivité et perf. Runtime, bundler, testeur, gestionnaire de paquets, tout-en-un.

Louis Dupont

Louis Dupont

5 June 2025

Démarrer avec l'API Bun

```html

Parmi les outils de développement récents les plus passionnants, on trouve Bun, une boîte à outils JavaScript tout-en-un incroyablement rapide, conçue pour améliorer la productivité des développeurs et les performances des applications. Bun n'est pas seulement un autre runtime ; c'est un écosystème cohérent englobant un runtime, un bundler, un test runner, un gestionnaire de paquets, et plus encore, le tout dans un seul exécutable natif. Ce guide vous présentera les éléments essentiels de Bun, en mettant l'accent sur ses concepts de base et ses API puissantes.

💡
Vous voulez un excellent outil de test d'API qui génère une belle documentation d'API ?

Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?

Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !
button

Qu'est-ce que Bun ?

À la base, Bun est construit autour d'un moteur d'exécution JavaScript haute performance. Contrairement à Node.js, qui utilise le moteur V8 de Google, Bun utilise JavaScriptCore (JSC) d'Apple, le moteur qui alimente Safari. Ce choix, combiné à l'implémentation de Bun dans le langage de programmation bas niveau Zig, contribue de manière significative à sa vitesse remarquable. Les temps de démarrage des applications Bun sont souvent mesurés comme étant considérablement plus rapides que les applications Node.js équivalentes, parfois d'un facteur de quatre ou plus. Cet avantage de vitesse s'étend au-delà du simple démarrage ; les implémentations internes de Bun de diverses API sont optimisées pour un débit maximal et une utilisation minimale de la mémoire.

Mais l'ambition de Bun va bien au-delà d'être simplement un runtime plus rapide. Il vise à être une boîte à outils complète, répondant directement aux besoins courants des développeurs :

  1. Outils intégrés : La commande bun elle-même sert de point d'entrée pour de nombreuses fonctionnalités. bun run exécute les scripts définis dans package.json, bun install gère les dépendances (souvent beaucoup plus rapidement que npm ou yarn), bun test exécute les tests à l'aide d'une API compatible Jest, bun build regroupe le code pour la production et bunx exécute les paquets sans les installer explicitement. Cette intégration simplifie les flux de travail en réduisant le nombre d'outils de développement distincts nécessaires.
  2. Prise en charge native de TypeScript et JSX : L'une des fonctionnalités les plus remarquables de Bun est sa prise en charge prête à l'emploi des fichiers TypeScript (.ts, .tsx) et JSX (.jsx). Bun inclut un transpiler intégré et hautement optimisé qui gère ces types de fichiers de manière transparente pendant l'exécution ou le regroupement. Cela élimine le besoin d'étapes de compilation distinctes impliquant tsc ou Babel pour de nombreux scénarios de développement courants, ce qui simplifie le processus de configuration.
  3. Compatibilité du système de modules : Bun adopte JavaScript moderne avec une prise en charge de premier ordre des modules ES (ESM). Cependant, il reconnaît le vaste écosystème existant construit sur CommonJS (CJS). Bun offre une compatibilité robuste pour les deux systèmes de modules, permettant aux développeurs d'utiliser import et require de manière largement interchangeable et de tirer parti des millions de paquets CJS existants disponibles sur npm.
  4. Adhésion à l'API Web Standard : Un principe de conception clé est l'implémentation des API Web standard. Les fonctions et les objets comme fetch, Request, Response, Headers, WebSocket et l'API Streams (ReadableStream, WritableStream) sont intégrés à la portée globale de Bun. Cela favorise la portabilité du code entre les environnements Bun côté serveur, les frontaux de navigateur et les plateformes de calcul de pointe, permettant aux développeurs de réutiliser des API familières dans différents contextes.
  5. Compatibilité Node.js : Tout en traçant sa propre voie avec des API optimisées et des normes Web, Bun vise un haut degré de compatibilité avec la surface de l'API Node.js. De nombreux modules Node.js intégrés (node:fs, node:path, node:os, node:events, etc.) et objets globaux (process, Buffer, __filename, __dirname) sont partiellement ou entièrement implémentés. L'objectif est de permettre à de nombreux projets Node.js et paquets npm existants de s'exécuter sur Bun avec un minimum de modifications, positionnant Bun comme un potentiel « remplacement direct » dans de nombreux cas.

En combinant ces éléments, Bun présente une alternative convaincante pour les développeurs JavaScript et TypeScript recherchant la performance, la simplicité et une expérience de développement moderne.

Comment installer Bun

La prise en main de Bun est conçue pour être rapide et simple sur diverses plateformes. La méthode la plus courante pour macOS, Linux et Windows Subsystem for Linux (WSL) utilise une simple commande curl exécutée dans votre terminal :

curl -fsSL https://bun.sh/install | bash

Cette commande télécharge un script d'installation et le transmet directement à bash. Le script gère la détection de votre système d'exploitation et de votre architecture, télécharge l'exécutable Bun approprié et l'installe généralement dans ~/.bun/bin. Il tente également de mettre à jour le fichier de configuration de votre shell (comme .zshrc, .bashrc ou .bash_profile) pour ajouter ~/.bun/bin au PATH de votre système, rendant la commande bun globalement disponible. Vous devrez peut-être redémarrer votre session de terminal ou sourcer manuellement le fichier de configuration de votre shell (par exemple, source ~/.zshrc) pour que les modifications prennent effet immédiatement.

Si vous rencontrez des problèmes d'autorisation ou si vous préférez ne pas transmettre directement à bash, vous pouvez d'abord télécharger le script et l'inspecter avant de l'exécuter :

curl -fsSL https://bun.sh/install -o install.sh
# Inspect install.sh if desired
bash install.sh

Autres méthodes d'installation :

npm install -g bun

docker run --rm --init --ulimit memlock=-1:-1 oven/bun:latest bun --version

brew tap oven-sh/bun
brew install bun

Vérification :

Une fois installé, ouvrez une nouvelle fenêtre de terminal et vérifiez l'installation en vérifiant la version :

bun --version

Cela devrait afficher le numéro de version installé, confirmant que Bun est prêt à être utilisé. Vous pouvez également exécuter bun --help pour voir une liste des commandes et options disponibles.

Exécuter votre Bun pour la première fois

Plongeons-nous dans l'écriture et l'exécution d'un programme simple avec Bun. L'une des tâches les plus courantes consiste à créer un serveur HTTP. Bun fournit une API intégrée et hautement optimisée à cet effet : Bun.serve.

Créez un nouveau fichier nommé server.js (ou server.ts, car Bun gère les deux) :

// server.ts

// Bun.serve démarre le serveur HTTP
const server = Bun.serve({
  // Spécifiez le port sur lequel écouter.
  // Par défaut, process.env.PORT || 3000
  port: 3000,

  // La fonction 'fetch' est le gestionnaire de requêtes principal.
  // Il reçoit un objet Request standard et doit renvoyer un objet Response (ou une Promise qui en résout un).
  fetch(request: Request): Response {
    // Crée un objet Response d'API Web standard
    return new Response("Welcome to Bun!");
  },
});

// Enregistre un message indiquant que le serveur est en cours d'exécution
console.log(`Listening on http://localhost:${server.port}`);

Ce snippet de code fait ce qui suit :

  1. Il appelle Bun.serve, la fonction principale pour la création de serveurs HTTP dans Bun.
  2. Il transmet un objet de configuration, en spécifiant le port (3000 dans ce cas).
  3. La partie cruciale est la fonction fetch. Cette fonction est appelée pour chaque requête HTTP entrante. Elle s'aligne sur le modèle de gestionnaire d'événements fetch de Service Worker, acceptant un objet Request standard.
  4. À l'intérieur de fetch, nous construisons et renvoyons un objet Response standard. Ici, nous renvoyons simplement du texte brut « Welcome to Bun ! ».
  5. Enfin, nous enregistrons un message de confirmation dans la console, y compris le port réel sur lequel le serveur écoute (accessible via server.port).

Pour exécuter ce serveur, ouvrez votre terminal dans le répertoire où vous avez enregistré le fichier et exécutez :

bun run server.ts

Ou, si vous l'avez enregistré sous le nom de server.js :

bun run server.js

Bun exécutera le script. Si vous avez utilisé TypeScript (server.ts), le transpiler interne de Bun gérera la conversion en JavaScript à la volée avant l'exécution. Vous verrez le message « Listening on http://localhost:3000 ».

Maintenant, ouvrez votre navigateur Web et accédez à http://localhost:3000. Vous devriez voir le texte « Welcome to Bun ! » affiché.

Pour arrêter le serveur, revenez à votre terminal et appuyez sur Ctrl + C.

Cet exemple simple démontre la facilité de configurer un serveur de base et d'exécuter du code (y compris TypeScript) directement avec Bun, mettant en valeur sa nature intégrée et sa dépendance aux API Web Standard comme Request et Response.

Quelle est la prise en charge native de TypeScript dans Bun

L'un des avantages les plus importants de Bun, en particulier pour les développeurs qui utilisent déjà ou souhaitent adopter TypeScript, est sa prise en charge de premier ordre et prête à l'emploi. Contrairement à Node.js, où l'exécution de TypeScript nécessite généralement une pré-compilation à l'aide du compilateur TypeScript (tsc) ou l'utilisation de chargeurs/registres comme ts-node ou tsx, Bun le gère nativement et de manière transparente.

Comment ça marche :

Lorsque vous demandez à Bun d'exécuter un fichier .ts ou .tsx (par exemple, bun run myscript.ts), il appelle automatiquement son transpiler interne. Ce transpiler est écrit en code natif (Zig) et est extrêmement rapide. Son travail consiste à :

  1. Supprimer les types : Supprimer les annotations de type TypeScript, les interfaces, les énumérations, etc., car celles-ci ne font pas partie de l'exécution JavaScript standard.
  2. Transformer la syntaxe : Convertir la syntaxe spécifique à TypeScript (comme certaines utilisations d'enum ou l'ancienne syntaxe de décorateur si configurée) en JavaScript équivalent.
  3. Gérer JSX : Transformer la syntaxe JSX (utilisée dans les fichiers .tsx et .jsx) en appels de fonction JavaScript standard (généralement React.createElement ou un équivalent de runtime JSX configuré).

L'avantage clé est que cela se produit à la volée pendant l'exécution (bun run) ou le processus de regroupement (bun build). Il n'y a pas d'étape de construction distincte et explicite requise juste pour exécuter votre code TypeScript pendant le développement.

Exemple :

Considérez ce fichier TypeScript (greet.ts) :

// greet.ts
interface User {
  name: string;
  id: number;
}

function greetUser(user: User): void {
  console.log(`Hello, ${user.name} (ID: ${user.id})!`);
}

const myUser: User = { name: "Bun Developer", id: 123 };

greetUser(myUser);

// Vous pouvez même utiliser les fonctionnalités modernes prises en charge par Bun
const message = `Bun version: ${Bun.version}`;
console.log(message);

Vous pouvez l'exécuter directement :

bun run greet.ts

Bun le transpilera en interne et exécutera le JavaScript résultant, produisant une sortie comme :

Hello, Bun Developer (ID: 123)!
Bun version: 1.x.y

Prise en charge de JSX :

De même, si vous avez un fichier .tsx avec JSX :

// component.tsx

// En supposant que vous ayez JSX configuré (les valeurs par défaut de Bun fonctionnent souvent avec React)
function MyComponent({ name }: { name: string }) {
  return <div className="greeting">Hello, {name}!</div>;
}

// REMARQUE : L'exécution directe de ceci ne rendra pas HTML,
// il montre juste la structure JS transpilée.
// Vous l'utiliseriez généralement dans une application ou un framework plus grand.
console.log("Simuler la création de composants (structure de sortie transpilée) :");
// La sortie réelle dépend des paramètres de transformation JSX,
// mais ce seraient des objets/appels de fonction JavaScript.

L'exécution de bun run component.tsx exécuterait le fichier, transpilant le JSX en JavaScript.

Configuration (tsconfig.json) :

Bun respecte les fichiers tsconfig.json pour les options de configuration qui affectent la transpilation. Bien qu'il n'effectue pas de vérification de type complète comme tsc (Bun se concentre sur la vitesse d'exécution et de transpilation), il lit tsconfig.json pour comprendre les paramètres tels que :

Si aucun tsconfig.json n'est trouvé, Bun utilise des paramètres par défaut raisonnables.

Cette intégration transparente rend le démarrage de projets TypeScript avec Bun incroyablement simple et rapide, abaissant la barrière à l'entrée et accélérant les cycles de développement.

Parlons des API spécifiques à Bun

Bien que Bun mette fortement l'accent sur la compatibilité avec les API Web Standard et Node.js, il introduit également son propre ensemble d'API intégrées et optimisées sous l'objet global Bun. Ces API fournissent souvent des alternatives hautes performances ou des wrappers pratiques pour les tâches courantes qui tirent parti des capacités de code natif de Bun.

Voici un aperçu de certaines API clés Bun.* :

Ces API représentent l'effort de Bun pour fournir des solutions intégrées et optimisées pour les tâches de développement courantes, réduisant la dépendance aux dépendances externes et tirant parti de la vitesse de son cœur natif.

API Web dans Bun

Un choix de conception fondamental dans Bun est son fort engagement à implémenter les API Web standard. Chaque fois qu'une API standard existe pour une tâche particulière (en particulier pour la mise en réseau et la gestion des données), Bun préfère implémenter cette norme plutôt que d'inventer une API propriétaire ou de s'appuyer uniquement sur les conventions Node.js.

Cette approche offre plusieurs avantages importants :

  1. Portabilité du code : Le code écrit à l'aide des API Web standard peut souvent être réutilisé dans différents environnements JavaScript – le navigateur, Node.js (qui adopte également de plus en plus les normes Web), Deno, Cloudflare Workers et Bun – avec moins de modifications.
  2. Familiarité : Les développeurs déjà familiarisés avec les API de navigateur peuvent tirer parti de ces connaissances lorsqu'ils travaillent avec Bun, ce qui réduit la courbe d'apprentissage.
  3. Pérennité : L'alignement sur les normes établies par des organismes comme WHATWG et W3C conduit généralement à des API plus stables et largement prises en charge à long terme.
  4. Performance : Les implémentations natives de Bun de ces API Web sont hautement optimisées pour son runtime.

Les API Web Standard clés implémentées dans Bun incluent :

Fetch API :

URL API :

Streams API :

Encoding API :

Blob API :

FormData API :

WebSocket API :

Minuteurs :

Console API :

Crypto API :

Performance API :

En fournissant des implémentations robustes et performantes de ces API Web essentielles, Bun se positionne comme un runtime moderne bien adapté à la création de serveurs Web, d'API et d'autres applications axées sur le réseau à l'aide d'interfaces familières et standardisées.

Serveur HTTP Bun, expliqué

Le principal moyen de créer des serveurs Web dans Bun est via l'API Bun.serve. Il est conçu pour des performances exceptionnelles et une facilité d'utilisation, s'intégrant de manière transparente aux API Web standard comme Request, Response et fetch.

Concepts de base :

La fonction Bun.serve prend un objet de configuration et renvoie un objet Server. La partie la plus critique de la configuration est la fonction fetch.

import { type Server } from "bun";

const server: Server = Bun.serve({
  port: 8080, // Le port sur lequel écouter
  hostname: "0.0.0.0", // L'interface réseau à lier (0.0.0.0 pour tous)

  // fetch : Le cœur du serveur - gère les requêtes entrantes
  async fetch(req: Request, server: Server): Promise<Response> {
    // req est un objet Request d'API Web standard
    // server est une référence à l'instance Server elle-même

    const url = new URL(req.url);

    // Exemple de routage de base
    if (url.pathname === "/") {
      return new Response("Homepage");
    }
    if (url.pathname === "/about") {
      return new Response("About Us page");
    }
    if (url.pathname === "/greet" && req.method === "GET") {
        const name = url.searchParams.get("name") || "World";
        return new Response(`Hello, ${name}!`);
    }
     if (url.pathname === "/data" && req.method === "POST") {
        try {
            const data = await req.json(); // Lire le corps de la requête en tant que JSON
            console.log("Received data:", data);
            return new Response(JSON.stringify({ received: data }), {
               headers: { 'Content-Type': 'application/json' }
            });
        } catch (e) {
            return new Response("Invalid JSON body", { status: 400 });
        }
    }

    // 404 Not Found par défaut
    return new Response("Page Not Found", { status: 404 });
  },

  // error : Gestionnaire facultatif pour les erreurs survenant *en dehors* du gestionnaire fetch
  error(error: Error): Response | Promise<Response> {
    console.error("[Server Error]", error);
    return new Response("Something went wrong!", { status: 500 });
  },

  // development : Définir sur true pour des pages d'erreur de développement utiles (par défaut : !process.env.NODE_ENV=production)
   development: true,

   // D'autres options comme 'websocket', 'tls' existent pour les cas d'utilisation avancés
});

console.log(`Bun server listening on http://${server.hostname}:${server.port}`);

// Vous pouvez interagir avec l'objet serveur :
// server.stop() // Arrête le serveur
// server.reload({...}) // Met à jour la configuration du serveur (par exemple, le gestionnaire fetch) de manière dynamique

Fonctionnalités clés :

Explore more

Fathom-R1-14B : Modèle de raisonnement IA avancé d'Inde

Fathom-R1-14B : Modèle de raisonnement IA avancé d'Inde

L'IA en expansion rapide. Fathom-R1-14B (14,8 milliards de paramètres) excelle en raisonnement mathématique et général, conçu par Fractal AI Research.

5 June 2025

Mistral Code : L'assistant de codage le plus personnalisable basé sur l'IA pour les entreprises

Mistral Code : L'assistant de codage le plus personnalisable basé sur l'IA pour les entreprises

Découvrez Mistral Code, l'IA d'aide au code la plus personnalisable pour les entreprises.

5 June 2025

Comment Claude Code transforme le codage de l'IA en 2025

Comment Claude Code transforme le codage de l'IA en 2025

Découvrez Claude Code en 2025 : codage IA révolutionné. Fonctionnalités, démo, et pourquoi il gagne du terrain après Windsurf d'Anthropic. Indispensable !

5 June 2025

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger