Blog
Standpunkt

Erste Schritte mit der Bun API

Zu den spannendsten Dev-Tools gehört Bun: ein schneller JavaScript-Toolkit für Produktivität & Performance. Es ist Runtime, Bundler, Testrunner & mehr.

Leo Schulz

Leo Schulz

5 June 2025

Erste Schritte mit der Bun API

```html

Zu den aufregendsten aktuellen Dev-Tools gehört Bun, ein unglaublich schnelles All-in-One-JavaScript-Toolkit, das entwickelt wurde, um die Produktivität von Entwicklern und die Anwendungsleistung zu steigern. Bun ist nicht nur eine weitere Laufzeitumgebung; es ist ein zusammenhängendes Ökosystem, das eine Laufzeitumgebung, einen Bundler, einen Test Runner, einen Paketmanager und mehr in einer einzigen nativen ausführbaren Datei umfasst. Dieser Leitfaden führt Sie durch die Grundlagen von Bun und konzentriert sich dabei auf seine Kernkonzepte und leistungsstarken APIs.

💡
Want a great API Testing tool that generates beautiful API Documentation?

Want an integrated, All-in-One platform for your Developer Team to work together with maximum productivity?

Apidog delivers all your demans, and replaces Postman at a much more affordable price!
button

Was ist Bun?

Im Kern basiert Bun auf einer Hochleistungs-JavaScript-Runtime-Engine. Im Gegensatz zu Node.js, das die V8-Engine von Google verwendet, verwendet Bun Apples JavaScriptCore (JSC), die Engine, die Safari antreibt. Diese Wahl, kombiniert mit Buns Implementierung in der Low-Level-Programmiersprache Zig, trägt erheblich zu seiner bemerkenswerten Geschwindigkeit bei. Startzeiten für Bun-Anwendungen werden oft als drastisch schneller gemessen als äquivalente Node.js-Anwendungen, manchmal um den Faktor vier oder mehr. Dieser Geschwindigkeitsvorteil erstreckt sich über den Start hinaus; Buns interne Implementierungen verschiedener APIs sind auf maximalen Durchsatz und minimalen Speicherverbrauch optimiert.

Aber Buns Ambition geht weit darüber hinaus, nur eine schnellere Laufzeitumgebung zu sein. Es soll ein umfassendes Toolkit sein, das häufige Entwicklerbedürfnisse direkt anspricht:

  1. Integrierte Werkzeuge: Der Befehl bun selbst fungiert als Einstiegspunkt für zahlreiche Funktionen. bun run führt Skripte aus, die in package.json definiert sind, bun install verwaltet Abhängigkeiten (oft viel schneller als npm oder yarn), bun test führt Tests mit einer Jest-kompatiblen API aus, bun build bündelt Code für die Produktion und bunx führt Pakete aus, ohne sie explizit zu installieren. Diese Integration vereinfacht Workflows, indem die Anzahl der benötigten separaten Entwicklungswerkzeuge reduziert wird.
  2. Native TypeScript- und JSX-Unterstützung: Eines der herausragenden Merkmale von Bun ist die sofort einsatzbereite Unterstützung für TypeScript- (.ts, .tsx) und JSX-Dateien (.jsx). Bun enthält einen integrierten, hochoptimierten Transpiler, der diese Dateitypen während der Ausführung oder des Bundlings nahtlos verarbeitet. Dies eliminiert die Notwendigkeit separater Kompilierungsschritte mit tsc oder Babel für viele gängige Entwicklungsszenarien und rationalisiert den Einrichtungsprozess.
  3. Modulsystemkompatibilität: Bun unterstützt modernes JavaScript mit erstklassiger Unterstützung für ES-Module (ESM). Es erkennt jedoch das riesige bestehende Ökosystem, das auf CommonJS (CJS) aufbaut. Bun bietet robuste Kompatibilität für beide Modulsysteme, sodass Entwickler import und require weitgehend austauschbar verwenden und die Millionen von vorhandenen CJS-Paketen nutzen können, die auf npm verfügbar sind.
  4. Web Standard API-Einhaltung: Ein wichtiges Designprinzip ist die Implementierung von Standard-Web-APIs. Funktionen und Objekte wie fetch, Request, Response, Headers, WebSocket und die Streams-API (ReadableStream, WritableStream) sind in den globalen Bun-Bereich integriert. Dies fördert die Codeportabilität zwischen serverseitigen Bun-Umgebungen, Browser-Frontends und Edge-Computing-Plattformen, sodass Entwickler vertraute APIs in verschiedenen Kontexten wiederverwenden können.
  5. Node.js-Kompatibilität: Während Bun mit optimierten APIs und Webstandards seinen eigenen Weg geht, strebt es einen hohen Grad an Kompatibilität mit der Node.js-API-Oberfläche an. Viele integrierte Node.js-Module (node:fs, node:path, node:os, node:events usw.) und globale Objekte (process, Buffer, __filename, __dirname) sind teilweise oder vollständig implementiert. Das Ziel ist es, vielen bestehenden Node.js-Projekten und npm-Paketen zu ermöglichen, mit minimalen oder keinen Änderungen auf Bun zu laufen, wodurch Bun in zahlreichen Fällen als potenzieller "Drop-in-Ersatz" positioniert wird.

Durch die Kombination dieser Elemente bietet Bun eine überzeugende Alternative für JavaScript- und TypeScript-Entwickler, die Leistung, Einfachheit und eine moderne Entwicklungserfahrung suchen.

Wie man Bun installiert

Der Einstieg in Bun ist für verschiedene Plattformen schnell und unkompliziert. Die gebräuchlichste Methode für macOS, Linux und Windows Subsystem for Linux (WSL) verwendet einen einfachen curl-Befehl, der in Ihrem Terminal ausgeführt wird:

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

Dieser Befehl lädt ein Installationsskript herunter und leitet es direkt an bash weiter. Das Skript verarbeitet die Erkennung Ihres Betriebssystems und Ihrer Architektur, lädt die entsprechende Bun-ausführbare Datei herunter und installiert sie normalerweise in ~/.bun/bin. Es versucht auch, die Konfigurationsdatei Ihrer Shell (z. B. .zshrc, .bashrc oder .bash_profile) zu aktualisieren, um ~/.bun/bin zum PATH Ihres Systems hinzuzufügen, wodurch der Befehl bun global verfügbar wird. Möglicherweise müssen Sie Ihre Terminalsitzung neu starten oder Ihre Shell-Konfigurationsdatei manuell laden (z. B. source ~/.zshrc), damit die Änderungen sofort wirksam werden.

Wenn Sie auf Berechtigungsprobleme stoßen oder es vorziehen, nicht direkt an bash weiterzuleiten, können Sie das Skript zuerst herunterladen und es vor der Ausführung untersuchen:

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

Andere Installationsmethoden:

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

Überprüfung:

Öffnen Sie nach der Installation ein neues Terminalfenster und überprüfen Sie die Installation, indem Sie die Version überprüfen:

bun --version

Dies sollte die installierte Versionsnummer ausgeben und bestätigen, dass Bun einsatzbereit ist. Sie können auch bun --help ausführen, um eine Liste der verfügbaren Befehle und Optionen anzuzeigen.

Führen Sie Ihr Bun zum ersten Mal aus

Lassen Sie uns eintauchen und ein einfaches Programm mit Bun schreiben und ausführen. Eine der häufigsten Aufgaben ist das Erstellen eines HTTP-Servers. Bun bietet eine integrierte, hochoptimierte API für diesen Zweck: Bun.serve.

Erstellen Sie eine neue Datei mit dem Namen server.js (oder server.ts, da Bun beides verarbeitet):

// server.ts

// Bun.serve startet den HTTP-Server
const server = Bun.serve({
  // Geben Sie den Port an, an dem gelauscht werden soll.
  // Standardmäßig process.env.PORT || 3000
  port: 3000,

  // Die 'fetch'-Funktion ist der Kern-Request-Handler.
  // Sie empfängt ein Standard-Request-Objekt und muss ein Response-Objekt (oder ein Promise, das zu einem aufgelöst wird) zurückgeben.
  fetch(request: Request): Response {
    // Erstellen Sie ein Standard-Web-API-Response-Objekt
    return new Response("Willkommen bei Bun!");
  },
});

// Protokollieren Sie eine Meldung, die angibt, dass der Server läuft
console.log(`Listening on http://localhost:${server.port}`);

