Hilfsfunktionen mit Bun JS

`Bun.version`

Ein string, der die Version des aktuell laufenden bun CLI enthält.

Bun.version;
// => "1.3.3"

`Bun.revision`

Der Git-Commit von Bun, der kompiliert wurde, um das aktuelle bun CLI zu erstellen.

Bun.revision;
// => "f02561530fda1ee9396f51c8bc99b38716e38296"

`Bun.env`

Ein Alias für process.env.

`Bun.main`

Ein absoluter Pfad zum Einstiegspunkt des aktuellen Programms (die Datei, die mit bun run ausgeführt wurde).

Bun.main;
// /path/to/script.ts

Dies ist besonders nützlich, um festzustellen, ob ein Skript direkt ausgeführt wird, im Gegensatz dazu, von einem anderen Skript importiert zu werden.

if (import.meta.path === Bun.main) {
  // dieses Skript wird direkt ausgeführt
} else {
  // diese Datei wird von einem anderen Skript importiert
}

Dies ist analog zum require.main = module-Trick in Node.js.

`Bun.sleep()`

Bun.sleep(ms: number)

Gibt ein Promise zurück, das nach der angegebenen Anzahl von Millisekunden aufgelöst wird.

console.log("hello");
await Bun.sleep(1000);
console.log("hello eine Sekunde später!");

Alternativ können Sie ein Date-Objekt übergeben, um ein Promise zu erhalten, das zu diesem Zeitpunkt aufgelöst wird.

const oneSecondInFuture = new Date(Date.now() + 1000);

console.log("hello");
await Bun.sleep(oneSecondInFuture);
console.log("hello eine Sekunde später!");

`Bun.sleepSync()`

Bun.sleepSync(ms: number)

Eine blockierende synchrone Version von Bun.sleep.

console.log("hello");
Bun.sleepSync(1000); // blockiert den Thread für eine Sekunde
console.log("hello eine Sekunde später!");

`Bun.which()`

Bun.which(bin: string)

Gibt den Pfad zu einer ausführbaren Datei zurück, ähnlich wie die Eingabe von which in Ihrem Terminal.

const ls = Bun.which("ls");
console.log(ls); // "/usr/bin/ls"

Standardmäßig sucht Bun in der aktuellen PATH-Umgebungsvariablen, um den Pfad zu bestimmen. So konfigurieren Sie PATH:

const ls = Bun.which("ls", {
  PATH: "/usr/local/bin:/usr/bin:/bin",
});
console.log(ls); // "/usr/bin/ls"

Übergeben Sie eine cwd-Option, um die ausführbare Datei innerhalb eines bestimmten Verzeichnisses aufzulösen.

const ls = Bun.which("ls", {
  cwd: "/tmp",
  PATH: "",
});

console.log(ls); // null

Sie können dies als eingebaute Alternative zum which npm-Paket betrachten.

`Bun.randomUUIDv7()`

Bun.randomUUIDv7() gibt eine UUID v7 zurück, die monoton ist und sich für Sortierung und Datenbanken eignet.

import { randomUUIDv7 } from "bun";

const id = randomUUIDv7();
// => "0192ce11-26d5-7dc3-9305-1426de888c5a"

Eine UUID v7 ist ein 128-Bit-Wert, der den aktuellen Zeitstempel, einen Zufallswert und einen Zähler codiert. Der Zeitstempel wird mit den niedrigsten 48 Bits codiert, und der Zufallswert und der Zähler werden mit den verbleibenden Bits codiert.

Der timestamp-Parameter standardmäßig auf die aktuelle Zeit in Millisekunden. Wenn sich der Zeitstempel ändert, wird der Zähler auf eine pseudozufällige Ganzzahl zurückgesetzt, die auf 4096 begrenzt ist. Dieser Zähler ist atomar und threadsicher, was bedeutet, dass die Verwendung von Bun.randomUUIDv7() in vielen Workern innerhalb desselben Prozesses, die mit demselben Zeitstempel laufen, keine kollidierenden Zählerwerte haben.

Die letzten 8 Bytes der UUID sind ein kryptografisch sicherer Zufallswert. Es verwendet denselben Zufallszahlengenerator wie crypto.randomUUID() (der von BoringSSL stammt, der wiederum vom plattformspezifischen System-Zufallszahlengenerator stammt, der normalerweise von der zugrunde liegenden Hardware bereitgestellt wird).

namespace Bun {
  function randomUUIDv7(encoding?: "hex" | "base64" | "base64url" = "hex", timestamp?: number = Date.now()): string;
  /**
   * Wenn Sie "buffer" übergeben, erhalten Sie einen 16-Byte-Puffer anstelle eines Strings.
   */
  function randomUUIDv7(encoding: "buffer", timestamp?: number = Date.now()): Buffer;

  // Wenn Sie nur einen Zeitstempel übergeben, erhalten Sie einen Hex-String
  function randomUUIDv7(timestamp?: number = Date.now()): string;
}

