Utils con Bun JS

`Bun.version`

Una string que contiene la versión del CLI bun que se está ejecutando actualmente.

Bun.version;
// => "1.3.3"

`Bun.revision`

El commit de git de Bun que se compiló para crear el CLI bun actual.

Bun.revision;
// => "f02561530fda1ee9396f51c8bc99b38716e38296"

`Bun.env`

Un alias para process.env.

`Bun.main`

Una ruta absoluta al punto de entrada del programa actual (el archivo que se ejecutó con bun run).

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

Esto es particularmente útil para determinar si un script se está ejecutando directamente, en lugar de ser importado por otro script.

if (import.meta.path === Bun.main) {
  // este script se está ejecutando directamente
} else {
  // este archivo se está importando desde otro script
}

Esto es análogo al truco require.main = module en Node.js.

`Bun.sleep()`

Bun.sleep(ms: number)

Devuelve una Promise que se resuelve después del número dado de milisegundos.

console.log("hola");
await Bun.sleep(1000);
console.log("¡hola un segundo después!");

Alternativamente, pasa un objeto Date para recibir una Promise que se resuelve en ese momento.

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

console.log("hola");
await Bun.sleep(unSegundoEnElFuturo);
console.log("¡hola un segundo después!");

`Bun.sleepSync()`

Bun.sleepSync(ms: number)

Una versión sincrónica de bloqueo de Bun.sleep.

console.log("hola");
Bun.sleepSync(1000); // bloquea el hilo durante un segundo
console.log("¡hola un segundo después!");

`Bun.which()`

Bun.which(bin: string)

Devuelve la ruta a un ejecutable, similar a escribir which en tu terminal.

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

Por defecto, Bun busca en la variable de entorno PATH actual para determinar la ruta. Para configurar PATH:

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

Pasa una opción cwd para resolver el ejecutable desde un directorio específico.

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

console.log(ls); // null

Puedes pensar en esto como una alternativa integrada al paquete npm which.

`Bun.randomUUIDv7()`

Bun.randomUUIDv7() devuelve un UUID v7, que es monótono y adecuado para ordenar y bases de datos.

import { randomUUIDv7 } from "bun";

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

Un UUID v7 es un valor de 128 bits que codifica la marca de tiempo actual, un valor aleatorio y un contador. La marca de tiempo se codifica usando los 48 bits más bajos, y el valor aleatorio y el contador se codifican usando los bits restantes.

El parámetro timestamp por defecto es la hora actual en milisegundos. Cuando la marca de tiempo cambia, el contador se restablece a un entero pseudoaleatorio envuelto a 4096. Este contador es atómico y seguro para hilos, lo que significa que usar Bun.randomUUIDv7() en muchos Workers dentro del mismo proceso ejecutándose en la misma marca de tiempo no tendrá valores de contador en colisión.

Los 8 bytes finales del UUID son un valor aleatorio criptográficamente seguro. Usa el mismo generador de números aleatorios usado por crypto.randomUUID() (que viene de BoringSSL, que a su vez viene del generador de números aleatorios del sistema específico de la plataforma, generalmente proporcionado por el hardware subyacente).

namespace Bun {
  function randomUUIDv7(encoding?: "hex" | "base64" | "base64url" = "hex", timestamp?: number = Date.now()): string;
  /**
   * Si pasas "buffer", obtienes un búfer de 16 bytes en lugar de una cadena.
   */
  function randomUUIDv7(encoding: "buffer", timestamp?: number = Date.now()): Buffer;

  // Si solo pasas una marca de tiempo, obtienes una cadena hex
  function randomUUIDv7(timestamp?: number = Date.now()): string;
}

Opcionalmente puedes establecer la codificación en "buffer" para obtener un búfer de 16 bytes en lugar de una cadena. Esto a veces puede evitar la sobrecarga de conversión de cadenas.

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

Las codificaciones base64 y base64url también se soportan cuando quieres una cadena ligeramente más corta.

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

`Bun.peek()`

Bun.peek(prom: Promise)

Lee el resultado de una promesa sin await o .then, pero solo si la promesa ya se cumplió o rechazó.

import { peek } from "bun";

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

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