Dieser Code-Snippet macht Folgendes:

  1. Er ruft Bun.serve auf, die primäre Funktion zum Erstellen von HTTP-Servern in Bun.
  2. Es übergibt ein Konfigurationsobjekt und gibt den port (in diesem Fall 3000) an.
  3. Der entscheidende Teil ist die fetch-Funktion. Diese Funktion wird für jede eingehende HTTP-Anfrage aufgerufen. Sie stimmt mit dem Service-Worker-Fetch-Event-Handler-Muster überein und akzeptiert ein Standard-Request-Objekt.
  4. Innerhalb von fetch erstellen und geben wir ein Standard-Response-Objekt zurück. Hier geben wir einfach den Klartext "Willkommen bei Bun!" zurück.
  5. Schließlich protokollieren wir eine Bestätigungsmeldung in der Konsole, einschließlich des tatsächlichen Ports, an dem der Server lauscht (zugänglich über server.port).

Um diesen Server auszuführen, öffnen Sie Ihr Terminal in dem Verzeichnis, in dem Sie die Datei gespeichert haben, und führen Sie Folgendes aus:

bun run server.ts

Oder, wenn Sie es als server.js gespeichert haben:

bun run server.js

Bun führt das Skript aus. Wenn Sie TypeScript (server.ts) verwendet haben, verarbeitet Buns interner Transpiler die Konvertierung in JavaScript während der Ausführung. Sie sehen die Meldung "Listening on http://localhost:3000".

