JSONL en JavaScript: Leer, Escribir y Parsear

Una guia completa para trabajar con archivos JSONL (JSON Lines) en JavaScript. Aprende a leer, escribir, parsear y transmitir datos JSONL tanto en Node.js como en el navegador usando APIs nativas y bibliotecas populares.

Ultima actualizacion: febrero 2026

Por que JavaScript para JSONL?

JavaScript es una opcion natural para trabajar con archivos JSONL. JSON nacio de JavaScript, por lo que el lenguaje tiene soporte nativo de parseo a traves de los metodos integrados JSON.parse() y JSON.stringify(). Ya sea que estes construyendo un pipeline de datos en Node.js, procesando archivos de registro en un servidor o permitiendo que los usuarios suban JSONL en el navegador, JavaScript te proporciona las herramientas para manejar cada paso.

JSONL (JSON Lines) almacena un objeto JSON por linea, lo que lo hace ideal para streaming, registro de solo adicion y procesamiento de grandes conjuntos de datos linea por linea. Los streams de Node.js se alinean perfectamente con este formato, permitiendote leer y transformar millones de registros sin agotar la memoria. En el lado del cliente, las APIs FileReader y Streams del navegador permiten el procesamiento JSONL completamente en el dispositivo del usuario. En esta guia, aprenderas a leer JSONL tanto en Node.js como en el navegador, escribir archivos JSONL, construir pipelines de transformacion con streams y elegir la biblioteca npm adecuada para tu proyecto.

Leer JSONL en Node.js

Node.js proporciona el modulo readline para leer archivos linea por linea de forma eficiente. Combinado con fs.createReadStream, esta es la forma recomendada de procesar archivos JSONL en el servidor porque transmite los datos en lugar de cargar el archivo completo en memoria.

Usa fs.createReadStream canalizado a readline.createInterface para leer un archivo JSONL linea por linea. Este enfoque utiliza memoria minima independientemente del tamano del archivo.

Lectura con Streaming usando readline
import { createReadStream } from 'node:fs';
import { createInterface } from 'node:readline';


async function readJsonl(filePath) {
  const records = [];
  const rl = createInterface({
    input: createReadStream(filePath, 'utf-8'),
    crlfDelay: Infinity,
  });


  for await (const line of rl) {
    const trimmed = line.trim();
    if (trimmed) {
      records.push(JSON.parse(trimmed));
    }
  }
  return records;
}


// Usage
const data = await readJsonl('data.jsonl');
console.log(`Loaded ${data.length} records`);
console.log(data[0]);

Para archivos JSONL pequenos que caben comodamente en memoria, puedes leer el archivo completo de una vez y dividir por salto de linea. Esto intercambia eficiencia de streaming por simplicidad.

Lectura Rapida en Una Linea (Archivos Pequenos)
import { readFileSync } from 'node:fs';


const records = readFileSync('data.jsonl', 'utf-8')
  .split('\n')
  .filter(line => line.trim())
  .map(line => JSON.parse(line));


console.log(`Loaded ${records.length} records`);

Leer JSONL en el Navegador

En el navegador, los usuarios pueden subir archivos JSONL a traves de un input de archivo. Puedes leer el archivo usando la API FileReader o la API moderna de Streams, todo sin enviar datos a un servidor.

Usa FileReader para leer un archivo seleccionado por el usuario, luego divide el contenido de texto en lineas y parsea cada una. Esto mantiene todos los datos del lado del cliente para privacidad.

API FileReader del Navegador
function parseJsonlFile(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = () => {
      const text = reader.result;
      const records = text
        .split('\n')
        .filter(line => line.trim())
        .map(line => JSON.parse(line));
      resolve(records);
    };
    reader.onerror = () => reject(reader.error);
    reader.readAsText(file, 'utf-8');
  });
}


// Usage with an <input type="file"> element
const input = document.querySelector('input[type="file"]');
input.addEventListener('change', async (e) => {
  const file = e.target.files[0];
  const records = await parseJsonlFile(file);
  console.log(`Parsed ${records.length} records`);
});

Para archivos grandes en el navegador, usa la API Streams con TextDecoderStream para procesar el archivo fragmento por fragmento. Esto evita cargar el archivo completo en memoria de una vez.

API Streams del Navegador (Archivos Grandes)
async function* streamJsonl(file) {
  const stream = file.stream()
    .pipeThrough(new TextDecoderStream());
  const reader = stream.getReader();
  let buffer = '';


  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buffer += value;
    const lines = buffer.split('\n');
    buffer = lines.pop(); // Keep incomplete last line
    for (const line of lines) {
      const trimmed = line.trim();
      if (trimmed) yield JSON.parse(trimmed);
    }
  }
  // Handle remaining buffer
  if (buffer.trim()) {
    yield JSON.parse(buffer.trim());
  }
}


// Usage
for await (const record of streamJsonl(file)) {
  console.log(record);
}

Escribir JSONL en Node.js

Escribir archivos JSONL en Node.js es sencillo: serializa cada objeto JavaScript a una cadena JSON y anade un caracter de nueva linea. Para mejor rendimiento con grandes conjuntos de datos, usa un stream de escritura en lugar de construir la cadena completa en memoria.