Esto es importante cuando intentas reducir el número de microticks extraños en código sensible al rendimiento. Es una API avanzada y probablemente no deberías usarla a menos que sepas lo que estás haciendo.

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

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

  // ¡no es necesario await!
  expect(peek(promise)).toBe(true);

  // si miramos de nuevo, devuelve el mismo valor
  const again = peek(promise);
  expect(again).toBe(true);

  // si miramos una no-promesa, devuelve el valor
  const value = peek(42);
  expect(value).toBe(42);

  // si miramos una promesa pendiente, devuelve la promesa de nuevo
  const pending = new Promise(() => {});
  expect(peek(pending)).toBe(pending);

  // Si miramos una promesa rechazada:
  // - devuelve el error
  // - no marca la promesa como manejada
  const rejected = Promise.reject(new Error("Se probó exitosamente el rechazo de promesa"));
  expect(peek(rejected).message).toBe("Se probó exitosamente el rechazo de promesa");
});

La función peek.status te permite leer el estado de una promesa sin resolverla.

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 un archivo en tu editor predeterminado. Bun detecta automáticamente tu editor a través de las variables de entorno $VISUAL o $EDITOR.

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

Puedes anular esto a través de la configuración debug.editor en tu bunfig.toml.

toml

[debug] 
editor = "code"

O especifica un editor con el parámetro editor. También puedes especificar un número de línea y columna.

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

`Bun.deepEquals()`

Comprueba recursivamente si dos objetos son equivalentes. Esto se usa internamente por expect().toEqual() en 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 tercer parámetro booleano se puede usar para habilitar el modo "estricto". Esto es usado por expect().toStrictEqual() en el runner de pruebas.

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

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

En modo estricto, los siguientes se consideran desiguales:

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

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

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

// literales de objeto vs instancias con mismas propiedades
class Foo {
  a = 1;
}
Bun.deepEquals(new Foo(), { a: 1 }, true); // false

`Bun.escapeHTML()`

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

Escapa los siguientes caracteres de una cadena de entrada:

" se convierte en "
& se convierte en &
' se convierte en '
< se convierte en <
> se convierte en >

Esta función está optimizada para entradas grandes. En un M1X, procesa 480 MB/s - 20 GB/s, dependiendo de cuántos datos se están escapando y si hay texto no ASCII. Los tipos que no son cadena se convertirán a una cadena antes de escapar.

`Bun.stringWidth()`

NOTE

Alternativa ~6,756x más rápida a `string-width`

Obtiene el conteo de columnas de una cadena como se mostraría en una terminal. Soporta códigos de escape ANSI, emoji y caracteres anchos.

Ejemplo de uso:

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

Esto es útil para:

Alinear texto en una terminal
Verificar rápidamente si una cadena contiene códigos de escape ANSI
Medir el ancho de una cadena en una terminal

Esta API está diseñada para coincidir con el popular paquete "string-width", para que el código existente se pueda portar fácilmente a Bun y viceversa.

En este benchmark, Bun.stringWidth es ~6,756x más rápido que el paquete npm string-width para entradas mayores a unos 500 caracteres. ¡Grandes gracias a sindresorhus por su trabajo en string-width!

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     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 hacer Bun.stringWidth rápido, lo hemos implementado en Zig usando instrucciones SIMD optimizadas, teniendo en cuenta las codificaciones Latin1, UTF-16 y UTF-8. Pasa las pruebas de string-width.

Ver benchmark completo

Como recordatorio, 1 nanosegundo (ns) es la milmillonésima parte de un segundo. Aquí hay una referencia rápida para convertir entre unidades:

Unidad	1 Milisegundo
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

Definición de TypeScript:

namespace Bun {
  export function stringWidth(
    /**
     * La cadena a medir
     */
    input: string,
    options?: {
      /**
       * Si `true`, cuenta los códigos de escape ANSI como parte del ancho de la cadena. Si `false`, los códigos de escape ANSI se ignoran al calcular el ancho de la cadena.
       *
       * @default false
       */
      countAnsiEscapeCodes?: boolean;
      /**
       * Cuando es ambiguo y `true`, cuenta emoji como 1 carácter de ancho. Si `false`, emoji se cuentan como 2 caracteres de ancho.
       *
       * @default true
       */
      ambiguousIsNarrow?: boolean;
    },
  ): number;
}