Sie können die Codierung optional auf "buffer" setzen, um einen 16-Byte-Puffer anstelle eines Strings zu erhalten. Dies kann manchmal die String-Konvertierungs-Overhead vermeiden.

const buffer = Bun.randomUUIDv7("buffer");

base64- und base64url-Codierungen werden ebenfalls unterstützt, wenn Sie einen etwas kürzeren String wünschen.

const base64 = Bun.randomUUIDv7("base64");
const base64url = Bun.randomUUIDv7("base64url");

`Bun.peek()`

Bun.peek(prom: Promise)

Liest das Ergebnis eines Promises ohne await oder .then, aber nur, wenn das Promise bereits erfüllt oder abgelehnt wurde.

import { peek } from "bun";

const promise = Promise.resolve("hi");

// kein await!
const result = peek(promise);
console.log(result); // "hi"

Dies ist wichtig, wenn Sie versuchen, die Anzahl der unnötigen Microticks in leistungskritischem Code zu reduzieren. Es ist eine fortgeschrittene API, und Sie sollten sie wahrscheinlich nicht verwenden, es sei denn, Sie wissen, was Sie tun.

import { peek } from "bun";
import { expect, test } from "bun:test";

test("peek", () => {
  const promise = Promise.resolve(true);

  // kein await notwendig!
  expect(peek(promise)).toBe(true);

  // wenn wir erneut peeken, gibt es denselben Wert zurück
  const again = peek(promise);
  expect(again).toBe(true);

  // wenn wir ein Nicht-Promise peeken, gibt es den Wert zurück
  const value = peek(42);
  expect(value).toBe(42);

  // wenn wir ein ausstehendes Promise peeken, gibt es das Promise erneut zurück
  const pending = new Promise(() => {});
  expect(peek(pending)).toBe(pending);

  // Wenn wir ein abgelehntes Promise peeken:
  // - gibt es den Fehler zurück
  // - markiert das Promise nicht als behandelt
  const rejected = Promise.reject(new Error("Promise-Ablehnung erfolgreich getestet"));
  expect(peek(rejected).message).toBe("Promise-Ablehnung erfolgreich getestet");
});

Die peek.status-Funktion ermöglicht es Ihnen, den Status eines Promises zu lesen, ohne es aufzulösen.

import { peek } from "bun";
import { expect, test } from "bun:test";

test("peek.status", () => {
  const promise = Promise.resolve(true);
  expect(peek.status(promise)).toBe("fulfilled");

  const pending = new Promise(() => {});
  expect(peek.status(pending)).toBe("pending");

  const rejected = Promise.reject(new Error("oh nein"));
  expect(peek.status(rejected)).toBe("rejected");
});

`Bun.openInEditor()`

Öffnet eine Datei in Ihrem Standard-Editor. Bun erkennt Ihren Editor automatisch über die $VISUAL- oder $EDITOR-Umgebungsvariablen.

const currentFile = import.meta.url;
Bun.openInEditor(currentFile);

Sie können dies über die debug.editor-Einstellung in Ihrer bunfig.toml überschreiben.

toml

[debug] 
editor = "code"

Oder geben Sie einen Editor mit dem editor-Parameter an. Sie können auch eine Zeilen- und Spaltennummer angeben.

Bun.openInEditor(import.meta.url, {
  editor: "vscode", // oder "subl"
  line: 10,
  column: 5,
});

`Bun.deepEquals()`

Überprüft rekursiv, ob zwei Objekte äquivalent sind. Dies wird intern von expect().toEqual() in bun:test verwendet.

const foo = { a: 1, b: 2, c: { d: 3 } };

// true
Bun.deepEquals(foo, { a: 1, b: 2, c: { d: 3 } });

// false
Bun.deepEquals(foo, { a: 1, b: 2, c: { d: 4 } });

Ein dritter boolescher Parameter kann verwendet werden, um den "strengen" Modus zu aktivieren. Dies wird von expect().toStrictEqual() im Test-Runner verwendet.

const a = { entries: [1, 2] };
const b = { entries: [1, 2], extra: undefined };

Bun.deepEquals(a, b); // => true
Bun.deepEquals(a, b, true); // => false

Im strengen Modus gelten Folgendes als ungleich:

// undefined-Werte
Bun.deepEquals({}, { a: undefined }, true); // false

// undefined in Arrays
Bun.deepEquals(["asdf"], ["asdf", undefined], true); // false

// sparse Arrays
Bun.deepEquals([, 1], [undefined, 1], true); // false

// Objekt-Literale vs. Instanzen mit denselben Eigenschaften
class Foo {
  a = 1;
}
Bun.deepEquals(new Foo(), { a: 1 }, true); // false

`Bun.escapeHTML()`

Bun.escapeHTML(value: string | object | number | boolean): string