Öffnen Sie nun Ihren Webbrowser und navigieren Sie zu http://localhost:3000. Sie sollten den Text "Willkommen bei Bun!" sehen.

Um den Server zu stoppen, gehen Sie zurück zu Ihrem Terminal und drücken Sie Strg + C.

Dieses einfache Beispiel demonstriert die einfache Einrichtung eines Basis-Servers und die Ausführung von Code (einschließlich TypeScript) direkt mit Bun, wobei seine integrierte Natur und die Abhängigkeit von Web Standard APIs wie Request und Response gezeigt werden.

Was ist die native TypeScript-Unterstützung in Bun?

Einer der wichtigsten Vorteile von Bun, insbesondere für Entwickler, die bereits TypeScript verwenden oder übernehmen möchten, ist die erstklassige, sofort einsatzbereite Unterstützung. Im Gegensatz zu Node.js, wo die Ausführung von TypeScript typischerweise eine Vorabkompilierung mit dem TypeScript-Compiler (tsc) oder die Verwendung von Loadern/Registern wie ts-node oder tsx erfordert, verarbeitet Bun dies nativ und transparent.

Wie es funktioniert:

Wenn Sie Bun auffordern, eine .ts- oder .tsx-Datei auszuführen (z. B. bun run myscript.ts), ruft es automatisch seinen internen Transpiler auf. Dieser Transpiler ist in nativem Code (Zig) geschrieben und extrem schnell. Seine Aufgabe ist es:

  1. Typen entfernen: Entfernen Sie TypeScript-Typanmerkungen, Schnittstellen, Enums usw., da diese nicht Teil der Standard-JavaScript-Ausführung sind.
  2. Syntax transformieren: Konvertieren Sie TypeScript-spezifische Syntax (wie bestimmte enum-Verwendungen oder ältere Decorator-Syntax, falls konfiguriert) in äquivalentes JavaScript.
  3. JSX verarbeiten: Transformieren Sie JSX-Syntax (verwendet in .tsx- und .jsx-Dateien) in Standard-JavaScript-Funktionsaufrufe (typischerweise React.createElement oder ein konfigurierter JSX-Runtime-Äquivalent).

Der Hauptvorteil ist, dass dies on-the-fly während der Ausführung (bun run) oder des Bundling-Prozesses (bun build) geschieht. Es ist kein separater, expliziter Build-Schritt erforderlich, nur um Ihren TypeScript-Code während der Entwicklung auszuführen.

Beispiel:

Betrachten Sie diese TypeScript-Datei (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);

// Sie können sogar moderne Funktionen verwenden, die Bun unterstützt
const message = `Bun version: ${Bun.version}`;
console.log(message);

Sie können dies direkt ausführen:

bun run greet.ts

Bun transpilert es intern und führt das resultierende JavaScript aus, wodurch eine Ausgabe wie folgt erzeugt wird:

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

JSX-Unterstützung:

Wenn Sie beispielsweise eine .tsx-Datei mit JSX haben:

