JSONL em JavaScript: Ler, Escrever e Parsear

Um guia completo para trabalhar com arquivos JSONL (JSON Lines) em JavaScript. Aprenda a ler, escrever, parsear e transmitir dados JSONL tanto em Node.js quanto no navegador usando APIs nativas e bibliotecas populares.

Ultima atualizacao: fevereiro de 2026

Por que JavaScript para JSONL?

JavaScript e uma escolha natural para trabalhar com arquivos JSONL. O proprio JSON nasceu do JavaScript, entao a linguagem tem suporte nativo de parseamento atraves dos metodos JSON.parse() e JSON.stringify(). Seja construindo um pipeline de dados em Node.js, processando arquivos de log em um servidor, ou permitindo que usuarios enviem JSONL no navegador, o JavaScript fornece as ferramentas para lidar com cada etapa.

JSONL (JSON Lines) armazena um objeto JSON por linha, tornando-o ideal para streaming, logging append-only e processamento de grandes datasets linha por linha. Os streams do Node.js se alinham perfeitamente com esse formato, permitindo ler e transformar milhoes de registros sem ficar sem memoria. No lado do cliente, as APIs FileReader e Streams do navegador permitem o processamento de JSONL inteiramente no dispositivo do usuario. Neste guia, voce aprendera como ler JSONL tanto em Node.js quanto no navegador, escrever arquivos JSONL, construir pipelines de transformacao com streaming e escolher a biblioteca npm certa para seu projeto.

Lendo JSONL em Node.js

O Node.js fornece o modulo readline para ler arquivos linha por linha de forma eficiente. Combinado com fs.createReadStream, esta e a maneira recomendada de processar arquivos JSONL no servidor porque transmite os dados em vez de carregar o arquivo inteiro na memoria.

Use fs.createReadStream canalizado para readline.createInterface para ler um arquivo JSONL uma linha por vez. Esta abordagem usa memoria minima independentemente do tamanho do arquivo.

Leitura com 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 arquivos JSONL pequenos que cabem confortavelmente na memoria, voce pode ler o arquivo inteiro de uma vez e dividir por quebra de linha. Isso troca eficiencia de streaming por simplicidade.

Leitura Rapida em Uma Linha (Arquivos 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`);

Lendo JSONL no Navegador

No navegador, os usuarios podem enviar arquivos JSONL atraves de um input de arquivo. Voce pode ler o arquivo usando a API FileReader ou a API moderna de Streams, tudo sem enviar dados para um servidor.

Use o FileReader para ler um arquivo selecionado pelo usuario, depois divida o conteudo de texto em linhas e parseie cada uma. Isso mantem todos os dados no lado do cliente para privacidade.

API FileReader do 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 arquivos grandes no navegador, use a API Streams com TextDecoderStream para processar o arquivo em blocos. Isso evita carregar o arquivo inteiro na memoria de uma vez.

API Streams do Navegador (Arquivos 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);
}

Escrevendo JSONL em Node.js

Escrever arquivos JSONL em Node.js e simples: serialize cada objeto JavaScript para uma string JSON e adicione um caractere de nova linha. Para melhor desempenho com grandes datasets, use um write stream em vez de construir a string inteira na memoria.

Use fs.writeFileSync ou fs.createWriteStream para escrever registros em um arquivo JSONL. Cada registro e uma unica linha de JSON valido seguida por uma quebra de linha.

Escrita Basica com 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`);

Ao escrever milhoes de registros, use um writable stream para evitar construir a string de saida inteira na memoria. O stream lida com backpressure automaticamente, pausando suas escritas quando o buffer do SO esta cheio.

Escrita com Streaming para Grandes Volumes
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

Os Transform streams do Node.js permitem construir pipelines de dados composiveis que leem JSONL, processam cada registro e escrevem os resultados. Esse padrao e ideal para trabalhos ETL, processamento de logs e migracao de dados.

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 le um arquivo JSONL linha por linha, aplica uma transformacao a cada registro (adicionando os campos processed e processedAt) e escreve os resultados em um novo arquivo. O Transform stream lida com backpressure automaticamente, entao o uso de memoria permanece constante mesmo para arquivos muito grandes. Voce pode encadear multiplas transformacoes para workflows ETL complexos.

Bibliotecas JavaScript para JSONL

Embora o JSON.parse nativo lide com a maioria dos casos, varios pacotes npm fornecem utilitarios convenientes para workflows especificos de JSONL como streaming, validacao e processamento em lote.

JSON.parse (Nativo)

Nativo

Os metodos nativos JSON.parse() e JSON.stringify() sao altamente otimizados no V8 e suficientes para a maioria dos casos de uso JSONL. Combine-os com readline para streaming. Nenhuma dependencia necessaria, e o desempenho e excelente para arquivos de ate varias centenas de MB.

ndjson

Popular

ndjson e um pacote npm popular que fornece parsers e serializers de streaming JSONL (Newline Delimited JSON) compativeis com streams do Node.js. Ele lida com erros de parseamento de forma elegante e se integra bem com pipelines de stream existentes. Otimo para prototipagem rapida.

jsonl-parse-stringify

Simples

jsonl-parse-stringify e uma biblioteca leve, sem dependencias, que fornece metodos simples parse() e stringify() para dados JSONL. Ela lida com casos especiais como quebras de linha finais e linhas vazias. Ideal quando voce quer uma API sincrona limpa sem configuracao de stream.

Experimente Nossas Ferramentas JSONL Gratuitas

Nao quer escrever codigo? Use nossas ferramentas online gratuitas para visualizar, converter e formatar arquivos JSONL diretamente no seu navegador. Todo o processamento acontece localmente, entao seus dados permanecem privados.

JSONL streaming guide
large JSONL files
JSONL validator

Trabalhe com Arquivos JSONL Online

Visualize, valide e converta arquivos JSONL de ate 1GB diretamente no seu navegador. Sem uploads, 100% privado.

Perguntas Frequentes

JSONL em JavaScript — Ler, Escrever e Streaming de JSON L...