Maskiert die folgenden Zeichen aus einem Eingabe-String:

" wird zu "
& wird zu &
' wird zu '
< wird zu <
> wird zu >

Diese Funktion ist für große Eingaben optimiert. Auf einem M1X verarbeitet sie 480 MB/s bis 20 GB/s, abhängig davon, wie viele Daten maskiert werden und ob es Nicht-ASCII-Text gibt. Nicht-String-Typen werden vor dem Maskieren in einen String konvertiert.

`Bun.stringWidth()`

NOTE

~6.756x schnellere `string-width`-Alternative

Ermittelt die Spaltenanzahl eines Strings, wie er in einem Terminal angezeigt würde. Unterstützt ANSI-Escape-Codes, Emoji und breite Zeichen.

Beispielverwendung:

Bun.stringWidth("hello"); // => 5
Bun.stringWidth("\u001b[31mhello\u001b[0m"); // => 5
Bun.stringWidth("\u001b[31mhello\u001b[0m", { countAnsiEscapeCodes: true }); // => 12

Dies ist nützlich für:

Ausrichten von Text in einem Terminal
Schnelles Überprüfen, ob ein String ANSI-Escape-Codes enthält
Messen der Breite eines Strings in einem Terminal

Diese API ist so gestaltet, dass sie mit dem beliebten "string-width"-Paket übereinstimmt, sodass bestehender Code einfach nach Bun portiert werden kann und umgekehrt.

In diesem Benchmark ist Bun.stringWidth ~6.756x schneller als das string-width npm-Paket für Eingaben größer als etwa 500 Zeichen. Vielen Dank an sindresorhus für ihre Arbeit an string-width!

❯ bun string-width.mjs
cpu: 13th Gen Intel(R) Core(TM) i9-13900
runtime: bun 1.0.29 (x64-linux)

benchmark                                          time (avg)             (min … max)       p75       p99      p995
------------------------------------------------------------------------------------- -----------------------------
Bun.stringWidth     500 chars ascii              37.09 ns/iter   (36.77 ns … 41.11 ns)  37.07 ns  38.84 ns  38.99 ns

❯ node string-width.mjs

benchmark                                          time (avg)             (min … max)       p75       p99      p995
------------------------------------------------------------------------------------- -----------------------------
npm/string-width    500 chars ascii             249,710 ns/iter (239,970 ns … 293,180 ns) 250,930 ns  276,700 ns 281,450 ns

Um Bun.stringWidth schnell zu machen, haben wir es in Zig mit optimierten SIMD-Anweisungen implementiert, wobei Latin1, UTF-16 und UTF-8-Codierungen berücksichtigt werden. Es besteht die Tests von string-width.

Vollständigen Benchmark anzeigen">

Zur Erinnerung: 1 Nanosekunde (ns) ist 1 Milliardstel einer Sekunde. Hier ist eine schnelle Referenz für die Umrechnung zwischen Einheiten:

Einheit	1 Millisekunde
ns	1.000.000
µs	1.000
ms	1

bash

❯ bun string-width.mjs
cpu: 13th Gen Intel(R) Core(TM) i9-13900
runtime: bun 1.0.29 (x64-linux)

