Blog

Comenzando con la API de Bun

Mark Ponomarev

Mark Ponomarev

4 May 2025

Comenzando con la API de Bun

Entre las herramientas de desarrollo recientes más emocionantes se encuentra Bun, un kit de herramientas de JavaScript increíblemente rápido y todo en uno diseñado para mejorar la productividad del desarrollador y el rendimiento de las aplicaciones. Bun no es solo otro tiempo de ejecución; es un ecosistema cohesivo que abarca un tiempo de ejecución, un empaquetador (bundler), un ejecutor de pruebas (test runner), un gestor de paquetes (package manager) y más, todo dentro de un único ejecutable nativo. Esta guía le guiará a través de los aspectos esenciales de Bun, centrándose en sus conceptos fundamentales y potentes APIs.

💡
¿Quiere una excelente herramienta de prueba de API que genere documentación de API hermosa?

¿Quiere una plataforma integrada y todo en uno para que su equipo de desarrolladores trabaje en conjunto con máxima productividad?

¡Apidog cumple todas sus demandas y reemplaza a Postman a un precio mucho más asequible!
botón

¿Qué es Bun?

En su esencia, Bun se construye alrededor de un motor de tiempo de ejecución de JavaScript de alto rendimiento. A diferencia de Node.js, que utiliza el motor V8 de Google, Bun utiliza JavaScriptCore (JSC) de Apple, el motor que impulsa Safari. Esta elección, combinada con la implementación de Bun en el lenguaje de programación de bajo nivel Zig, contribuye significativamente a su notable velocidad. Los tiempos de inicio para las aplicaciones de Bun a menudo se miden como drásticamente más rápidos que las aplicaciones equivalentes de Node.js, a veces por un factor de cuatro o más. Esta ventaja de velocidad se extiende más allá del simple inicio; las implementaciones internas de Bun de varias APIs están optimizadas para un rendimiento máximo y un uso mínimo de memoria.

Pero la ambición de Bun se extiende mucho más allá de ser solo un tiempo de ejecución más rápido. Su objetivo es ser un kit de herramientas completo, abordando directamente las necesidades comunes de los desarrolladores:

  1. Herramientas Integradas: El comando bun en sí mismo actúa como punto de entrada para numerosas funcionalidades. bun run ejecuta scripts definidos en package.json, bun install gestiona dependencias (a menudo mucho más rápido que npm o yarn), bun test ejecuta pruebas utilizando una API compatible con Jest, bun build empaqueta código para producción y bunx ejecuta paquetes sin instalarlos explícitamente. Esta integración simplifica los flujos de trabajo al reducir la cantidad de herramientas de desarrollo distintas necesarias.
  2. Soporte Nativo de TypeScript y JSX: Una de las características destacadas de Bun es su soporte inmediato (out-of-the-box) para archivos TypeScript (.ts, .tsx) y JSX (.jsx). Bun incluye un transpilador integrado y altamente optimizado que maneja estos tipos de archivos sin problemas durante la ejecución o el empaquetado. Esto elimina la necesidad de pasos de compilación separados que involucren tsc o Babel para muchos escenarios de desarrollo comunes, agilizando el proceso de configuración.
  3. Compatibilidad con Sistemas de Módulos: Bun adopta JavaScript moderno con soporte de primera clase para ES Modules (ESM). Sin embargo, reconoce el vasto ecosistema existente construido sobre CommonJS (CJS). Bun proporciona una compatibilidad robusta para ambos sistemas de módulos, permitiendo a los desarrolladores usar import y require de manera intercambiable en gran medida y aprovechar los millones de paquetes CJS existentes disponibles en npm.
  4. Adherencia a APIs Estándar Web: Un principio de diseño clave es la implementación de APIs Web estándar. Funciones y objetos como fetch, Request, Response, Headers, WebSocket y la API Streams (ReadableStream, WritableStream) están integrados en el ámbito global de Bun. Esto promueve la portabilidad del código entre entornos Bun del lado del servidor, frontends de navegador y plataformas de computación de borde (edge computing), permitiendo a los desarrolladores reutilizar APIs familiares en diferentes contextos.
  5. Compatibilidad con Node.js: Si bien Bun forja su propio camino con APIs optimizadas y estándares Web, busca un alto grado de compatibilidad con la superficie de la API de Node.js. Muchos módulos integrados de Node.js (node:fs, node:path, node:os, node:events, etc.) y objetos globales (process, Buffer, __filename, __dirname) están implementados parcial o totalmente. El objetivo es permitir que muchos proyectos Node.js y paquetes npm existentes se ejecuten en Bun con mínima o ninguna modificación, posicionando a Bun como un potencial "reemplazo directo" (drop-in replacement) en numerosos casos.