Usa fs.writeFileSync o fs.createWriteStream para escribir registros en un archivo JSONL. Cada registro es una sola linea de JSON valido seguida de un salto de linea.

Escritura Basica con fs
import { writeFileSync } from 'node:fs';


const records = [
  { id: 1, name: 'Alice', role: 'engineer' },
  { id: 2, name: 'Bob', role: 'designer' },
  { id: 3, name: 'Charlie', role: 'manager' },
];


const jsonl = records
  .map(record => JSON.stringify(record))
  .join('\n') + '\n';


writeFileSync('output.jsonl', jsonl, 'utf-8');
console.log(`Wrote ${records.length} records`);

Al escribir millones de registros, usa un stream de escritura para evitar construir la cadena de salida completa en memoria. El stream maneja la contrapresion automaticamente, pausando tus escrituras cuando el buffer del sistema operativo esta lleno.

Escritura con Streaming para Grandes Volumenes
import { createWriteStream } from 'node:fs';


async function writeJsonl(filePath, records) {
  const stream = createWriteStream(filePath, 'utf-8');


  for (const record of records) {
    const line = JSON.stringify(record) + '\n';
    // Respect backpressure
    if (!stream.write(line)) {
      await new Promise(resolve => stream.once('drain', resolve));
    }
  }


  stream.end();
  await new Promise(resolve => stream.on('finish', resolve));
  console.log('Write complete');
}


// Usage
const data = Array.from({ length: 100000 }, (_, i) => ({
  id: i + 1,
  value: Math.random(),
  timestamp: new Date().toISOString(),
}));


await writeJsonl('large_output.jsonl', data);

Transform Streams para Pipelines JSONL

Los Transform streams de Node.js te permiten construir pipelines de datos componibles que leen JSONL, procesan cada registro y escriben los resultados. Este patron es ideal para trabajos ETL, procesamiento de logs y migracion de datos.

Transform Streams para Pipelines JSONL
import { createReadStream, createWriteStream } from 'node:fs';
import { createInterface } from 'node:readline';
import { Transform } from 'node:stream';
import { pipeline } from 'node:stream/promises';


// Transform: parse JSONL line into object, process, stringify back
const transformJsonl = new Transform({
  objectMode: true,
  transform(chunk, encoding, callback) {
    const line = chunk.toString().trim();
    if (!line) return callback();
    try {
      const record = JSON.parse(line);
      // Add your transformation here
      record.processed = true;
      record.processedAt = new Date().toISOString();
      callback(null, JSON.stringify(record) + '\n');
    } catch (err) {
      callback(err);
    }
  },
});


// Build the pipeline
const rl = createInterface({
  input: createReadStream('input.jsonl', 'utf-8'),
  crlfDelay: Infinity,
});


const output = createWriteStream('output.jsonl', 'utf-8');


for await (const line of rl) {
  transformJsonl.write(line);
}
transformJsonl.end();
await pipeline(transformJsonl, output);
console.log('Pipeline complete');

Este pipeline lee un archivo JSONL linea por linea, aplica una transformacion a cada registro (anadiendo los campos processed y processedAt) y escribe los resultados en un nuevo archivo. El Transform stream maneja la contrapresion automaticamente, por lo que el uso de memoria se mantiene constante incluso para archivos muy grandes. Puedes encadenar multiples transformaciones para flujos de trabajo ETL complejos.

Bibliotecas JavaScript para JSONL

Aunque el JSON.parse integrado maneja bien la mayoria de los casos, varios paquetes npm proporcionan utilidades convenientes para flujos de trabajo especificos de JSONL como streaming, validacion y procesamiento por lotes.

JSON.parse (Integrado)

Integrado

Los metodos integrados JSON.parse() y JSON.stringify() estan altamente optimizados en V8 y son suficientes para la mayoria de los casos de uso JSONL. Combinalos con readline para streaming. No se necesitan dependencias y el rendimiento es excelente para archivos de hasta varios cientos de MB.

ndjson

Popular

ndjson es un paquete npm popular que proporciona parseadores y serializadores de JSONL (Newline Delimited JSON) con streaming compatibles con los streams de Node.js. Maneja errores de parseo de forma elegante y se integra bien con pipelines de streams existentes. Ideal para prototipado rapido.

jsonl-parse-stringify

Simple

jsonl-parse-stringify es una biblioteca ligera y sin dependencias que proporciona metodos simples parse() y stringify() para datos JSONL. Maneja casos especiales como saltos de linea finales y lineas vacias. Ideal cuando quieres una API sincrona limpia sin configuracion de streams.

Prueba Nuestras Herramientas JSONL Gratuitas

No quieres escribir codigo? Usa nuestras herramientas online gratuitas para visualizar, convertir y formatear archivos JSONL directamente en tu navegador. Todo el procesamiento ocurre localmente, asi que tus datos permanecen privados.

JSONL streaming guide
large JSONL files
JSONL validator

Trabaja con Archivos JSONL Online

Visualiza, valida y convierte archivos JSONL de hasta 1GB directamente en tu navegador. Sin subidas, 100% privado.

Preguntas Frecuentes

JSONL en JavaScript — Leer, escribir y transmitir JSON Li...