benchmark                                          time (avg)             (min … max)       p75       p99      p995
------------------------------------------------------------------------------------- -----------------------------
Bun.stringWidth      5 chars ascii              16.45 ns/iter   (16.27 ns … 19.71 ns)  16.48 ns  16.93 ns  17.21 ns
Bun.stringWidth     50 chars ascii              19.42 ns/iter   (18.61 ns … 27.85 ns)  19.35 ns   21.7 ns  22.31 ns
Bun.stringWidth    500 chars ascii              37.09 ns/iter   (36.77 ns … 41.11 ns)  37.07 ns  38.84 ns  38.99 ns
Bun.stringWidth  5,000 chars ascii              216.9 ns/iter  (215.8 ns … 228.54 ns) 216.23 ns 228.52 ns 228.53 ns
Bun.stringWidth 25,000 chars ascii               1.01 µs/iter     (1.01 µs … 1.01 µs)   1.01 µs   1.01 µs   1.01 µs
Bun.stringWidth      7 chars ascii+emoji         54.2 ns/iter   (53.36 ns … 58.19 ns)  54.23 ns  57.55 ns  57.94 ns
Bun.stringWidth     70 chars ascii+emoji       354.26 ns/iter (350.51 ns … 363.96 ns) 355.93 ns 363.11 ns 363.96 ns
Bun.stringWidth    700 chars ascii+emoji          3.3 µs/iter      (3.27 µs … 3.4 µs)    3.3 µs    3.4 µs    3.4 µs
Bun.stringWidth  7,000 chars ascii+emoji        32.69 µs/iter   (32.22 µs … 45.27 µs)   32.7 µs  34.57 µs  34.68 µs
Bun.stringWidth 35,000 chars ascii+emoji       163.35 µs/iter (161.17 µs … 170.79 µs) 163.82 µs 169.66 µs 169.93 µs
Bun.stringWidth      8 chars ansi+emoji         66.15 ns/iter   (65.17 ns … 69.97 ns)  66.12 ns   69.8 ns  69.87 ns
Bun.stringWidth     80 chars ansi+emoji        492.95 ns/iter  (488.05 ns … 499.5 ns)  494.8 ns 498.58 ns  499.5 ns
Bun.stringWidth    800 chars ansi+emoji          4.73 µs/iter     (4.71 µs … 4.88 µs)   4.72 µs   4.88 µs   4.88 µs
Bun.stringWidth  8,000 chars ansi+emoji         47.02 µs/iter   (46.37 µs … 67.44 µs)  46.96 µs  49.57 µs  49.63 µs
Bun.stringWidth 40,000 chars ansi+emoji        234.45 µs/iter (231.78 µs … 240.98 µs) 234.92 µs 236.34 µs 236.62 µs
Bun.stringWidth     19 chars ansi+emoji+ascii  135.46 ns/iter (133.67 ns … 143.26 ns) 135.32 ns 142.55 ns 142.77 ns
Bun.stringWidth    190 chars ansi+emoji+ascii    1.17 µs/iter     (1.16 µs … 1.17 µs)   1.17 µs   1.17 µs   1.17 µs
Bun.stringWidth  1,900 chars ansi+emoji+ascii   11.45 µs/iter   (11.26 µs … 20.41 µs)  11.45 µs  12.08 µs  12.11 µs
Bun.stringWidth 19,000 chars ansi+emoji+ascii  114.06 µs/iter (112.86 µs … 120.06 µs) 114.25 µs 115.86 µs 116.15 µs
Bun.stringWidth 95,000 chars ansi+emoji+ascii  572.69 µs/iter (565.52 µs … 607.22 µs) 572.45 µs 604.86 µs 605.21 µs

bash

❯ node string-width.mjs
cpu: 13th Gen Intel(R) Core(TM) i9-13900
runtime: node v21.4.0 (x64-linux)

benchmark                                           time (avg)             (min … max)       p75       p99      p995
-------------------------------------------------------------------------------------- -----------------------------
npm/string-width      5 chars ascii               3.19 µs/iter     (3.13 µs … 3.48 µs)   3.25 µs   3.48 µs   3.48 µs
npm/string-width     50 chars ascii              20.09 µs/iter  (18.93 µs … 435.06 µs)  19.49 µs  21.89 µs  22.59 µs
npm/string-width    500 chars ascii             249.71 µs/iter (239.97 µs … 293.18 µs) 250.93 µs  276.7 µs 281.45 µs
npm/string-width  5,000 chars ascii               6.69 ms/iter     (6.58 ms … 6.76 ms)   6.72 ms   6.76 ms   6.76 ms
npm/string-width 25,000 chars ascii             139.57 ms/iter (137.17 ms … 143.28 ms) 140.49 ms 143.28 ms 143.28 ms
npm/string-width      7 chars ascii+emoji          3.7 µs/iter     (3.62 µs … 3.94 µs)   3.73 µs   3.94 µs   3.94 µs
npm/string-width     70 chars ascii+emoji        23.93 µs/iter   (22.44 µs … 331.2 µs)  23.15 µs  25.98 µs   30.2 µs
npm/string-width    700 chars ascii+emoji       251.65 µs/iter (237.78 µs … 444.69 µs) 252.92 µs 325.89 µs 354.08 µs
npm/string-width  7,000 chars ascii+emoji         4.95 ms/iter     (4.82 ms … 5.19 ms)      5 ms   5.04 ms   5.19 ms
npm/string-width 35,000 chars ascii+emoji        96.93 ms/iter  (94.39 ms … 102.58 ms)  97.68 ms 102.58 ms 102.58 ms
npm/string-width      8 chars ansi+emoji          3.92 µs/iter     (3.45 µs … 4.57 µs)   4.09 µs   4.57 µs   4.57 µs
npm/string-width     80 chars ansi+emoji         24.46 µs/iter     (22.87 µs … 4.2 ms)  23.54 µs  25.89 µs  27.41 µs
npm/string-width    800 chars ansi+emoji        259.62 µs/iter (246.76 µs … 480.12 µs) 258.65 µs 349.84 µs 372.55 µs
npm/string-width  8,000 chars ansi+emoji          5.46 ms/iter     (5.41 ms … 5.57 ms)   5.48 ms   5.55 ms   5.57 ms
npm/string-width 40,000 chars ansi+emoji        108.91 ms/iter  (107.55 ms … 109.5 ms) 109.25 ms  109.5 ms  109.5 ms
npm/string-width     19 chars ansi+emoji+ascii    6.53 µs/iter     (6.35 µs … 6.75 µs)   6.54 µs   6.75 µs   6.75 µs
npm/string-width    190 chars ansi+emoji+ascii   55.52 µs/iter  (52.59 µs … 352.73 µs)  54.19 µs  80.77 µs 167.21 µs
npm/string-width  1,900 chars ansi+emoji+ascii  701.71 µs/iter (653.94 µs … 893.78 µs)  715.3 µs 855.37 µs  872.9 µs
npm/string-width 19,000 chars ansi+emoji+ascii   27.19 ms/iter   (26.89 ms … 27.41 ms)  27.28 ms  27.41 ms  27.41 ms
npm/string-width 95,000 chars ansi+emoji+ascii     3.68 s/iter        (3.66 s … 3.7 s)    3.69 s     3.7 s     3.7 s