Al combinar estos elementos, Bun presenta una alternativa atractiva para los desarrolladores de JavaScript y TypeScript que buscan rendimiento, simplicidad y una experiencia de desarrollo moderna.

Cómo Instalar Bun

Comenzar con Bun está diseñado para ser rápido y sencillo en diversas plataformas. El método más común para macOS, Linux y el Subsistema de Windows para Linux (WSL) utiliza un simple comando curl ejecutado en su terminal:

curl -fsSL https://bun.sh/install | bash

Si encuentra problemas de permisos o prefiere no canalizar directamente a bash, puede descargar el script primero e inspeccionarlo antes de ejecutarlo:

curl -fsSL https://bun.sh/install -o install.sh
# Inspeccionar install.sh si se desea
bash install.sh

Otros Métodos de Instalación:

npm install -g bun

docker run --rm --init --ulimit memlock=-1:-1 oven/bun:latest bun --version

brew tap oven-sh/bun
brew install bun

Verificación:

Una vez instalado, abra una nueva ventana de terminal y verifique la instalación comprobando la versión:

bun --version

Esto debería mostrar el número de versión instalado, confirmando que Bun está listo para usar. También puede ejecutar bun --help para ver una lista de comandos y opciones disponibles.

Ejecute Su Bun por Primera Vez

Vamos a sumergirnos en la escritura y ejecución de un programa simple con Bun. Una de las tareas más comunes es crear un servidor HTTP. Bun proporciona una API integrada y altamente optimizada para este propósito: Bun.serve.

Cree un nuevo archivo llamado server.js (o server.ts, ya que Bun maneja ambos):

// server.ts

// Bun.serve inicia el servidor HTTP
const server = Bun.serve({
  // Especifica el puerto en el que escuchar.
  // Por defecto es process.env.PORT || 3000
  port: 3000,

  // La función 'fetch' es el manejador principal de solicitudes.
  // Recibe un objeto Request estándar y debe devolver un objeto Response (o una Promesa que resuelva a uno).
  fetch(request: Request): Response {
    // Crea un objeto Response estándar de la Web API
    return new Response("Welcome to Bun!");
  },
});

// Registra un mensaje indicando que el servidor está corriendo
console.log(`Listening on http://localhost:${server.port}`);

Este fragmento de código hace lo siguiente:

  1. Llama a Bun.serve, la función principal para crear servidores HTTP en Bun.
  2. Pasa un objeto de configuración, especificando el port (3000 en este caso).
  3. La parte crucial es la función fetch. Esta función se invoca para cada solicitud HTTP entrante. Se alinea con el patrón del manejador de eventos fetch de Service Worker, aceptando un objeto Request estándar.
  4. Dentro de fetch, construimos y devolvemos un objeto Response estándar. Aquí, simplemente devolvemos el texto plano "Welcome to Bun!".
  5. Finalmente, registramos un mensaje de confirmación en la consola, incluyendo el puerto real en el que el servidor está escuchando (accesible a través de server.port).

Para ejecutar este servidor, abra su terminal en el directorio donde guardó el archivo y ejecute:

bun run server.ts

O, si lo guardó como server.js:

bun run server.js

Bun ejecutará el script. Si usó TypeScript (server.ts), el transpilador interno de Bun manejará la conversión a JavaScript sobre la marcha antes de la ejecución. Verá el mensaje "Listening on http://localhost:3000".

Ahora, abra su navegador web y navegue a http://localhost:3000. Debería ver el texto "Welcome to Bun!" mostrado.

Para detener el servidor, vuelva a su terminal y presione Ctrl + C.

Este simple ejemplo demuestra la facilidad para configurar un servidor básico y ejecutar código (incluido TypeScript) directamente con Bun, mostrando su naturaleza integrada y su dependencia de APIs Web estándar como Request y Response.