// component.tsx

// Angenommen, Sie haben JSX konfiguriert (Bun-Standards funktionieren oft mit React)
function MyComponent({ name }: { name: string }) {
  return <div className="greeting">Hello, {name}!</div>;
}

// HINWEIS: Wenn Sie dies direkt ausführen, wird kein HTML gerendert,
// es zeigt nur die transpilierte JS-Struktur.
// Sie würden dies typischerweise innerhalb einer größeren App oder eines Frameworks verwenden.
console.log("Simulieren der Komponentenerstellung (transpilierte Ausgabestruktur):");
// Die tatsächliche Ausgabe hängt von den JSX-Transform-Einstellungen ab,
// aber es wären JavaScript-Objekte/Funktionsaufrufe.

Wenn Sie bun run component.tsx ausführen, wird die Datei ausgeführt und das JSX in JavaScript transpilert.

Konfiguration (tsconfig.json):

Bun respektiert tsconfig.json-Dateien für Konfigurationsoptionen, die sich auf die Transpilierung auswirken. Obwohl es keine vollständige Typüberprüfung wie tsc durchführt (Bun konzentriert sich auf die Ausführungs- und Transpilierungsgeschwindigkeit), liest es tsconfig.json, um Einstellungen wie Folgendes zu verstehen:

Wenn keine tsconfig.json gefunden wird, verwendet Bun sinnvolle Standardeinstellungen.

Diese nahtlose Integration macht den Start von TypeScript-Projekten mit Bun unglaublich einfach und schnell, wodurch die Einstiegshürde gesenkt und die Entwicklungszyklen beschleunigt werden.

Sprechen wir über Bun-spezifische APIs

Während Bun großen Wert auf die Kompatibilität mit Web Standard APIs und Node.js legt, führt es auch eine eigene Reihe optimierter, integrierter APIs unter dem globalen Bun-Objekt ein. Diese APIs bieten oft Hochleistungsalternativen oder praktische Wrapper für gängige Aufgaben, die die nativen Codefunktionen von Bun nutzen.

Hier ist ein Einblick in einige wichtige Bun.*-APIs:

Diese APIs stellen Buns Bemühungen dar, optimierte, integrierte Lösungen für gängige Entwicklungsaufgaben bereitzustellen, die Abhängigkeit von externen Abhängigkeiten zu verringern und die Geschwindigkeit seines nativen Kerns zu nutzen.

Web-APIs in Bun

Eine grundlegende Designentscheidung in Bun ist sein starkes Engagement für die Implementierung von Standard-Web-APIs. Wo immer eine Standard-API für eine bestimmte Aufgabe existiert (insbesondere für Netzwerk- und Datenverarbeitung), bevorzugt Bun die Implementierung dieses Standards, anstatt eine proprietäre API zu erfinden oder sich ausschließlich auf Node.js-Konventionen zu verlassen.

Dieser Ansatz bietet mehrere wesentliche Vorteile:

  1. Codeportabilität: Code, der mit Standard-Web-APIs geschrieben wurde, kann oft in verschiedenen JavaScript-Umgebungen wiederverwendet werden – dem Browser, Node.js (das auch zunehmend Webstandards übernimmt), Deno, Cloudflare Workers und Bun – mit weniger Änderungen.
  2. Vertrautheit: Entwickler, die bereits mit Browser-APIs vertraut sind, können dieses Wissen bei der Arbeit mit Bun nutzen und so die Lernkurve verkürzen.
  3. Zukunftssicherheit: Die Ausrichtung auf Standards, die von Gremien wie WHATWG und W3C festgelegt wurden, führt im Allgemeinen langfristig zu stabileren und weithin unterstützten APIs.
  4. Leistung: Buns native Implementierungen dieser Web-APIs sind für seine Laufzeitumgebung hochoptimiert.

Zu den wichtigsten Web Standard APIs, die in Bun implementiert sind, gehören:

Fetch-API:

URL-API:

Streams-API:

Codierungs-API:

Blob-API:

FormData-API:

WebSocket-API:

Timer:

Console-API:

Crypto-API:

Performance-API:

Durch die Bereitstellung robuster, leistungsstarker Implementierungen dieser wesentlichen Web-APIs positioniert sich Bun als moderne Laufzeitumgebung, die sich gut für den Aufbau von Webservern, APIs und anderen netzwerkzentrierten Anwendungen mit vertrauten, standardisierten Schnittstellen eignet.