TypeScript-Definition:

namespace Bun {
  export function stringWidth(
    /**
     * Der zu messende String
     */
    input: string,
    options?: {
      /**
       * Wenn `true`, werden ANSI-Escape-Codes als Teil der String-Breite gezählt. Wenn `false`, werden ANSI-Escape-Codes bei der Berechnung der String-Breite ignoriert.
       *
       * @default false
       */
      countAnsiEscapeCodes?: boolean;
      /**
       * Wenn es mehrdeutig ist und `true`, werden Emoji als 1 Zeichen breit gezählt. Wenn `false`, werden Emoji als 2 Zeichen breit gezählt.
       *
       * @default true
       */
      ambiguousIsNarrow?: boolean;
    },
  ): number;
}

`Bun.fileURLToPath()`

Konvertiert eine file://-URL in einen absoluten Pfad.

const path = Bun.fileURLToPath(new URL("file:///foo/bar.txt"));
console.log(path); // "/foo/bar.txt"

`Bun.pathToFileURL()`

Konvertiert einen absoluten Pfad in eine file://-URL.

const url = Bun.pathToFileURL("/foo/bar.txt");
console.log(url); // "file:///foo/bar.txt"

`Bun.gzipSync()`

Komprimiert ein Uint8Array mit zlib's GZIP-Algorithmus.

const buf = Buffer.from("hello".repeat(100)); // Buffer erweitert Uint8Array
const compressed = Bun.gzipSync(buf);

buf; // => Uint8Array(500)
compressed; // => Uint8Array(30)

Optional können Sie ein Parameter-Objekt als zweites Argument übergeben:

zlib-Komprimierungsoptionen">

export type ZlibCompressionOptions = {
  /**
   * Die zu verwendende Komprimierungsstufe. Muss zwischen `-1` und `9` liegen.
   * - Ein Wert von `-1` verwendet die Standard-Komprimierungsstufe (derzeit `6`)
   * - Ein Wert von `0` bietet keine Komprimierung
   * - Ein Wert von `1` bietet die geringste Komprimierung, schnellste Geschwindigkeit
   * - Ein Wert von `9` bietet die beste Komprimierung, langsamste Geschwindigkeit
   */
  level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * Wie viel Speicher für den internen Komprimierungszustand zugewiesen werden soll.
   *
   * Ein Wert von `1` verwendet minimalen Speicher, ist aber langsam und reduziert das Komprimierungsverhältnis.
   *
   * Ein Wert von `9` verwendet maximalen Speicher für optimale Geschwindigkeit. Der Standardwert ist `8`.
   */
  memLevel?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * Der Basis-2-Logarithmus der Fenstergröße (die Größe des History-Puffers).
   *
   * Größere Werte dieses Parameters führen zu besserer Komprimierung auf Kosten der Speichernutzung.
   *
   * Die folgenden Wertebereiche werden unterstützt:
   * - `9..15`: Die Ausgabe hat einen zlib-Header und -Footer (Deflate)
   * - `-9..-15`: Die Ausgabe hat **keinen** zlib-Header oder -Footer (Raw Deflate)
   * - `25..31` (16+`9..15`): Die Ausgabe hat einen gzip-Header und -Footer (gzip)
   *
   * Der gzip-Header hat keinen Dateinamen, keine zusätzlichen Daten, keinen Kommentar, keine Änderungszeit (auf Null gesetzt) und keine Header-CRC.
   */
  windowBits?:
    | -9
    | -10
    | -11
    | -12
    | -13
    | -14
    | -15
    | 9
    | 10
    | 11
    | 12
    | 13
    | 14
    | 15
    | 25
    | 26
    | 27
    | 28
    | 29
    | 30
    | 31;
  /**
   * Optimiert den Komprimierungsalgorithmus.
   *
   * - `Z_DEFAULT_STRATEGY`: Für normale Daten **(Standard)**
   * - `Z_FILTERED`: Für Daten, die von einem Filter oder Prädiktor erzeugt wurden
   * - `Z_HUFFMAN_ONLY`: Erzwingt nur Huffman-Codierung (kein String-Matching)
   * - `Z_RLE`: Begrenzt Übereinstimmungsabstände auf eins (Run-Length-Encoding)
   * - `Z_FIXED` verhindert die Verwendung dynamischer Huffman-Codes
   *
   * `Z_RLE` ist so konzipiert, dass es fast so schnell wie `Z_HUFFMAN_ONLY` ist, aber eine bessere Komprimierung für PNG-Bilddaten bietet.
   *
   * `Z_FILTERED` erzwingt mehr Huffman-Codierung und weniger String-Matching, es ist
   * gewissermaßen eine Zwischenstufe zwischen `Z_DEFAULT_STRATEGY` und `Z_HUFFMAN_ONLY`.
   * Gefilterte Daten bestehen hauptsächlich aus kleinen Werten mit einer etwas zufälligen Verteilung.
   */
  strategy?: number;
};

