¿Qué son los Buffers en Node.js?

Question

Accepted Answer

Un **Buffer** es la forma de Node de manejar **datos binarios en crudo** — una secuencia de bytes de longitud fija almacenada fuera del heap de V8. Como los strings de JavaScript son para texto (Unicode), los Buffers existen para trabajar con binario: contenido de archivos, paquetes de red, imágenes, cifrado, etc.

## Por qué existen los Buffers

```text
Strings de JavaScript → texto (UTF-16). No pueden representar bytes arbitrarios de forma limpia.
Buffers → bytes en crudo (0–255 cada uno). Para datos binarios que no son texto.
```

Cuando lees un archivo o recibes datos de red, llegan como bytes — un Buffer — que luego puedes decodificar a un string si es texto, o procesar como binario si no lo es.

## Crear y usar Buffers

```js
const buf = Buffer.from("Hello");          // desde un string → bytes
const buf2 = Buffer.from([72, 105]);       // desde valores de byte → "Hi"
const buf3 = Buffer.alloc(10);             // 10 bytes rellenados con ceros

buf.length;          // 5 (bytes, no caracteres)
buf.toString("utf8"); // "Hello" — decodificar de vuelta a texto
buf.toString("hex");  // "48656c6c6f"
buf.toString("base64"); // "SGVsbG8="
buf[0];              // 72 — acceder a bytes individuales
```

## Dónde aparecen los Buffers

```js
// las lecturas de archivos sin encoding devuelven un Buffer
const data = await fs.promises.readFile("image.png"); // Buffer (binario)
const text = await fs.promises.readFile("file.txt", "utf8"); // string (decodificado)

// los streams emiten chunks de tipo Buffer
req.on("data", (chunk) => { /* chunk es un Buffer */ });

// crypto, compresión y protocolos de red trabajan todos con Buffers
crypto.randomBytes(16); // un Buffer de 16 bytes aleatorios
```

Si lees un archivo *sin* especificar un encoding, obtienes un Buffer; especifica `"utf8"` y Node lo decodifica a un string por ti.

## Un punto sutil: bytes vs caracteres

```js
Buffer.from("café").length; // 5 (é son 2 bytes en UTF-8) — NO 4 caracteres
```

La longitud del Buffer está en **bytes**, que puede diferir del número de caracteres para texto multibyte (no ASCII) — relevante al cortar datos binarios.

## Por qué es importante

Los Buffers son la forma en que Node maneja todos los **datos binarios**, algo inevitable en el trabajo de servidor: leer archivos no textuales, procesar streams, protocolos de red, criptografía, subida de imágenes/archivos y compresión.

Entender que la E/S trata fundamentalmente con bytes (Buffers) — y cómo convertir entre Buffers y strings con el encoding correcto — es esencial cuando vas más allá del texto plano, y es la base de los streams, el sistema de archivos y crypto.