Утилиты Bun JS

`Bun.version`

string, содержащая версию bun CLI, которая в данный момент запущена.

Bun.version;
// => "1.3.3"

`Bun.revision`

Git-коммит Bun, который был скомпилирован для создания текущего bun CLI.

Bun.revision;
// => "f02561530fda1ee9396f51c8bc99b38716e38296"

`Bun.env`

Псевдоним для process.env.

`Bun.main`

Абсолютный путь к точке входа текущей программы (файл, который был выполнен с помощью bun run).

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

Это особенно полезно для определения того, выполняется ли скрипт напрямую или импортируется другим скриптом.

if (import.meta.path === Bun.main) {
  // этот скрипт выполняется напрямую
} else {
  // этот файл импортируется из другого скрипта
}

Это аналогично трюку require.main = module в Node.js.

`Bun.sleep()`

Bun.sleep(ms: number)

Возвращает Promise, который разрешается через указанное количество миллисекунд.

console.log("hello");
await Bun.sleep(1000);
console.log("hello одну секунду спустя!");

Или передайте объект Date, чтобы получить Promise, который разрешится в указанный момент времени.

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

console.log("hello");
await Bun.sleep(oneSecondInFuture);
console.log("hello одну секунду спустя!");

`Bun.sleepSync()`

Bun.sleepSync(ms: number)

Блокирующая синхронная версия Bun.sleep.

console.log("hello");
Bun.sleepSync(1000); // блокирует поток на одну секунду
console.log("hello одну секунду спустя!");

`Bun.which()`

Bun.which(bin: string)

Возвращает путь к исполняемому файлу, аналогично вводу which в терминале.

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

По умолчанию Bun ищет в текущей переменной окружения PATH. Для настройки PATH:

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

Передайте опцию cwd, чтобы разрешить путь для исполняемого файла из определенного каталога.

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

console.log(ls); // null

Вы можете думать об этом как о встроенной альтернативе npm-пакету which.

`Bun.randomUUIDv7()`

Bun.randomUUIDv7() возвращает UUID v7, который является монотонным и подходит для сортировки и баз данных.

import { randomUUIDv7 } from "bun";

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

UUID v7 — это 128-битное значение, которое кодирует текущую метку времени, случайное значение и счетчик. Метка времени кодируется с использованием младших 48 бит, а случайное значение и счетчик кодируются с использованием оставшихся бит.

Параметр timestamp по умолчанию равен текущему времени в миллисекундах. Когда метка времени изменяется, счетчик сбрасывается до псевдослучайного целого числа, ограниченного 4096. Этот счетчик является атомарным и потокобезопасным, что означает, что использование Bun.randomUUIDv7() во многих Workers в одном и том же процессе, работающих с одинаковой меткой времени, не приведет к коллизиям значений счетчика.

Последние 8 байт UUID — это криптографически безопасное случайное значение. Используется тот же генератор случайных чисел, что и в crypto.randomUUID() (который поступает из BoringSSL, который, в свою очередь, поступает из системного генератора случайных чисел платформы, обычно предоставляемого базовым оборудованием).

namespace Bun {
  function randomUUIDv7(encoding?: "hex" | "base64" | "base64url" = "hex", timestamp?: number = Date.now()): string;
  /**
   * Если вы передадите "buffer", вы получите 16-байтный буфер вместо строки.
   */
  function randomUUIDv7(encoding: "buffer", timestamp?: number = Date.now()): Buffer;

  // Если вы передадите только метку времени, вы получите hex-строку
  function randomUUIDv7(timestamp?: number = Date.now()): string;
}

Вы можете установить кодировку в "buffer", чтобы получить 16-байтный буфер вместо строки. Это иногда позволяет избежать накладных расходов на преобразование строки.

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

Также поддерживаются кодировки base64 и base64url, когда вам нужна немного более короткая строка.

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

`Bun.peek()`

Bun.peek(prom: Promise)

Читает результат промиса без await или .then, но только если промис уже выполнен или отклонен.

