Utilitaires avec Bun JS

`Bun.version`

Une string contenant la version de la CLI bun qui est actuellement en cours d'exécution.

Bun.version;
// => "1.3.3"

`Bun.revision`

Le commit git de Bun qui a été compilé pour créer la CLI bun actuelle.

Bun.revision;
// => "f02561530fda1ee9396f51c8bc99b38716e38296"

`Bun.env`

Un alias pour process.env.

`Bun.main`

Un chemin absolu vers le point d'entrée du programme actuel (le fichier qui a été exécuté avec bun run).

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

Ceci est particulièrement utile pour déterminer si un script est exécuté directement, par opposition à être importé par un autre script.

if (import.meta.path === Bun.main) {
  // ce script est exécuté directement
} else {
  // ce fichier est importé depuis un autre script
}

Ceci est analogue à l'astuce require.main = module dans Node.js.

`Bun.sleep()`

Bun.sleep(ms: number)

Retourne une Promise qui se résout après le nombre de millisecondes donné.

console.log("hello");
await Bun.sleep(1000);
console.log("hello une seconde plus tard !");

Alternativement, passez un objet Date pour recevoir une Promise qui se résout à ce moment précis.

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

console.log("hello");
await Bun.sleep(oneSecondInFuture);
console.log("hello une seconde plus tard !");

`Bun.sleepSync()`

Bun.sleepSync(ms: number)

Une version synchrone bloquante de Bun.sleep.

console.log("hello");
Bun.sleepSync(1000); // bloque le thread pendant une seconde
console.log("hello une seconde plus tard !");

`Bun.which()`

Bun.which(bin: string)

Retourne le chemin vers un exécutable, similaire à la saisie de which dans votre terminal.

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

Par défaut, Bun examine la variable d'environnement PATH actuelle pour déterminer le chemin. Pour configurer PATH :

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

Passez une option cwd pour résoudre l'exécutable depuis un répertoire spécifique.

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

console.log(ls); // null

Vous pouvez considérer cela comme une alternative intégrée au package npm which.

`Bun.randomUUIDv7()`

Bun.randomUUIDv7() retourne un UUID v7, qui est monotone et adapté au tri et aux bases de données.

import { randomUUIDv7 } from "bun";

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

Un UUID v7 est une valeur de 128 bits qui encode l'horodatage actuel, une valeur aléatoire et un compteur. L'horodatage est encodé en utilisant les 48 bits les plus bas, et la valeur aléatoire et le compteur sont encodés en utilisant les bits restants.

Le paramètre timestamp par défaut à l'heure actuelle en millisecondes. Lorsque l'horodatage change, le compteur est réinitialisé à un entier pseudo-aléatoire limité à 4096. Ce compteur est atomique et thread-safe, ce qui signifie que l'utilisation de Bun.randomUUIDv7() dans plusieurs Workers au sein du même processus s'exécutant au même horodatage n'aura pas de valeurs de compteur en collision.

Les 8 octets finaux de l'UUID sont une valeur aléatoire cryptographiquement sécurisée. Il utilise le même générateur de nombres aléatoires que crypto.randomUUID() (qui provient de BoringSSL, qui à son tour provient du générateur de nombres aléatoires du système spécifique à la plateforme généralement fourni par le matériel sous-jacent).

namespace Bun {
  function randomUUIDv7(encoding?: "hex" | "base64" | "base64url" = "hex", timestamp?: number = Date.now()): string;
  /**
   * Si vous passez "buffer", vous obtenez un tampon de 16 octets au lieu d'une string.
   */
  function randomUUIDv7(encoding: "buffer", timestamp?: number = Date.now()): Buffer;

  // Si vous passez uniquement un horodatage, vous obtenez une string hexadécimale
  function randomUUIDv7(timestamp?: number = Date.now()): string;
}

Vous pouvez éventuellement définir l'encodage sur "buffer" pour obtenir un tampon de 16 octets au lieu d'une string. Cela peut parfois éviter les frais de conversion de string.

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

Les encodages base64 et base64url sont également pris en charge lorsque vous souhaitez une string légèrement plus courte.

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

`Bun.peek()`

Bun.peek(prom: Promise)

Lit le résultat d'une promesse sans await ni .then, mais uniquement si la promesse a déjà été remplie ou rejetée.

import { peek } from "bun";

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

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