`Bun.gunzipSync()`

Dekomprimiert ein Uint8Array mit zlib's GUNZIP-Algorithmus.

const buf = Buffer.from("hello".repeat(100)); // Buffer erweitert Uint8Array
const compressed = Bun.gzipSync(buf);

const dec = new TextDecoder();
const uncompressed = Bun.gunzipSync(compressed);
dec.decode(uncompressed);
// => "hellohellohello..."

`Bun.deflateSync()`

Komprimiert ein Uint8Array mit zlib's DEFLATE-Algorithmus.

const buf = Buffer.from("hello".repeat(100));
const compressed = Bun.deflateSync(buf);

buf; // => Buffer(500)
compressed; // => Uint8Array(12)

Das zweite Argument unterstützt dieselben Konfigurationsoptionen wie Bun.gzipSync.

`Bun.inflateSync()`

Dekomprimiert ein Uint8Array mit zlib's INFLATE-Algorithmus.

const buf = Buffer.from("hello".repeat(100));
const compressed = Bun.deflateSync(buf);

const dec = new TextDecoder();
const decompressed = Bun.inflateSync(compressed);
dec.decode(decompressed);
// => "hellohellohello..."

`Bun.zstdCompress()` / `Bun.zstdCompressSync()`

Komprimiert ein Uint8Array mit dem Zstandard-Algorithmus.

const buf = Buffer.from("hello".repeat(100));

// Synchron
const compressedSync = Bun.zstdCompressSync(buf);
// Asynchron
const compressedAsync = await Bun.zstdCompress(buf);

// Mit Komprimierungsstufe (1-22, Standard: 3)
const compressedLevel = Bun.zstdCompressSync(buf, { level: 6 });

`Bun.zstdDecompress()` / `Bun.zstdDecompressSync()`

Dekomprimiert ein Uint8Array mit dem Zstandard-Algorithmus.

const buf = Buffer.from("hello".repeat(100));
const compressed = Bun.zstdCompressSync(buf);

// Synchron
const decompressedSync = Bun.zstdDecompressSync(compressed);
// Asynchron
const decompressedAsync = await Bun.zstdDecompress(compressed);

const dec = new TextDecoder();
dec.decode(decompressedSync);
// => "hellohellohello..."

`Bun.inspect()`

Serialisiert ein Objekt zu einem string, genau so, wie es von console.log ausgegeben würde.

const obj = { foo: "bar" };
const str = Bun.inspect(obj);
// => '{\nfoo: "bar" \n}'

const arr = new Uint8Array([1, 2, 3]);
const str = Bun.inspect(arr);
// => "Uint8Array(3) [ 1, 2, 3 ]"

`Bun.inspect.custom`

Dies ist das Symbol, das Bun verwendet, um Bun.inspect zu implementieren. Sie können dies überschreiben, um anzupassen, wie Ihre Objekte ausgegeben werden. Es ist identisch mit util.inspect.custom in Node.js.

class Foo {
  [Bun.inspect.custom]() {
    return "foo";
  }
}

const foo = new Foo();
console.log(foo); // => "foo"

`Bun.inspect.table(tabularData, properties, options)`

Formatiert tabellarische Daten in einen String. Wie console.table, außer dass es einen String zurückgibt, anstatt auf die Konsole zu schreiben.

console.log(
  Bun.inspect.table([
    { a: 1, b: 2, c: 3 },
    { a: 4, b: 5, c: 6 },
    { a: 7, b: 8, c: 9 },
  ]),
);
//
// ┌───┬───┬───┬───┐
// │   │ a │ b │ c │
// ├───┼───┼───┼───┤
// │ 0 │ 1 │ 2 │ 3 │
// │ 1 │ 4 │ 5 │ 6 │
// │ 2 │ 7 │ 8 │ 9 │
// └───┴───┴───┴───┘

Zusätzlich können Sie ein Array von Eigenschaftsnamen übergeben, um nur eine Teilmenge von Eigenschaften anzuzeigen.