import { peek } from "bun";

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

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

Это важно при попытке уменьшить количество лишних микротиков в коде, чувствительном к производительности. Это продвинутый API, и вы, вероятно, не должны использовать его, если не знаете, что делаете.

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

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

  // без await необходимо!
  expect(peek(promise)).toBe(true);

  // если мы посмотрим снова, оно вернет то же значение
  const again = peek(promise);
  expect(again).toBe(true);

  // если мы посмотрим на не-промис, оно вернет значение
  const value = peek(42);
  expect(value).toBe(42);

  // если мы посмотрим на ожидающий промис, оно вернет промис снова
  const pending = new Promise(() => {});
  expect(peek(pending)).toBe(pending);

  // Если мы посмотрим на отклоненный промис, оно:
  // - вернет ошибку
  // - не пометит промис как обработанный
  const rejected = Promise.reject(new Error("Успешно протестировано отклонение промиса"));
  expect(peek(rejected).message).toBe("Успешно протестировано отклонение промиса");
});

Функция peek.status позволяет прочитать статус промиса без его разрешения.

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("ой нет"));
  expect(peek.status(rejected)).toBe("rejected");
});

`Bun.openInEditor()`

Открывает файл в вашем редакторе по умолчанию. Bun автоматически определяет ваш редактор через переменные окружения $VISUAL или $EDITOR.

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

Вы можете переопределить это через настройку debug.editor в вашем bunfig.toml.

toml

[debug] 
editor = "code"

Или укажите редактор с параметром editor. Вы также можете указать номер строки и столбца.

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

`Bun.deepEquals()`

Рекурсивно проверяет, эквивалентны ли два объекта. Это используется внутри expect().toEqual() в 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 } });

Третий булевый параметр может быть использован для включения "строгого" режима. Это используется expect().toStrictEqual() в тестовом раннере.

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

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

В строгом режиме следующие значения считаются неравными:

// undefined значения
Bun.deepEquals({}, { a: undefined }, true); // false

// undefined в массивах
Bun.deepEquals(["asdf"], ["asdf", undefined], true); // false

// разреженные массивы
Bun.deepEquals([, 1], [undefined, 1], true); // false

// объектные литералы против экземпляров с теми же свойствами
class Foo {
  a = 1;
}
Bun.deepEquals(new Foo(), { a: 1 }, true); // false

`Bun.escapeHTML()`

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

Экранирует следующие символы из входной строки:

" становится "
& становится &
' становится '
< становится <
> становится >

Эта функция оптимизирована для больших входных данных. На M1X она обрабатывает 480 МБ/с - 20 ГБ/с, в зависимости от того, сколько данных экранируется и есть ли текст не-ascii. Типы, не являющиеся строками, будут преобразованы в строку перед экранированием.

`Bun.stringWidth()`

NOTE

~6,756x более быстрая альтернатива `string-width`

Получить количество колонок строки, как она будет отображаться в терминале. Поддерживает ANSI escape-коды, emoji и широкие символы.

Пример использования:

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

Это полезно для:

Выравнивания текста в терминале
Быстрой проверки, содержит ли строка ANSI escape-коды
Измерения ширины строки в терминале

Этот API разработан так, чтобы соответствовать популярному пакету "string-width", чтобы существующий код можно было легко перенести в Bun и наоборот.

В этом бенчмарке Bun.stringWidth примерно в ~6,756 раз быстрее, чем npm-пакет string-width для входных данных размером более 500 символов. Большое спасибо sindresorhus за их работу над 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      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 µс   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 µс   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 µс 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:

namespace Bun {
  export function stringWidth(
    /**
     * Строка для измерения
     */
    input: string,
    options?: {
      /**
       * Если `true`, считать ANSI escape-коды частью ширины строки. Если `false`, ANSI escape-коды игнорируются при вычислении ширины строки.
       *
       * @default false
       */
      countAnsiEscapeCodes?: boolean;
      /**
       * Когда это неоднозначно и `true`, считать emoji шириной в 1 символ. Если `false`, emoji считаются шириной в 2 символа.
       *
       * @default true
       */
      ambiguousIsNarrow?: boolean;
    },
  ): number;
}