Ceci est important lorsque vous essayez de réduire le nombre de micro-ticks inutiles dans du code sensible aux performances. C'est une API avancée et vous ne devriez probablement pas l'utiliser sauf si vous savez ce que vous faites.

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

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

  // pas de await nécessaire !
  expect(peek(promise)).toBe(true);

  // si on peek à nouveau, cela retourne la même valeur
  const again = peek(promise);
  expect(again).toBe(true);

  // si on peek une non-promesse, cela retourne la valeur
  const value = peek(42);
  expect(value).toBe(42);

  // si on peek une promesse en attente, cela retourne à nouveau la promesse
  const pending = new Promise(() => {});
  expect(peek(pending)).toBe(pending);

  // Si on peek une promesse rejetée, cela :
  // - retourne l'erreur
  // - ne marque pas la promesse comme gérée
  const rejected = Promise.reject(new Error("Successfully tested promise rejection"));
  expect(peek(rejected).message).toBe("Successfully tested promise rejection");
});

La fonction peek.status vous permet de lire le statut d'une promesse sans la résoudre.

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 nooo"));
  expect(peek.status(rejected)).toBe("rejected");
});

`Bun.openInEditor()`

Ouvre un fichier dans votre éditeur par défaut. Bun détecte automatiquement votre éditeur via les variables d'environnement $VISUAL ou $EDITOR.

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

Vous pouvez remplacer cela via le paramètre debug.editor dans votre bunfig.toml.

toml

[debug] 
editor = "code"

Ou spécifiez un éditeur avec le paramètre editor. Vous pouvez également spécifier un numéro de ligne et de colonne.

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

`Bun.deepEquals()`

Vérifie récursivement si deux objets sont équivalents. Ceci est utilisé en interne par expect().toEqual() dans bun:test.

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 } });

Un troisième paramètre booléen peut être utilisé pour activer le mode "strict". Ceci est utilisé par expect().toStrictEqual() dans le runner de tests.

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

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

En mode strict, les éléments suivants sont considérés comme inégaux :

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

// undefined dans les tableaux
Bun.deepEquals(["asdf"], ["asdf", undefined], true); // false

// tableaux clairsemés
Bun.deepEquals([, 1], [undefined, 1], true); // false

// littéraux d'objet vs instances avec les mêmes propriétés
class Foo {
  a = 1;
}
Bun.deepEquals(new Foo(), { a: 1 }, true); // false

`Bun.escapeHTML()`

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

Échappe les caractères suivants d'une string d'entrée :

" devient "
& devient &
' devient '
< devient <
> devient >

Cette fonction est optimisée pour les grandes entrées. Sur un M1X, elle traite 480 Mo/s - 20 Go/s, selon la quantité de données à échapper et s'il y a du texte non-ascii. Les types non-string seront convertis en string avant l'échappement.

`Bun.stringWidth()`

NOTE

Alternative à `string-width` ~6 756x plus rapide

Obtient le nombre de colonnes d'une string telle qu'elle serait affichée dans un terminal. Prend en charge les codes d'échappement ANSI, les emoji et les caractères larges.

Exemple d'utilisation :

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

Ceci est utile pour :

Aligner le texte dans un terminal
Vérifier rapidement si une string contient des codes d'échappement ANSI
Mesurer la largeur d'une string dans un terminal

Cette API est conçue pour correspondre au package populaire "string-width", afin que le code existant puisse être facilement porté vers Bun et vice versa.

Dans ce benchmark, Bun.stringWidth est ~6 756x plus rapide que le package npm string-width pour des entrées supérieures à environ 500 caractères. Un grand merci à sindresorhus pour son travail sur 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

Pour rendre Bun.stringWidth rapide, nous l'avons implémenté en Zig en utilisant des instructions SIMD optimisées, en tenant compte des encodages Latin1, UTF-16 et UTF-8. Il passe les tests de string-width.

Voir le benchmark complet

Pour rappel, 1 nanoseconde (ns) représente 1 milliardième de seconde. Voici une référence rapide pour convertir entre les unités :

Unité	1 Milliseconde
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

Définition TypeScript :

namespace Bun {
  export function stringWidth(
    /**
     * La string à mesurer
     */
    input: string,
    options?: {
      /**
       * Si `true`, compte les codes d'échappement ANSI comme faisant partie de la largeur de la string. Si `false`, les codes d'échappement ANSI sont ignorés lors du calcul de la largeur de la string.
       *
       * @default false
       */
      countAnsiEscapeCodes?: boolean;
      /**
       * Quand c'est ambigu et `true`, compte les emoji comme 1 caractère de large. Si `false`, les emoji sont comptés comme 2 caractères de large.
       *
       * @default true
       */
      ambiguousIsNarrow?: boolean;
    },
  ): number;
}

