Heim

Skill

Entwicklertools

bun-runtime

affaan-m/ECC

Bietet eine Anleitung zur Verwendung von Bun als JavaScript-Laufzeitumgebung, Paketmanager, Bundler und Testausführungsumgebung, einschließlich der Migration von Node.js und der Bereitstellung über Vercel.

...Alle erweitern

Zeit aktualisiert 1. Oktober 2026

# javascript # typescript # bun # vercel # package manager # bundler # node js migration # test runner

Bun-Laufzeitumgebung

Bun ist eine schnelle All-in-One-JavaScript-Laufzeitumgebung und ein Toolkit: Laufzeitumgebung, Paketmanager, Bundler und Test-Runner.

Einsatzbereiche

Verwenden Sie Bun vorzugsweise für: neue JS/TS-Projekte, Skripte, bei denen es auf die Installations- und Ausführungsgeschwindigkeit ankommt, Vercel-Bereitstellungen mit der Bun-Laufzeitumgebung sowie wenn Sie eine einzige Toolchain (Ausführen + Installieren + Testen + Erstellen) wünschen.
Verwenden Sie Node vorzugsweise für: maximale Kompatibilität mit dem Ökosystem, ältere Tools, die Node voraussetzen, oder wenn bei einer Abhängigkeit bekannte Probleme mit Bun vorliegen.

Verwenden Sie dies, wenn: Sie Bun einführen, von Node migrieren, Bun-Skripte/-Tests schreiben oder debuggen oder Bun auf Vercel oder anderen Plattformen konfigurieren.

So funktioniert es

Laufzeitumgebung: Nahtlos integrierbare, Node-kompatible Laufzeitumgebung (basierend auf JavaScriptCore, implementiert in Zig).
Paketmanager: bun install ist deutlich schneller als npm/yarn. Die Lockdatei ist bun.lock in der aktuellen Bun-Version standardmäßig im Textformat; ältere Versionen verwendeten bun.lockb (binär).
Bundler: Integrierter Bundler und Transpiler für Apps und Bibliotheken.
Test-Runner: Integrierter bun test mit Jest-ähnlicher API.

Migration von Node: Ersetzen node script.js durch bun run script.js oder bun script.js. Führen Sie bun install anstelle von npm install; die meisten Pakete funktionieren. Verwenden Sie bun run für npm-Skripte; bun x für einmalige Ausführungen im npx-Stil. Integrierte Node-Funktionen werden unterstützt; bevorzugen Sie, sofern vorhanden, Bun-APIs für eine bessere Leistung.

Vercel: Stelle die Laufzeitumgebung in den Projekteinstellungen auf Bun ein. Build: bun run build oder bun build ./src/index.ts --outdir=dist. Installation: bun install --frozen-lockfile für reproduzierbare Deploys.

Beispiele

Ausführen und installieren

# Install dependencies (creates/updates bun.lock or bun.lockb)
bun install

# Run a script or file
bun run dev
bun run src/index.ts
bun src/index.ts

Skripte und Umgebung

bun run --env-file=.env dev
FOO=bar bun run script.ts

Testen

bun test
bun test --watch

// test/example.test.ts
import { expect, test } from "bun:test";

test("add", () => {
  expect(1 + 2).toBe(3);
});

Laufzeit-API

const file = Bun.file("package.json");
const json = await file.json();

Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello");
  },
});

Bewährte Vorgehensweisen

Die Sperrdatei festschreiben (bun.lock oder bun.lockb) für reproduzierbare Installationen fest.
Verwenden Sie bun run Skripte. Für TypeScript läuft Bun .ts nativ.
Halten Sie die Abhängigkeiten auf dem neuesten Stand; Bun und das Ökosystem entwickeln sich schnell weiter.

Auf GitHub ansehen

---
name: bun-runtime
description: Provides guidance on using Bun as a JavaScript runtime, package manager, bundler, and test runner, including migration from Node.js and Vercel deployment.
---

# Bun Runtime

Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner.

## When to Use

- **Prefer Bun** for: new JS/TS projects, scripts where install/run speed matters, Vercel deployments with Bun runtime, and when you want a single toolchain (run + install + test + build).
- **Prefer Node** for: maximum ecosystem compatibility, legacy tooling that assumes Node, or when a dependency has known Bun issues.

Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms.

## How It Works

- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig).
- **Package manager**: `bun install` is significantly faster than npm/yarn. Lockfile is `bun.lock` (text) by default in current Bun; older versions used `bun.lockb` (binary).
- **Bundler**: Built-in bundler and transpiler for apps and libraries.
- **Test runner**: Built-in `bun test` with Jest-like API.

**Migration from Node**: Replace `node script.js` with `bun run script.js` or `bun script.js`. Run `bun install` in place of `npm install`; most packages work. Use `bun run` for npm scripts; `bun x` for npx-style one-off runs. Node built-ins are supported; prefer Bun APIs where they exist for better performance.

**Vercel**: Set runtime to Bun in project settings. Build: `bun run build` or `bun build ./src/index.ts --outdir=dist`. Install: `bun install --frozen-lockfile` for reproducible deploys.

## Examples

### Run and install

```bash
# Install dependencies (creates/updates bun.lock or bun.lockb)
bun install

# Run a script or file
bun run dev
bun run src/index.ts
bun src/index.ts
```

### Scripts and env

```bash
bun run --env-file=.env dev
FOO=bar bun run script.ts
```

### Testing

```bash
bun test
bun test --watch
```

```typescript
// test/example.test.ts
import { expect, test } from "bun:test";

test("add", () => {
  expect(1 + 2).toBe(3);
});
```

### Runtime API

```typescript
const file = Bun.file("package.json");
const json = await file.json();

Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello");
  },
});
```

## Best Practices

- Commit the lockfile (`bun.lock` or `bun.lockb`) for reproducible installs.
- Prefer `bun run` for scripts. For TypeScript, Bun runs `.ts` natively.
- Keep dependencies up to date; Bun and the ecosystem evolve quickly.