`Bun.fileURLToPath()`

Преобразует file:// URL в абсолютный путь.

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

`Bun.pathToFileURL()`

Преобразует абсолютный путь в file:// URL.

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

`Bun.gzipSync()`

Сжимает Uint8Array с использованием алгоритма GZIP zlib.

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

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

При необходимости передайте объект параметров в качестве второго аргумента:

Опции сжатия zlib">

export type ZlibCompressionOptions = {
  /**
   * Уровень сжатия, который нужно использовать. Должен быть между `-1` и `9`.
   * - Значение `-1` использует уровень сжатия по умолчанию (в настоящее время `6`)
   * - Значение `0` не использует сжатие
   * - Значение `1` дает наименьшее сжатие, самую высокую скорость
   * - Значение `9` дает лучшее сжатие, самую низкую скорость
   */
  level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * Сколько памяти должно быть выделено для внутреннего состояния сжатия.
   *
   * Значение `1` использует минимум памяти, но медленное и уменьшает коэффициент сжатия.
   *
   * Значение `9` использует максимум памяти для оптимальной скорости. По умолчанию `8`.
   */
  memLevel?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
  /**
   * Основание 2 логарифма размера окна (размер буфера истории).
   *
   * Большие значения этого параметра приводят к лучшему сжатию за счет использования памяти.
   *
   * Поддерживаются следующие диапазоны значений:
   * - `9..15`: Вывод будет иметь заголовок и нижний колонтитул zlib (Deflate)
   * - `-9..-15`: Вывод **не будет** иметь заголовок и нижний колонтитул zlib (Raw Deflate)
   * - `25..31` (16+`9..15`): Вывод будет иметь заголовок и нижний колонтитул gzip (gzip)
   *
   * Заголовок gzip не будет иметь имени файла, дополнительных данных, комментария, времени модификации (установлено в ноль) и CRC заголовка.
   */
  windowBits?:
    | -9
    | -10
    | -11
    | -12
    | -13
    | -14
    | -15
    | 9
    | 10
    | 11
    | 12
    | 13
    | 14
    | 15
    | 25
    | 26
    | 27
    | 28
    | 29
    | 30
    | 31;
  /**
   * Настраивает алгоритм сжатия.
   *
   * - `Z_DEFAULT_STRATEGY`: Для нормальных данных **(по умолчанию)**
   * - `Z_FILTERED`: Для данных, произведенных фильтром или предиктором
   * - `Z_HUFFMAN_ONLY`: Принудительное кодирование Хаффмана только (без сопоставления строк)
   * - `Z_RLE`: Ограничить расстояния сопоставления одним (кодирование длин серий)
   * - `Z_FIXED` предотвращает использование динамических кодов Хаффмана
   *
   * `Z_RLE` разработан, чтобы быть почти таким же быстрым, как `Z_HUFFMAN_ONLY`, но давать лучшее сжатие для данных изображений PNG.
   *
   * `Z_FILTERED` принудительно использует больше кодирования Хаффмана и меньше сопоставления строк, это
   * несколько промежуточно между `Z_DEFAULT_STRATEGY` и `Z_HUFFMAN_ONLY`.
   * Фильтрованные данные состоят в основном из небольших значений с несколько случайным распределением.
   */
  strategy?: number;
};

`Bun.gunzipSync()`

Распаковывает Uint8Array с использованием алгоритма GUNZIP 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()`

Сжимает Uint8Array с использованием алгоритма DEFLATE zlib.

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

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

Второй аргумент поддерживает тот же набор опций конфигурации, что и Bun.gzipSync.

`Bun.inflateSync()`

Распаковывает Uint8Array с использованием алгоритма INFLATE 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()`

Сжимает Uint8Array с использованием алгоритма Zstandard.

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