`Bun.fileURLToPath()`

Convierte una URL file:// a una ruta absoluta.

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

`Bun.pathToFileURL()`

Convierte una ruta absoluta a una URL file://.

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

`Bun.gzipSync()`

Comprime un Uint8Array usando el algoritmo GZIP de zlib.

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

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

Opcionalmente, pasa un objeto de parámetros como segundo argumento:

Opciones de compresión zlib

export type ZlibCompressionOptions = {
  /**
   * El nivel de compresión a usar. Debe estar entre `-1` y `9`.
   * - Un valor de `-1` usa el nivel de compresión predeterminado (Actualmente `6`)
   * - Un valor de `0` no da compresión
   * - Un valor de `1` da la menor compresión, mayor velocidad
   * - Un valor de `9` da la mejor compresión, menor velocidad
   */
  level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * Cuánta memoria debe asignarse para el estado interno de compresión.
   *
   * Un valor de `1` usa la mínima memoria pero es lento y reduce la relación de compresión.
   *
   * Un valor de `9` usa la máxima memoria para velocidad óptima. El predeterminado es `8`.
   */
  memLevel?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * El logaritmo base 2 del tamaño de la ventana (el tamaño del búfer de historial).
   *
   * Valores más grandes de este parámetro resultan en mejor compresión a expensas del uso de memoria.
   *
   * Los siguientes rangos de valores se soportan:
   * - `9..15`: La salida tendrá un encabezado y pie de página zlib (Deflate)
   * - `-9..-15`: La salida **no** tendrá un encabezado o pie de página zlib (Deflate crudo)
   * - `25..31` (16+`9..15`): La salida tendrá un encabezado y pie de página gzip
   *
   * El encabezado gzip no tendrá nombre de archivo, datos extra, comentario, tiempo de modificación (establecido en cero) ni CRC de encabezado.
   */
  windowBits?:
    | -9
    | -10
    | -11
    | -12
    | -13
    | -14
    | -15
    | 9
    | 10
    | 11
    | 12
    | 13
    | 14
    | 15
    | 25
    | 26
    | 27
    | 28
    | 29
    | 30
    | 31;
  /**
   * Ajusta el algoritmo de compresión.
   *
   * - `Z_DEFAULT_STRATEGY`: Para datos normales **(Predeterminado)**
   * - `Z_FILTERED`: Para datos producidos por un filtro o predictor
   * - `Z_HUFFMAN_ONLY`: Forzar codificación Huffman solamente (sin coincidencia de cadenas)
   * - `Z_RLE`: Limitar distancias de coincidencia a uno (codificación por longitud de ejecución)
   * - `Z_FIXED` previene el uso de códigos Huffman dinámicos
   *
   * `Z_RLE` está diseñado para ser casi tan rápido como `Z_HUFFMAN_ONLY`, pero da mejor compresión para datos de imágenes PNG.
   *
   * `Z_FILTERED` fuerza más codificación Huffman y menos coincidencia de cadenas, es algo intermedio entre `Z_DEFAULT_STRATEGY` y `Z_HUFFMAN_ONLY`.
   * Los datos filtrados consisten principalmente en valores pequeños con una distribución algo aleatoria.
   */
  strategy?: number;
};

`Bun.gunzipSync()`

Descomprime un Uint8Array usando el algoritmo GUNZIP de zlib.

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

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

`Bun.deflateSync()`

Comprime un Uint8Array usando el algoritmo DEFLATE de zlib.

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

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

El segundo argumento soporta el mismo conjunto de opciones de configuración que Bun.gzipSync.

`Bun.inflateSync()`