console.log(
  Bun.inspect.table(
    [
      { a: 1, b: 2, c: 3 },
      { a: 4, b: 5, c: 6 },
    ],
    ["a", "c"],
  ),
);
//
// ┌───┬───┬───┐
// │   │ a │ c │
// ├───┼───┼───┤
// │ 0 │ 1 │ 3 │
// │ 1 │ 4 │ 6 │
// └───┴───┴───┘

Sie können auch ANSI-Farben bedingt aktivieren, indem Sie { colors: true } übergeben.

console.log(
  Bun.inspect.table(
    [
      { a: 1, b: 2, c: 3 },
      { a: 4, b: 5, c: 6 },
    ],
    {
      colors: true,
    },
  ),
);

`Bun.nanoseconds()`

Gibt die Anzahl der Nanosekunden zurück, seit der aktuelle bun-Prozess gestartet wurde, als number. Nützlich für hochpräzise Zeitmessungen und Benchmarking.

Bun.nanoseconds();
// => 7288958

`Bun.readableStreamTo*()`

Bun implementiert eine Reihe von Hilfsfunktionen für den asynchronen Konsum des Body eines ReadableStream und die Konvertierung in verschiedene Binärformate.

const stream = (await fetch("https://bun.com")).body;
stream; // => ReadableStream

await Bun.readableStreamToArrayBuffer(stream);
// => ArrayBuffer

await Bun.readableStreamToBytes(stream);
// => Uint8Array

await Bun.readableStreamToBlob(stream);
// => Blob

await Bun.readableStreamToJSON(stream);
// => Objekt

await Bun.readableStreamToText(stream);
// => String

// gibt alle Chunks als Array zurück
await Bun.readableStreamToArray(stream);
// => unknown[]

// gibt alle Chunks als FormData-Objekt zurück (codiert als x-www-form-urlencoded)
await Bun.readableStreamToFormData(stream);

// gibt alle Chunks als FormData-Objekt zurück (codiert als multipart/form-data)
await Bun.readableStreamToFormData(stream, multipartFormBoundary);

`Bun.resolveSync()`

Löst einen Dateipfad oder Modulspezifizierer mit Bun's internem Modulauflösungsalgorithmus auf. Das erste Argument ist der aufzulösende Pfad, und das zweite Argument ist die "Wurzel". Wenn keine Übereinstimmung gefunden wird, wird ein Error ausgelöst.

Bun.resolveSync("./foo.ts", "/path/to/project");
// => "/path/to/project/foo.ts"

Bun.resolveSync("zod", "/path/to/project");
// => "/path/to/project/node_modules/zod/index.ts"

Um relativ zum aktuellen Arbeitsverzeichnis aufzulösen, übergeben Sie process.cwd() oder "." als Wurzel.

Bun.resolveSync("./foo.ts", process.cwd());
Bun.resolveSync("./foo.ts", "/path/to/project");

Um relativ zum Verzeichnis, das die aktuelle Datei enthält, aufzulösen, übergeben Sie import.meta.dir.

Bun.resolveSync("./foo.ts", import.meta.dir);

`Bun.stripANSI()`

NOTE

~6-57x schnellere `strip-ansi`-Alternative

Bun.stripANSI(text: string): string

Entfernt ANSI-Escape-Codes aus einem String. Dies ist nützlich, um Farben und Formatierungen aus der Terminal-Ausgabe zu entfernen.

const coloredText = "\u001b[31mHello\u001b[0m \u001b[32mWorld\u001b[0m";
const plainText = Bun.stripANSI(coloredText);
console.log(plainText); // => "Hello World"

// Funktioniert mit verschiedenen ANSI-Codes
const formatted = "\u001b[1m\u001b[4mBold and underlined\u001b[0m";
console.log(Bun.stripANSI(formatted)); // => "Bold and underlined"

Bun.stripANSI ist erheblich schneller als das beliebte strip-ansi npm-Paket:

bash

bun bench/snippets/strip-ansi.mjs

txt

cpu: Apple M3 Max
runtime: bun 1.2.21 (arm64-darwin)

benchmark                               avg (min … max) p75 / p99
------------------------------------------------------- ----------
Bun.stripANSI      11 chars no-ansi        8.13 ns/iter   8.27 ns
                                   (7.45 ns … 33.59 ns)  10.29 ns

Bun.stripANSI      13 chars ansi          51.68 ns/iter  52.51 ns
                                 (46.16 ns … 113.71 ns)  57.71 ns

Bun.stripANSI  16,384 chars long-no-ansi 298.39 ns/iter 305.44 ns
                                (281.50 ns … 331.65 ns) 320.70 ns

Bun.stripANSI 212,992 chars long-ansi    227.65 µs/iter 234.50 µs
                                (216.46 µs … 401.92 µs) 262.25 µs

bash

node bench/snippets/strip-ansi.mjs

txt

cpu: Apple M3 Max
runtime: node 24.6.0 (arm64-darwin)

