import Run from "/snippets/cli/run.mdx";

Il Runtime di Bun è progettato per avviarsi velocemente ed eseguire velocemente.

Sotto il cofano, Bun usa il motore JavaScriptCore, sviluppato da Apple per Safari. Nella maggior parte dei casi, le prestazioni di avvio ed esecuzione sono superiori a V8, il motore usato da Node.js e dai browser basati su Chromium. Il suo transpiler e runtime sono scritti in Zig, un linguaggio moderno e ad alte prestazioni. Su Linux, questo si traduce in tempi di avvio 4 volte più veloci rispetto a Node.js.

Comando	Tempo
bun hello.js	5.2ms
node hello.js	25.1ms

Questo benchmark si basa sull'esecuzione di un semplice script Hello World su Linux.

Eseguire un file

Usa bun run per eseguire un file sorgente.

bun run index.js

Bun supporta TypeScript e JSX nativamente. Ogni file viene transpilato al volo dal veloce transpiler nativo di Bun prima di essere eseguito.

bun run index.js
bun run index.jsx
bun run index.ts
bun run index.tsx

In alternativa, puoi omettere la parola chiave run e usare il comando "nudo"; si comporta in modo identico.

bun index.tsx
bun index.js

--watch

Per eseguire un file in modalità watch, usa il flag --watch.

bun --watch run index.tsx

::: note Quando usi bun run, metti i flag di Bun come --watch immediatamente dopo bun. :::

bun --watch run dev # ✔️ fai così
bun run dev --watch # ❌ non fare così

I flag che si verificano alla fine del comando verranno ignorati e passati allo script "dev" stesso.

Eseguire uno script package.json

::: note Confronta con npm run <script> o yarn <script> :::

bun [flag bun] run <script> [flag script]

Il tuo package.json può definire diversi "scripts" nominati che corrispondono a comandi shell.

{
  // ... altri campi
  "scripts": {
    "clean": "rm -rf dist && echo 'Fatto.'",
    "dev": "bun server.ts"
  }
}

Usa bun run <script> per eseguire questi script.

bun run clean
rm -rf dist && echo 'Fatto.'

Pulizia...
Fatto.

Bun esegue il comando dello script in un sottoshell. Su Linux e macOS, cerca le seguenti shell in ordine, usando la prima che trova: bash, sh, zsh. Su Windows, usa bun shell per supportare la sintassi simile a bash e molti comandi comuni.

NOTE

⚡️ Il tempo di avvio per `npm run` su Linux è circa 170ms; con Bun è `6ms`.

Gli script possono anche essere eseguiti con il comando più breve bun <script>, tuttavia se esiste un comando built-in di bun con lo stesso nome, il comando built-in ha la precedenza. In questo caso, usa il comando più esplicito bun run <script> per eseguire il tuo script del package.

bun run dev

Per vedere un elenco degli script disponibili, esegui bun run senza argomenti.

bun run

script quickstart:

 bun run clean
   rm -rf dist && echo 'Fatto.'

 bun run dev
   bun server.ts

2 script

Bun rispetta gli hook del ciclo di vita. Ad esempio, bun run clean eseguirà preclean e postclean, se definiti. Se il pre<script> fallisce, Bun non eseguirà lo script stesso.

--bun

È comune per gli script package.json fare riferimento a CLI installati localmente come vite o next. Questi CLI sono spesso file JavaScript contrassegnati con uno shebang per indicare che dovrebbero essere eseguiti con node.

#!/usr/bin/env node

// fai cose

Per impostazione predefinita, Bun rispetta questo shebang ed esegue lo script con node. Tuttavia, puoi sovrascrivere questo comportamento con il flag --bun. Per CLI basati su Node.js, questo eseguirà la CLI con Bun invece di Node.js.

bun run --bun vite

Filtraggio

Nei monorepo contenenti più pacchetti, puoi usare l'argomento --filter per eseguire script in molti pacchetti contemporaneamente.

Usa bun run --filter <patterno_nome> <script> per eseguire <script> in tutti i pacchetti il cui nome corrisponde a <pattern_nome>. Ad esempio, se hai sottodirectory contenenti pacchetti chiamati foo, bar e baz, eseguendo

bun run --filter 'ba*' <script>

eseguirà <script> sia in bar che in baz, ma non in foo.

Trova maggiori dettagli nella pagina docs per filter.

bun run - per inviare codice da stdin

bun run - ti permette di leggere JavaScript, TypeScript, TSX o JSX da stdin ed eseguirlo senza scrivere prima su un file temporaneo.

echo "console.log('Ciao')" | bun run -

Ciao

Puoi anche usare bun run - per reindirizzare file in Bun. Ad esempio, per eseguire un file .js come se fosse un file .ts:

echo "console.log!('Questo è TypeScript!' as any)" > secretly-typescript.js
bun run - < secretly-typescript.js

Questo è TypeScript!

Per comodità, tutto il codice è trattato come TypeScript con supporto JSX quando si usa bun run -.

bun run --console-depth

Controlla la profondità dell'ispezione degli oggetti nell'output della console con il flag --console-depth.

bun --console-depth 5 run index.tsx

Questo imposta quanto profondamente gli oggetti annidati vengono visualizzati nell'output di console.log(). La profondità predefinita è 2. Valori più alti mostrano più proprietà annidate ma possono produrre output verbosi per oggetti complessi.

const nested = { a: { b: { c: { d: "deep" } } } };
console.log(nested);
// Con --console-depth 2 (predefinito): { a: { b: [Object] } }
// Con --console-depth 4: { a: { b: { c: { d: 'deep' } } } }

bun run --smol

In ambienti con vincoli di memoria, usa il flag --smol per ridurre l'uso di memoria a scapito delle prestazioni.

bun --smol run index.tsx

Questo fa sì che il garbage collector venga eseguito più frequentemente, il che può rallentare l'esecuzione. Tuttavia, può essere utile in ambienti con memoria limitata. Bun regola automaticamente la dimensione dell'heap del garbage collector in base alla memoria disponibile (tenendo conto di cgroups e altri limiti di memoria) con e senza il flag --smol, quindi questo è principalmente utile per i casi in cui vuoi far crescere la dimensione dell'heap più lentamente.

Ordine di risoluzione

I percorsi assoluti e i percorsi che iniziano con ./ o .\\ sono sempre eseguiti come file sorgente. A meno che non si usi bun run, l'esecuzione di un file con un'estensione consentita preferirà il file a uno script package.json.

Quando c'è uno script package.json e un file con lo stesso nome, bun run dà priorità allo script package.json. L'ordine di risoluzione completo è:

1. Script package.json, es. bun run build
2. File sorgente, es. bun run src/main.js
3. Binari dai pacchetti del progetto, es. bun add eslint && bun run eslint
4. (solo bun run) Comandi di sistema, es. bun run ls

---