Descomprime un Uint8Array usando el algoritmo 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()`

Comprime un Uint8Array usando el algoritmo Zstandard.

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

// Sincrónico
const compressedSync = Bun.zstdCompressSync(buf);
// Asíncrono
const compressedAsync = await Bun.zstdCompress(buf);

// Con nivel de compresión (1-22, predeterminado: 3)
const compressedLevel = Bun.zstdCompressSync(buf, { level: 6 });

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

Descomprime un Uint8Array usando el algoritmo Zstandard.

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

// Sincrónico
const decompressedSync = Bun.zstdDecompressSync(compressed);
// Asíncrono
const decompressedAsync = await Bun.zstdDecompress(compressed);

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

`Bun.inspect()`

Serializa un objeto a una string exactamente como se imprimiría con 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 es el símbolo que Bun usa para implementar Bun.inspect. Puedes anular esto para personalizar cómo se imprimen tus objetos. Es idéntico a util.inspect.custom en Node.js.

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

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

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

Formatea datos tabulares en una cadena. Como console.table, excepto que devuelve una cadena en lugar de imprimir en la consola.

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, puedes pasar un array de nombres de propiedad para mostrar solo un subconjunto de propiedades.

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

También puedes habilitar condicionalmente colores ANSI pasando { colors: true }.

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

`Bun.nanoseconds()`

Devuelve el número de nanosegundos desde que inició el proceso bun actual, como un number. Útil para cronometraje y benchmarking de alta precisión.

Bun.nanoseconds();
// => 7288958

`Bun.readableStreamTo*()`

Bun implementa un conjunto de funciones de conveniencia para consumir asíncronamente el cuerpo de un ReadableStream y convertirlo a varios formatos binarios.

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

// devuelve todos los fragmentos como un array
await Bun.readableStreamToArray(stream);
// => unknown[]

// devuelve todos los fragmentos como un objeto FormData (codificado como x-www-form-urlencoded)
await Bun.readableStreamToFormData(stream);

// devuelve todos los fragmentos como un objeto FormData (codificado como multipart/form-data)
await Bun.readableStreamToFormData(stream, multipartFormBoundary);

`Bun.resolveSync()`

Resuelve una ruta de archivo o especificador de módulo usando el algoritmo interno de resolución de módulos de Bun. El primer argumento es la ruta a resolver, y el segundo argumento es la "raíz". Si no se encuentra ninguna coincidencia, se lanza un Error.

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 al directorio de trabajo actual, pasa process.cwd() o "." como raíz.

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

Para resolver relativo al directorio que contiene el archivo actual, pasa import.meta.dir.

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

`Bun.stripANSI()`

NOTE

Alternativa ~6-57x más rápida a `strip-ansi`

Bun.stripANSI(text: string): string

Elimina códigos de escape ANSI de una cadena. Esto es útil para eliminar colores y formato de la salida de terminal.

const coloredText = "\u001b[31mHola\u001b[0m \u001b[32mMundo\u001b[0m";
const plainText = Bun.stripANSI(coloredText);
console.log(plainText); // => "Hola Mundo"

// Funciona con varios códigos ANSI
const formatted = "\u001b[1m\u001b[4mNegrita y subrayado\u001b[0m";
console.log(Bun.stripANSI(formatted)); // => "Negrita y subrayado"

Bun.stripANSI es significativamente más rápido que el popular paquete 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` y `deserialize` en `bun:jsc`

Para guardar un valor de JavaScript en un ArrayBuffer y volver, usa serialize y deserialize del 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 y postMessage serializan y deserializan de la misma manera. Esto expone el Algoritmo de Clonado Estructurado HTML subyacente a JavaScript como un ArrayBuffer.

`estimateShallowMemoryUsageOf` en `bun:jsc`

La función estimateShallowMemoryUsageOf devuelve una estimación del mejor esfuerzo del uso de memoria de un objeto en bytes, excluyendo el uso de memoria de propiedades u otros objetos a los que hace referencia. Para un uso de memoria preciso por objeto, usa 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 });
// Los arrays generalmente no se almacenan contiguamente en memoria, así que esto no devolverá un valor útil (lo cual no es 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() ​

Ver benchmark completo ​

Bun.fileURLToPath() ​

Bun.pathToFileURL() ​

Bun.gzipSync() ​

Opciones de compresión 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 y deserialize en bun:jsc ​

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

Opciones de compresión 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` y `deserialize` en `bun:jsc`

`estimateShallowMemoryUsageOf` en `bun:jsc`