benchmark                                avg (min … max) p75 / p99
-------------------------------------------------------- ---------
npm/strip-ansi      11 chars no-ansi      466.79 ns/iter 468.67 ns
                                 (454.08 ns … 570.67 ns) 543.67 ns

npm/strip-ansi      13 chars ansi         546.77 ns/iter 550.23 ns
                                 (532.74 ns … 651.08 ns) 590.35 ns

npm/strip-ansi  16,384 chars long-no-ansi   4.85 µs/iter   4.89 µs
                                     (4.71 µs … 5.00 µs)   4.98 µs

npm/strip-ansi 212,992 chars long-ansi      1.36 ms/iter   1.38 ms
                                     (1.27 ms … 1.73 ms)   1.49 ms

`serialize` & `deserialize` in `bun:jsc`

Um einen JavaScript-Wert in einen ArrayBuffer zu speichern und zurückzuholen, verwenden Sie serialize und deserialize aus dem "bun:jsc"-Modul.

import { serialize, deserialize } from "bun:jsc";

const buf = serialize({ foo: "bar" });
const obj = deserialize(buf);
console.log(obj); // => { foo: "bar" }

Intern serialisieren und deserialisieren structuredClone und postMessage auf dieselbe Weise. Dies macht den zugrunde liegenden HTML Structured Clone Algorithm für JavaScript als ArrayBuffer zugänglich.

`estimateShallowMemoryUsageOf` in `bun:jsc`

Die estimateShallowMemoryUsageOf-Funktion gibt eine bestmögliche Schätzung der Speichernutzung eines Objekts in Bytes zurück, ohne die Speichernutzung von Eigenschaften oder anderen Objekten, auf die es verweist. Für eine genaue Pro-Objekt-Speichernutzung verwenden Sie Bun.generateHeapSnapshot.

import { estimateShallowMemoryUsageOf } from "bun:jsc";

const obj = { foo: "bar" };
const usage = estimateShallowMemoryUsageOf(obj);
console.log(usage); // => 16

const buffer = Buffer.alloc(1024 * 1024);
estimateShallowMemoryUsageOf(buffer);
// => 1048624

const req = new Request("https://bun.com");
estimateShallowMemoryUsageOf(req);
// => 167

const array = Array(1024).fill({ a: 1 });
// Arrays werden normalerweise nicht zusammenhängend im Speicher gespeichert, daher gibt dies keinen nützlichen Wert zurück (was kein Fehler ist).
estimateShallowMemoryUsageOf(array);
// => 16

Bun.version ​

Bun.revision ​

Bun.env ​

Bun.main ​

Bun.sleep() ​

Bun.sleepSync() ​

Bun.which() ​

Bun.randomUUIDv7() ​

Bun.peek() ​

Bun.openInEditor() ​

Bun.deepEquals() ​

Bun.escapeHTML() ​

Bun.stringWidth() ​

Vollständigen Benchmark anzeigen"> ​

Bun.fileURLToPath() ​

Bun.pathToFileURL() ​

Bun.gzipSync() ​

zlib-Komprimierungsoptionen"> ​

Bun.gunzipSync() ​

Bun.deflateSync() ​

Bun.inflateSync() ​

Bun.zstdCompress() / Bun.zstdCompressSync() ​

Bun.zstdDecompress() / Bun.zstdDecompressSync() ​

Bun.inspect() ​

Bun.inspect.custom ​

Bun.inspect.table(tabularData, properties, options) ​

Bun.nanoseconds() ​

Bun.readableStreamTo*() ​

Bun.resolveSync() ​

Bun.stripANSI() ​

serialize & deserialize in bun:jsc ​

estimateShallowMemoryUsageOf in bun:jsc ​

`Bun.version`

`Bun.revision`

`Bun.env`

`Bun.main`

`Bun.sleep()`

`Bun.sleepSync()`

`Bun.which()`

`Bun.randomUUIDv7()`

`Bun.peek()`

`Bun.openInEditor()`

`Bun.deepEquals()`

`Bun.escapeHTML()`

`Bun.stringWidth()`

Vollständigen Benchmark anzeigen">

`Bun.fileURLToPath()`

`Bun.pathToFileURL()`

`Bun.gzipSync()`

zlib-Komprimierungsoptionen">

`Bun.gunzipSync()`

`Bun.deflateSync()`

`Bun.inflateSync()`

`Bun.zstdCompress()` / `Bun.zstdCompressSync()`

`Bun.zstdDecompress()` / `Bun.zstdDecompressSync()`

`Bun.inspect()`

`Bun.inspect.custom`

`Bun.inspect.table(tabularData, properties, options)`

`Bun.nanoseconds()`

`Bun.readableStreamTo*()`

`Bun.resolveSync()`

`Bun.stripANSI()`

`serialize` & `deserialize` in `bun:jsc`

`estimateShallowMemoryUsageOf` in `bun:jsc`