`Bun.fileURLToPath()`

Convertit une URL file:// en un chemin absolu.

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

`Bun.pathToFileURL()`

Convertit un chemin absolu en une URL file://.

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

`Bun.gzipSync()`

Compresse une Uint8Array en utilisant l'algorithme GZIP de zlib.

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

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

Éventuellement, passez un objet de paramètres comme deuxième argument :

Options de compression zlib

export type ZlibCompressionOptions = {
  /**
   * Le niveau de compression à utiliser. Doit être entre `-1` et `9`.
   * - Une valeur de `-1` utilise le niveau de compression par défaut (actuellement `6`)
   * - Une valeur de `0` ne donne aucune compression
   * - Une valeur de `1` donne le moins de compression, vitesse la plus rapide
   * - Une valeur de `9` donne la meilleure compression, vitesse la plus lente
   */
  level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * Combien de mémoire doit être allouée pour l'état de compression interne.
   *
   * Une valeur de `1` utilise le minimum de mémoire mais est lente et réduit le taux de compression.
   *
   * Une valeur de `9` utilise le maximum de mémoire pour une vitesse optimale. La valeur par défaut est `8`.
   */
  memLevel?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * Le logarithme en base 2 de la taille de la fenêtre (la taille du tampon d'historique).
   *
   * Des valeurs plus grandes de ce paramètre entraînent une meilleure compression au détriment de l'utilisation de la mémoire.
   *
   * Les plages de valeurs suivantes sont prises en charge :
   * - `9..15`: La sortie aura un en-tête et un pied de page zlib (Deflate)
   * - `-9..-15`: La sortie n'aura **pas** d'en-tête ou de pied de page zlib (Deflate brut)
   * - `25..31` (16+`9..15`): La sortie aura un en-tête et un pied de page gzip (gzip)
   *
   * L'en-tête gzip n'aura pas de nom de fichier, pas de données supplémentaires, pas de commentaire, pas de temps de modification (défini à zéro) et pas de CRC d'en-tête.
   */
  windowBits?:
    | -9
    | -10
    | -11
    | -12
    | -13
    | -14
    | -15
    | 9
    | 10
    | 11
    | 12
    | 13
    | 14
    | 15
    | 25
    | 26
    | 27
    | 28
    | 29
    | 30
    | 31;
  /**
   * Ajuste l'algorithme de compression.
   *
   * - `Z_DEFAULT_STRATEGY`: Pour les données normales **(par défaut)**
   * - `Z_FILTERED`: Pour les données produites par un filtre ou un prédicteur
   * - `Z_HUFFMAN_ONLY`: Force uniquement l'encodage Huffman (pas de correspondance de string)
   * - `Z_RLE`: Limite les distances de correspondance à un (encodage par longueur d'exécution)
   * - `Z_FIXED` empêche l'utilisation de codes Huffman dynamiques
   *
   * `Z_RLE` est conçu pour être presque aussi rapide que `Z_HUFFMAN_ONLY`, mais donne une meilleure compression pour les données d'image PNG.
   *
   * `Z_FILTERED` force plus de codage Huffman et moins de correspondance de string, il est quelque peu intermédiaire entre `Z_DEFAULT_STRATEGY` et `Z_HUFFMAN_ONLY`.
   * Les données filtrées consistent principalement en de petites valeurs avec une distribution quelque peu aléatoire.
   */
  strategy?: number;
};

`Bun.gunzipSync()`

Décompresse une Uint8Array en utilisant l'algorithme GUNZIP de zlib.

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

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

`Bun.deflateSync()`

Compresse une Uint8Array en utilisant l'algorithme DEFLATE de zlib.

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

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

Le deuxième argument prend en charge le même ensemble d'options de configuration que Bun.gzipSync.

`Bun.inflateSync()`

Décompresse une Uint8Array en utilisant l'algorithme INFLATE de zlib.

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()`

Compresse une Uint8Array en utilisant l'algorithme Zstandard.

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

// Synchrone
const compressedSync = Bun.zstdCompressSync(buf);
// Asynchrone
const compressedAsync = await Bun.zstdCompress(buf);

// Avec niveau de compression (1-22, par défaut : 3)
const compressedLevel = Bun.zstdCompressSync(buf, { level: 6 });

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

Décompresse une Uint8Array en utilisant l'algorithme Zstandard.

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

// Synchrone
const decompressedSync = Bun.zstdDecompressSync(compressed);
// Asynchrone
const decompressedAsync = await Bun.zstdDecompress(compressed);

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

`Bun.inspect()`

Sérialise un objet en une string exactement comme il serait imprimé par console.log.

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`

Ceci est le symbole que Bun utilise pour implémenter Bun.inspect. Vous pouvez le remplacer pour personnaliser la façon dont vos objets sont imprimés. Il est identique à util.inspect.custom dans Node.js.

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

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

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

Formate des données tabulaires en une string. Comme console.table, sauf qu'il retourne une string au lieu d'imprimer dans la console.

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 │
// └───┴───┴───┴───┘

De plus, vous pouvez passer un tableau de noms de propriétés pour afficher uniquement un sous-ensemble de propriétés.

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 │
// └───┴───┴───┘

Vous pouvez également activer conditionnellement les couleurs ANSI en passant { colors: true }.

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

`Bun.nanoseconds()`

Retourne le nombre de nanosecondes depuis le démarrage du processus bun actuel, sous forme de number. Utile pour le chronométrage de haute précision et le benchmarking.

Bun.nanoseconds();
// => 7288958

`Bun.readableStreamTo*()`

Bun implémente un ensemble de fonctions utilitaires pour consommer de manière asynchrone le corps d'un ReadableStream et le convertir en différents formats binaires.

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);
// => object

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

// retourne tous les chunks sous forme de tableau
await Bun.readableStreamToArray(stream);
// => unknown[]

// retourne tous les chunks sous forme d'objet FormData (encodé en x-www-form-urlencoded)
await Bun.readableStreamToFormData(stream);

// retourne tous les chunks sous forme d'objet FormData (encodé en multipart/form-data)
await Bun.readableStreamToFormData(stream, multipartFormBoundary);

`Bun.resolveSync()`

Résout un chemin de fichier ou un spécificateur de module en utilisant l'algorithme de résolution de module interne de Bun. Le premier argument est le chemin à résoudre, et le deuxième argument est la "racine". Si aucune correspondance n'est trouvée, une Error est lancée.

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"

Pour résoudre par rapport au répertoire de travail actuel, passez process.cwd() ou "." comme racine.

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

Pour résoudre par rapport au répertoire contenant le fichier actuel, passez import.meta.dir.

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

`Bun.stripANSI()`

NOTE

Alternative à `strip-ansi` ~6-57x plus rapide

Bun.stripANSI(text: string): string

Supprime les codes d'échappement ANSI d'une string. Ceci est utile pour supprimer les couleurs et le formatage de la sortie du terminal.

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

// Fonctionne avec différents codes ANSI
const formatted = "\u001b[1m\u001b[4mBold and underlined\u001b[0m";
console.log(Bun.stripANSI(formatted)); // => "Bold and underlined"

Bun.stripANSI est considérablement plus rapide que le package npm populaire strip-ansi :

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` dans `bun:jsc`

Pour enregistrer une valeur JavaScript dans un ArrayBuffer et la récupérer, utilisez serialize et deserialize du module "bun:jsc".

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

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

En interne, structuredClone et postMessage sérialisent et désérialisent de la même manière. Cela expose l'algorithme de clonage structuré HTML sous-jacent à JavaScript sous forme d'ArrayBuffer.

`estimateShallowMemoryUsageOf` dans `bun:jsc`

La fonction estimateShallowMemoryUsageOf retourne une estimation de l'utilisation de la mémoire d'un objet en octets, excluant l'utilisation de la mémoire des propriétés ou d'autres objets auxquels il fait référence. Pour une utilisation précise de la mémoire par objet, utilisez 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 });
// Les tableaux ne sont généralement pas stockés de manière contiguë en mémoire, donc cela ne retournera pas une valeur utile (ce qui n'est pas un bug).
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() ​

Voir le benchmark complet ​

Bun.fileURLToPath() ​

Bun.pathToFileURL() ​

Bun.gzipSync() ​

Options de compression zlib ​

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 dans bun:jsc ​

estimateShallowMemoryUsageOf dans 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()`

Voir le benchmark complet

`Bun.fileURLToPath()`

`Bun.pathToFileURL()`

`Bun.gzipSync()`

Options de compression zlib

`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` dans `bun:jsc`

`estimateShallowMemoryUsageOf` dans `bun:jsc`