¿Qué es el Soporte Nativo de TypeScript en Bun?

Una de las ventajas más significativas de Bun, especialmente para los desarrolladores que ya usan o desean adoptar TypeScript, es su soporte de primera clase e inmediato (out-of-the-box). A diferencia de Node.js, donde ejecutar TypeScript generalmente requiere pre-compilación usando el compilador de TypeScript (tsc) o usando cargadores/registradores como ts-node o tsx, Bun lo maneja de forma nativa y transparente.

Cómo Funciona:

Cuando le pide a Bun que ejecute un archivo .ts o .tsx (por ejemplo, bun run myscript.ts), invoca automáticamente su transpilador interno. Este transpilador está escrito en código nativo (Zig) y es extremadamente rápido. Su trabajo es:

  1. Eliminar Tipos: Elimina anotaciones de tipo de TypeScript, interfaces, enums, etc., ya que no forman parte de la ejecución estándar de JavaScript.
  2. Transformar Sintaxis: Convierte la sintaxis específica de TypeScript (como ciertos usos de enum o sintaxis de decoradores más antigua si está configurado) en JavaScript equivalente.
  3. Manejar JSX: Transforma la sintaxis JSX (utilizada en archivos .tsx y .jsx) en llamadas a funciones de JavaScript estándar (típicamente React.createElement o un equivalente de tiempo de ejecución JSX configurado).

El beneficio clave es que esto sucede sobre la marcha durante el proceso de ejecución (bun run) o empaquetado (bun build). No se requiere un paso de construcción separado y explícito solo para ejecutar su código TypeScript durante el desarrollo.

Ejemplo:

Considere este archivo TypeScript (greet.ts):

// greet.ts
interface User {
  name: string;
  id: number;
}

function greetUser(user: User): void {
  console.log(`Hello, ${user.name} (ID: ${user.id})!`);
}

const myUser: User = { name: "Bun Developer", id: 123 };

greetUser(myUser);

// Incluso puedes usar características modernas que Bun soporta
const message = `Bun version: ${Bun.version}`;
console.log(message);

Puede ejecutar esto directamente:

bun run greet.ts

Bun lo transpilá internamente y ejecutará el JavaScript resultante, produciendo una salida como:

Hello, Bun Developer (ID: 123)!
Bun version: 1.x.y

Soporte de JSX:

De manera similar, si tiene un archivo .tsx con JSX:

// component.tsx

// Asumiendo que tiene JSX configurado (las configuraciones por defecto de Bun a menudo funcionan con React)
function MyComponent({ name }: { name: string }) {
  return <div className="greeting">Hello, {name}!</div>;
}

// NOTA: Ejecutar esto directamente no renderizará HTML,
// solo muestra la estructura JS transpilada.
// Típicamente lo usaría dentro de una aplicación o framework más grande.
console.log("Simulando la creación de un componente (estructura de salida transpilada):");
// La salida real depende de la configuración de transformación de JSX,
// pero serían objetos/llamadas a funciones de JavaScript.

Ejecutar bun run component.tsx ejecutaría el archivo, transpilando el JSX a JavaScript.

Configuración (tsconfig.json):

Bun respeta los archivos tsconfig.json para las opciones de configuración que afectan la transpilación. Aunque no realiza una verificación de tipos completa como tsc (Bun se centra en la velocidad de ejecución y transpilación), lee tsconfig.json para entender configuraciones como:

Si no se encuentra un archivo tsconfig.json, Bun utiliza configuraciones predeterminadas sensatas.

Esta integración perfecta hace que iniciar proyectos TypeScript con Bun sea increíblemente simple y rápido, reduciendo la barrera de entrada y acelerando los ciclos de desarrollo.

Hablemos de las APIs Específicas de Bun

Aunque Bun enfatiza fuertemente la compatibilidad con las APIs estándar Web y Node.js, también introduce su propio conjunto de APIs optimizadas e integradas bajo el objeto global Bun. Estas APIs a menudo proporcionan alternativas de alto rendimiento o envoltorios convenientes para tareas comunes que aprovechan las capacidades de código nativo de Bun.

Aquí hay un vistazo a algunas APIs clave de Bun.*:

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs

Registrarse gratisDescargar