Bun HTTP-Server, erklärt

Die primäre Möglichkeit, Webserver in Bun zu erstellen, ist über die Bun.serve-API. Es ist auf außergewöhnliche Leistung und Benutzerfreundlichkeit ausgelegt und lässt sich nahtlos in Standard-Web-APIs wie Request, Response und fetch integrieren.

Kernkonzepte:

Die Funktion Bun.serve nimmt ein Konfigurationsobjekt entgegen und gibt ein Server-Objekt zurück. Der wichtigste Teil der Konfiguration ist die fetch-Funktion.

import { type Server } from "bun";

const server: Server = Bun.serve({
  port: 8080, // Der Port, an dem gelauscht werden soll
  hostname: "0.0.0.0", // Die Netzwerkschnittstelle, an die gebunden werden soll (0.0.0.0 für alle)

  // fetch: Das Herzstück des Servers - verarbeitet eingehende Anfragen
  async fetch(req: Request, server: Server): Promise<Response> {
    // req ist ein Standard-Web-API-Request-Objekt
    // server ist ein Verweis auf die Serverinstanz selbst

    const url = new URL(req.url);

    // Einfaches Routing-Beispiel
    if (url.pathname === "/") {
      return new Response("Homepage");
    }
    if (url.pathname === "/about") {
      return new Response("Über uns Seite");
    }
    if (url.pathname === "/greet" && req.method === "GET") {
        const name = url.searchParams.get("name") || "World";
        return new Response(`Hallo, ${name}!`);
    }
     if (url.pathname === "/data" && req.method === "POST") {
        try {
            const data = await req.json(); // Lesen Sie den Anfragetext als JSON
            console.log("Empfangene Daten:", data);
            return new Response(JSON.stringify({ received: data }), {
               headers: { 'Content-Type': 'application/json' }
            });
        } catch (e) {
            return new Response("Ungültiger JSON-Text", { status: 400 });
        }
    }

    // Standard 404 Nicht gefunden
    return new Response("Seite nicht gefunden", { status: 404 });
  },

  // error: Optionaler Handler für Fehler, die *außerhalb* des Fetch-Handlers auftreten
  error(error: Error): Response | Promise<Response> {
    console.error("[Server Error]", error);
    return new Response("Etwas ist schief gelaufen!", { status: 500 });
  },

  // development: Auf true setzen für hilfreiche Entwicklungsfehlerseiten (Standard: !process.env.NODE_ENV=production)
   development: true,

   // Andere Optionen wie 'websocket', 'tls' existieren für erweiterte Anwendungsfälle
});

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

// Sie können mit dem Serverobjekt interagieren:
// server.stop() // Stoppt den Server
// server.reload({...}) // Aktualisiert die Serverkonfiguration (z. B. Fetch-Handler) dynamisch

Hauptmerkmale:

Bun.serve bietet eine leistungsstarke und dennoch einfache Grundlage für den Aufbau von Webanwendungen und APIs in Bun, wobei Geschwindigkeit und die Einhaltung von Webstandards im Vordergrund stehen

Explore more

Fathom-R1-14B: Fortschrittliches KI-Argumentationsmodell aus Indien

Fathom-R1-14B: Fortschrittliches KI-Argumentationsmodell aus Indien

Künstliche Intelligenz wächst rasant. FractalAIResearch/Fathom-R1-14B (14,8 Mrd. Parameter) glänzt in Mathe & Logik.

5 June 2025

Cursor 1.0 mit BugBot: KI-gestütztes Automatisierungstest-Tool ist da:

Cursor 1.0 mit BugBot: KI-gestütztes Automatisierungstest-Tool ist da:

Die Softwareentwicklung erlebt Innovationen durch KI. Cursor, ein KI-Editor, erreicht mit Version 1.0 einen Meilenstein.

5 June 2025

30+ öffentliche Web 3.0 APIs, die Sie jetzt nutzen können

30+ öffentliche Web 3.0 APIs, die Sie jetzt nutzen können

Der Aufstieg von Web 3.0: Dezentral, nutzerorientiert, transparent. APIs ermöglichen innovative dApps und Blockchain-Integration.

4 June 2025

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenDownload