Utils com Bun JS

`Bun.version`

Uma string contendo a versão do CLI bun que está atualmente em execução.

Bun.version;
// => "1.3.3"

`Bun.revision`

O commit git do Bun que foi compilado para criar o CLI bun atual.

Bun.revision;
// => "f02561530fda1ee9396f51c8bc99b38716e38296"

`Bun.env`

Um alias para process.env.

`Bun.main`

Um caminho absoluto para o entrypoint do programa atual (o arquivo que foi executado com bun run).

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

Isto é particularmente útil para determinar se um script está sendo executado diretamente, em oposição a ser importado por outro script.

if (import.meta.path === Bun.main) {
  // este script está sendo executado diretamente
} else {
  // este arquivo está sendo importado de outro script
}

Isto é análogo ao truque require.main = module no Node.js.

`Bun.sleep()`

Bun.sleep(ms: number)

Retorna uma Promise que resolve após o número especificado de milissegundos.

console.log("hello");
await Bun.sleep(1000);
console.log("hello one second later!");

Alternativamente, passe um objeto Date para receber uma Promise que resolve naquele ponto no tempo.

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

console.log("hello");
await Bun.sleep(oneSecondInFuture);
console.log("hello one second later!");

`Bun.sleepSync()`

Bun.sleepSync(ms: number)

Uma versão síncrona de bloqueio do Bun.sleep.

console.log("hello");
Bun.sleepSync(1000); // bloqueia a thread por um segundo
console.log("hello one second later!");

`Bun.which()`

Bun.which(bin: string)

Retorna o caminho para um executável, similar a digitar which no seu terminal.

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

Por padrão, o Bun olha a variável de ambiente PATH atual para determinar o caminho. Para configurar PATH:

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

Passe uma opção cwd para resolver o executável dentro de um diretório específico.

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

console.log(ls); // null

Você pode pensar nisso como uma alternativa built-in ao pacote npm which.

`Bun.randomUUIDv7()`

Bun.randomUUIDv7() retorna um UUID v7, que é monótono e adequado para ordenação e bancos de dados.

import { randomUUIDv7 } from "bun";

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

Um UUID v7 é um valor de 128 bits que codifica o timestamp atual, um valor aleatório e um contador. O timestamp é codificado usando os 48 bits mais baixos, e o valor aleatório e contador são codificados usando os bits restantes.

O parâmetro timestamp padrão é o tempo atual em milissegundos. Quando o timestamp muda, o contador é resetado para um inteiro pseudo-aleatório limitado a 4096. Este contador é atômico e thread-safe, o que significa que usar Bun.randomUUIDv7() em muitos Workers dentro do mesmo processo rodando no mesmo timestamp não terá valores de contador colidindo.

Os 8 bytes finais do UUID são um valor aleatório criptograficamente seguro. Ele usa o mesmo gerador de números aleatórios usado por crypto.randomUUID() (que vem do BoringSSL, que por sua vez vem do gerador de números aleatórios do sistema específico da plataforma, geralmente fornecido pelo hardware subjacente).

namespace Bun {
  function randomUUIDv7(encoding?: "hex" | "base64" | "base64url" = "hex", timestamp?: number = Date.now()): string;
  /**
   * Se você passar "buffer", você recebe um buffer de 16 bytes em vez de uma string.
   */
  function randomUUIDv7(encoding: "buffer", timestamp?: number = Date.now()): Buffer;

  // Se você passar apenas um timestamp, você recebe uma string hex
  function randomUUIDv7(timestamp?: number = Date.now()): string;
}

Você pode opcionalmente definir encoding como "buffer" para receber um buffer de 16 bytes em vez de uma string. Isto pode às vezes evitar overhead de conversão de string.

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

Encodings base64 e base64url também são suportados quando você quer uma string ligeiramente mais curta.

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

`Bun.peek()`

Bun.peek(prom: Promise)

Lê o resultado de uma promise sem await ou .then, mas apenas se a promise já tiver fulfilled ou rejected.

import { peek } from "bun";

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

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

Isto é importante quando se tenta reduzir o número de microticks extranhos em código sensível a performance. É uma API avançada e você provavelmente não deve usá-la a menos que saiba o que está fazendo.

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

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

  // sem await necessário!
  expect(peek(promise)).toBe(true);

  // se olharmos novamente, retorna o mesmo valor
  const again = peek(promise);
  expect(again).toBe(true);

  // se olharmos uma non-promise, retorna o valor
  const value = peek(42);
  expect(value).toBe(42);

  // se olharmos uma pending promise, retorna a promise novamente
  const pending = new Promise(() => {});
  expect(peek(pending)).toBe(pending);

  // Se olharmos uma rejected promise, ele:
  // - retorna o erro
  // - não marca a promise como handled
  const rejected = Promise.reject(new Error("Successfully tested promise rejection"));
  expect(peek(rejected).message).toBe("Successfully tested promise rejection");
});

A função peek.status permite ler o status de uma promise sem resolvê-la.

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

Abre um arquivo no seu editor padrão. O Bun auto-detecta seu editor via variáveis de ambiente $VISUAL ou $EDITOR.

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

Você pode sobrescrever isto via configuração debug.editor no seu bunfig.toml.

toml

[debug] 
editor = "code"

Ou especifique um editor com o parâmetro editor. Você também pode especificar um número de linha e coluna.

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

`Bun.deepEquals()`

Verifica recursivamente se dois objetos são equivalentes. Isto é usado internamente por expect().toEqual() em 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 } });

Um terceiro parâmetro booleano pode ser usado para habilitar o modo "strict". Isto é usado por expect().toStrictEqual() no test runner.

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

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

No modo strict, os seguintes são considerados desiguais:

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

// undefined em arrays
Bun.deepEquals(["asdf"], ["asdf", undefined], true); // false

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

// object literals vs instances com mesmas propriedades
class Foo {
  a = 1;
}
Bun.deepEquals(new Foo(), { a: 1 }, true); // false

`Bun.escapeHTML()`

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

Escapa os seguintes caracteres de uma string de input:

" se torna "
& se torna &
' se torna '
< se torna <
> se torna >

Esta função é otimizada para input grande. Em um M1X, ela processa 480 MB/s - 20 GB/s, dependendo de quantos dados estão sendo escapados e se há texto non-ascii. Tipos non-string serão convertidos para string antes de escapar.

`Bun.stringWidth()`

NOTE

Alternativa ~6,756x mais rápida que `string-width`

Obtém a contagem de colunas de uma string como ela seria exibida em um terminal. Suporta códigos de escape ANSI, emoji e caracteres largos.

Exemplo de uso:

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

Isto é útil para:

Alinhar texto em um terminal
Verificar rapidamente se uma string contém códigos de escape ANSI
Medir a largura de uma string em um terminal

Esta API é projetada para corresponder ao popular pacote "string-width", para que código existente possa ser facilmente portado para o Bun e vice-versa.

Neste benchmark, Bun.stringWidth é ~6,756x mais rápido que o pacote npm string-width para input maior que cerca de 500 caracteres. Grandes agradecimentos a sindresorhus por seu trabalho no 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

Para tornar Bun.stringWidth rápido, implementamos em Zig usando instruções SIMD otimizadas, considerando encodings Latin1, UTF-16 e UTF-8. Ele passa nos testes do string-width.

Ver benchmark completo">

Como lembrete, 1 nanosegundo (ns) é 1 bilionésimo de segundo. Aqui está uma referência rápida para converter entre unidades:

Unidade	1 Milissegundo
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

Definição TypeScript:

namespace Bun {
  export function stringWidth(
    /**
     * A string para medir
     */
    input: string,
    options?: {
      /**
       * Se `true`, conta códigos de escape ANSI como parte da largura da string. Se `false`, códigos de escape ANSI são ignorados ao calcular a largura da string.
       *
       * @default false
       */
      countAnsiEscapeCodes?: boolean;
      /**
       * Quando é ambíguo e `true`, conta emoji como 1 caractere de largura. Se `false`, emoji são contados como 2 caracteres de largura.
       *
       * @default true
       */
      ambiguousIsNarrow?: boolean;
    },
  ): number;
}

`Bun.fileURLToPath()`

Converte uma URL file:// para um caminho absoluto.

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

`Bun.pathToFileURL()`

Converte um caminho absoluto para uma URL file://.

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

`Bun.gzipSync()`

Comprime um Uint8Array usando o algoritmo GZIP do zlib.

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

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

Opcionalmente, passe um objeto de parâmetros como segundo argumento:

Opções de compressão zlib">

export type ZlibCompressionOptions = {
  /**
   * O nível de compressão para usar. Deve estar entre `-1` e `9`.
   * - Um valor de `-1` usa o nível de compressão padrão (Atualmente `6`)
   * - Um valor de `0` não dá compressão
   * - Um valor de `1` dá menos compressão, velocidade mais rápida
   * - Um valor de `9` dá melhor compressão, velocidade mais lenta
   */
  level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * Quanta memória deve ser alocada para o estado interno de compressão.
   *
   * Um valor de `1` usa memória mínima mas é lento e reduz a taxa de compressão.
   *
   * Um valor de `9` usa memória máxima para velocidade ótima. O padrão é `8`.
   */
  memLevel?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * O logaritmo base 2 do tamanho da janela (o tamanho do buffer de histórico).
   *
   * Valores maiores deste parâmetro resultam em melhor compressão às custas de uso de memória.
   *
   * Os seguintes ranges de valor são suportados:
   * - `9..15`: A saída terá um header e footer zlib (Deflate)
   * - `-9..-15`: A saída **não** terá um header ou footer zlib (Raw Deflate)
   * - `25..31` (16+`9..15`): A saída terá um header e footer gzip (gzip)
   *
   * O header gzip não terá nome de arquivo, nenhum dado extra, nenhum comentário, nenhum tempo de modificação (definido como zero) e nenhum CRC de header.
   */
  windowBits?:
    | -9
    | -10
    | -11
    | -12
    | -13
    | -14
    | -15
    | 9
    | 10
    | 11
    | 12
    | 13
    | 14
    | 15
    | 25
    | 26
    | 27
    | 28
    | 29
    | 30
    | 31;
  /**
   * Ajusta o algoritmo de compressão.
   *
   * - `Z_DEFAULT_STRATEGY`: Para dados normais **(Padrão)**
   * - `Z_FILTERED`: Para dados produzidos por um filtro ou preditor
   * - `Z_HUFFMAN_ONLY`: Força encoding Huffman apenas (sem match de string)
   * - `Z_RLE`: Limita distâncias de match a um (run-length encoding)
   * - `Z_FIXED` previne o uso de códigos Huffman dinâmicos
   *
   * `Z_RLE` é projetado para ser quase tão rápido quanto `Z_HUFFMAN_ONLY`, mas dá melhor compressão para dados de imagem PNG.
   *
   * `Z_FILTERED` força mais encoding Huffman e menos string matching, é
   * um pouco intermediário entre `Z_DEFAULT_STRATEGY` e `Z_HUFFMAN_ONLY`.
   * Dados filtrados consistem principalmente de valores pequenos com uma distribuição um tanto aleatória.
   */
  strategy?: number;
};

`Bun.gunzipSync()`

Descomprime um Uint8Array usando o algoritmo GUNZIP do zlib.

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

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

`Bun.deflateSync()`

Comprime um Uint8Array usando o algoritmo DEFLATE do zlib.

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

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

O segundo argumento suporta o mesmo conjunto de opções de configuração que Bun.gzipSync.

`Bun.inflateSync()`

Descomprime um Uint8Array usando o algoritmo INFLATE do 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()`

Comprime um Uint8Array usando o algoritmo Zstandard.

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

// Síncrono
const compressedSync = Bun.zstdCompressSync(buf);
// Assíncrono
const compressedAsync = await Bun.zstdCompress(buf);

// Com nível de compressão (1-22, padrão: 3)
const compressedLevel = Bun.zstdCompressSync(buf, { level: 6 });

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

Descomprime um Uint8Array usando o algoritmo Zstandard.

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

// Síncrono
const decompressedSync = Bun.zstdDecompressSync(compressed);
// Assíncrono
const decompressedAsync = await Bun.zstdDecompress(compressed);

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

`Bun.inspect()`

Serializa um objeto para uma string exatamente como seria impresso por 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`

Este é o símbolo que o Bun usa para implementar Bun.inspect. Você pode sobrescrever isto para personalizar como seus objetos são impressos. É idêntico a util.inspect.custom no Node.js.

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

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

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

Formata dados tabulares em uma string. Como console.table, exceto que retorna uma string em vez de imprimir no 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 │
// └───┴───┴───┴───┘

Adicionalmente, você pode passar um array de nomes de propriedade para exibir apenas um subconjunto de propriedades.

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

Você também pode condicionalmente habilitar cores ANSI passando { colors: true }.

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

`Bun.nanoseconds()`

Retorna o número de nanosegundos desde que o processo bun atual iniciou, como um number. Útil para timing e benchmarking de alta precisão.

Bun.nanoseconds();
// => 7288958

`Bun.readableStreamTo*()`

O Bun implementa um conjunto de funções de conveniência para consumir assincronamente o body de um ReadableStream e convertê-lo para vários formatos binários.

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

// retorna todos os chunks como um array
await Bun.readableStreamToArray(stream);
// => unknown[]

// retorna todos os chunks como um objeto FormData (encoded como x-www-form-urlencoded)
await Bun.readableStreamToFormData(stream);

// retorna todos os chunks como um objeto FormData (encoded como multipart/form-data)
await Bun.readableStreamToFormData(stream, multipartFormBoundary);

`Bun.resolveSync()`

Resolve um caminho de arquivo ou module specifier usando o algoritmo interno de module resolution do Bun. O primeiro argumento é o caminho para resolver, e o segundo argumento é a "root". Se nenhum match for encontrado, um Error é lançado.

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"

Para resolver relativo ao diretório de trabalho atual, passe process.cwd() ou "." como root.

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

Para resolver relativo ao diretório contendo o arquivo atual, passe import.meta.dir.

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

`Bun.stripANSI()`

NOTE

Alternativa ~6-57x mais rápida que `strip-ansi`

Bun.stripANSI(text: string): string

Remove códigos de escape ANSI de uma string. Isto é útil para remover cores e formatação de saída de terminal.

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

// Funciona com vários códigos ANSI
const formatted = "\u001b[1m\u001b[4mBold and underlined\u001b[0m";
console.log(Bun.stripANSI(formatted)); // => "Bold and underlined"

Bun.stripANSI é significativamente mais rápido que o popular pacote npm 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` em `bun:jsc`

Para salvar um valor JavaScript em um ArrayBuffer e voltar, use serialize e deserialize do módulo "bun:jsc".

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

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

Internamente, structuredClone e postMessage serializam e desserializam da mesma forma. Isto expõe o algoritmo HTML Structured Clone Algorithm subjacente para JavaScript como um ArrayBuffer.

`estimateShallowMemoryUsageOf` em `bun:jsc`

A função estimateShallowMemoryUsageOf retorna uma estimativa de melhor esforço do uso de memória de um objeto em bytes, excluindo o uso de memória de propriedades ou outros objetos que referencia. Para uso preciso de memória por objeto, use 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 geralmente não são armazenados de forma contígua na memória, então isto não retornará um valor útil (o que não é um 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() ​

Ver benchmark completo"> ​

Bun.fileURLToPath() ​

Bun.pathToFileURL() ​

Bun.gzipSync() ​

Opções de compressão 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 em bun:jsc ​

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

Ver benchmark completo">

`Bun.fileURLToPath()`

`Bun.pathToFileURL()`

`Bun.gzipSync()`

Opções de compressão 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` em `bun:jsc`

`estimateShallowMemoryUsageOf` em `bun:jsc`