// Синхронно
const compressedSync = Bun.zstdCompressSync(buf);
// Асинхронно
const compressedAsync = await Bun.zstdCompress(buf);

// С уровнем сжатия (1-22, по умолчанию: 3)
const compressedLevel = Bun.zstdCompressSync(buf, { level: 6 });

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

Распаковывает Uint8Array с использованием алгоритма Zstandard.

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

// Синхронно
const decompressedSync = Bun.zstdDecompressSync(compressed);
// Асинхронно
const decompressedAsync = await Bun.zstdDecompress(compressed);

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

`Bun.inspect()`

Сериализует объект в string точно так, как он был бы напечатан с помощью 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`

Это символ, который Bun использует для реализации Bun.inspect. Вы можете переопределить это, чтобы настроить печать ваших объектов. Это идентично util.inspect.custom в Node.js.

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

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

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

Форматирует табличные данные в строку. Как console.table, за исключением того, что оно возвращает строку, а не печатает в консоль.

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

Кроме того, вы можете передать массив имен свойств для отображения только подмножества свойств.

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

Вы также можете условно включить ANSI цвета, передав { colors: true }.

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

`Bun.nanoseconds()`

Возвращает количество наносекунд с момента запуска текущего процесса bun как number. Полезно для высокоточного хронометрирования и бенчмаркинга.

Bun.nanoseconds();
// => 7288958

`Bun.readableStreamTo*()`

Bun реализует набор удобных функций для асинхронного потребления тела ReadableStream и преобразования его в различные бинарные форматы.

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

// возвращает все части как массив
await Bun.readableStreamToArray(stream);
// => unknown[]

// возвращает все части как объект FormData (закодированный как x-www-form-urlencoded)
await Bun.readableStreamToFormData(stream);

// возвращает все части как объект FormData (закодированный как multipart/form-data)
await Bun.readableStreamToFormData(stream, multipartFormBoundary);

`Bun.resolveSync()`

Разрешает путь к файлу или спецификатор модуля с использованием внутреннего алгоритма разрешения модулей Bun. Первый аргумент — путь для разрешения, второй аргумент — "корень". Если совпадение не найдено, выбрасывается 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"

Для разрешения относительно текущего рабочего каталога передайте process.cwd() или "." в качестве корня.

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

Для разрешения относительно каталога, содержащего текущий файл, передайте import.meta.dir.

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

`Bun.stripANSI()`

NOTE

~6-57x более быстрая альтернатива `strip-ansi`

Bun.stripANSI(text: string): string

Удаляет ANSI escape-коды из строки. Это полезно для удаления цветов и форматирования из вывода терминала.

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

// Работает с различными ANSI-кодами
const formatted = "\u001b[1m\u001b[4mBold and underlined\u001b[0m";
console.log(Bun.stripANSI(formatted)); // => "Bold and underlined"

Bun.stripANSI значительно быстрее, чем популярный 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` в `bun:jsc`

Для сохранения JavaScript-значения в ArrayBuffer и обратно используйте serialize и deserialize из модуля "bun:jsc".

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

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

Внутри structuredClone и postMessage сериализуют и десериализуют одинаковым образом. Это предоставляет базовый алгоритм структурированного клонирования HTML JavaScript как ArrayBuffer.

`estimateShallowMemoryUsageOf` в `bun:jsc`

Функция estimateShallowMemoryUsageOf возвращает наилучшую оценку использования памяти объектом в байтах, исключая использование памяти свойствами или другими объектами, на которые он ссылается. Для точного использования памяти на объект используйте 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 });
// Массивы обычно не хранятся непрерывно в памяти, поэтому это не вернет полезное значение (что не является ошибкой).
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() ​

Bun.fileURLToPath() ​

Bun.pathToFileURL() ​

Bun.gzipSync() ​

Опции сжатия 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 в bun:jsc ​

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

`Bun.fileURLToPath()`

`Bun.pathToFileURL()`

`Bun.gzipSync()`

Опции сжатия 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` в `bun:jsc`

`estimateShallowMemoryUsageOf` в `bun:jsc`