Saltar al contenido
Colecciones y datos

Datos binarios

Lección 7 de 712 min4 ejercicios

Imágenes, audio, archivos, mensajes de red, criptografía: por debajo, todo son bytes. Para trabajar con ellos de forma eficiente, JavaScript tiene un conjunto de herramientas propio: un bloque de memoria cruda y distintas "lentes" para leerlo como números de distintos tamaños.

Buffer y vistas

Un ArrayBuffer es un bloque de bytes de tamaño fijo. No se puede leer directamente: necesitas una vista que diga cómo interpretar esos bytes.

const buffer = new ArrayBuffer(8);     // 8 bytes, todos en 0

const bytes = new Uint8Array(buffer);  // vista de 8 números de 0 a 255
bytes[0] = 255;
bytes[1] = 1;

const pares = new Uint16Array(buffer); // los mismos bytes, de a 2
console.log(bytes.length, pares.length);
console.log(pares[0]);                 // 255 + 1 × 256 = 511

Las dos vistas miran la misma memoria: cambiar una cambia lo que ve la otra.

Arrays tipados

Cada tipo fija cuántos bytes ocupa cada elemento y qué valores admite:

Tipo Bytes Valores
Uint8Array 1 0 a 255
Int8Array 1 -128 a 127
Uint8ClampedArray 1 0 a 255, sin dar la vuelta (para imágenes)
Int16Array, Uint16Array 2 Enteros de 16 bits
Int32Array, Uint32Array 4 Enteros de 32 bits
Float16Array (ES2025) 2 Decimales de media precisión
Float32Array, Float64Array 4 y 8 Decimales
BigInt64Array, BigUint64Array 8 Enteros de 64 bits, como BigInt

Se pueden crear sin un buffer explícito, y se usan casi como arrays: tienen map, filter, at, slice…, pero su largo es fijo: no hay push ni pop.

const muestras = new Float32Array([0.25, 0.5, -1.5]);
console.log(muestras.map((x) => x * 2));

const enteros = new Uint8Array([250, 10]);
enteros[0] += 10;   // 260 no cabe: da la vuelta a 4
console.log(enteros);

const limitados = new Uint8ClampedArray([250]);
limitados[0] += 10; // se queda en 255
console.log(limitados);

Float16Array (ES2025) ocupa la mitad que Float32Array con menos precisión. Se usa en gráficos y en modelos de aprendizaje automático, donde la memoria importa más que los decimales.

DataView

Cuando un formato mezcla tipos (un archivo con un entero de 2 bytes, después uno de 4…), DataView lee y escribe cualquier tipo en cualquier posición:

const datos = new DataView(new ArrayBuffer(6));

datos.setUint16(0, 2026);       // 2 bytes en la posición 0
datos.setFloat32(2, 1.5);       // 4 bytes en la posición 2

console.log(datos.getUint16(0), datos.getFloat32(2));

Buffers que crecen (ES2024)

Un buffer puede crearse redimensionable, con un tamaño máximo:

const buffer = new ArrayBuffer(4, { maxByteLength: 16 });
const vista = new Uint8Array(buffer);  // sin largo fijo: sigue al buffer

console.log(buffer.resizable, vista.length);
buffer.resize(12);
console.log(vista.length);

const movido = buffer.transfer();      // traspasa la memoria a un buffer nuevo
console.log(buffer.detached, movido.byteLength);

transfer mueve la memoria sin copiarla y deja el buffer original inutilizable (detached). Es útil para pasar datos grandes a otra parte del programa, o a un worker, sin duplicarlos.

Base64 y hexadecimal (ES2026)

Para enviar bytes donde solo se admite texto (JSON, una URL, un correo), se codifican en base64 o en hexadecimal. Desde ES2026, Uint8Array lo hace directamente:

const texto = "¡Hola!";
const bytes = new TextEncoder().encode(texto);  // texto → bytes UTF-8

console.log(bytes.toBase64());
console.log(bytes.toHex());

const deVuelta = Uint8Array.fromBase64(bytes.toBase64());
console.log(new TextDecoder().decode(deVuelta));
console.log(Uint8Array.fromHex("4a53"));

Resumen

  • ArrayBuffer guarda bytes; las vistas (arrays tipados, DataView) los interpretan.
  • Los arrays tipados tienen largo fijo y sus valores dan la vuelta al salirse de rango (salvo Uint8ClampedArray).
  • DataView lee y escribe tipos mezclados en cualquier posición.
  • ES2024: buffers redimensionables (resize) y transfer.
  • ES2025: Float16Array. ES2026: toBase64, fromBase64, toHex y fromHex.
  • TextEncoder y TextDecoder convierten entre texto y bytes UTF-8.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Bytes, buffers y vistas

Elige una respuesta en cada pregunta.

  1. ¿Qué es un ArrayBuffer?

  2. ¿Qué pasa al guardar 300 en un Uint8Array?

  3. ¿Qué agregó ES2026 a Uint8Array?

  4. ¿Qué permite un ArrayBuffer redimensionable (ES2024)?

Ordena la salida: Desbordes, vistas y base64

Un byte que se desborda, dos vistas del mismo buffer y dos conversiones. Ordena lo que aparecería en la consola.

const bytes = new Uint8Array([250, 5]);bytes[0] += 20;console.log(bytes[0]); const buffer = new ArrayBuffer(4);const vista8 = new Uint8Array(buffer);const vista32 = new Uint32Array(buffer);console.log(vista8.byteLength, vista32.length); console.log(new Uint8Array([72, 105]).toHex());console.log(Uint8Array.fromBase64("SG9sYQ==").length);

Consola, de arriba abajo

  1. 4869
  2. 14
  3. 4
  4. 4 1

Detective: Agregar a un array tipado

Se quería guardar una muestra de audio. Encuentra la línea que falla y elige el arreglo.

Consola

audio.js:3
muestras.push(0.5);
         ^

TypeError: muestras.push is not a function

Paso 1: toca la línea de código que causa el error.

Laboratorio: Decodificar base64

Escribe decodificar(texto64): de base64 a bytes, y de bytes a texto.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime Hola, mundo (pendiente)
  • Funciona con otros textos, incluidos los acentos (pendiente)
  • Usa Uint8Array.fromBase64 (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.