JSONL in JavaScript: Lettura, Scrittura e Parsing

Una guida completa per lavorare con file JSONL (JSON Lines) in JavaScript. Impara a leggere, scrivere, analizzare e trasmettere in streaming dati JSONL sia in Node.js che nel browser, utilizzando API native e librerie popolari.

Ultimo aggiornamento: Febbraio 2026

Perché JavaScript per JSONL?

JavaScript è una scelta naturale per lavorare con file JSONL. JSON stesso è nato da JavaScript, quindi il linguaggio offre supporto nativo al parsing tramite i metodi integrati JSON.parse() e JSON.stringify(). Che tu stia costruendo una pipeline di dati in Node.js, elaborando file di log su un server o permettendo agli utenti di caricare JSONL nel browser, JavaScript ti fornisce gli strumenti per gestire ogni passaggio.

JSONL (JSON Lines) memorizza un oggetto JSON per riga, rendendolo ideale per lo streaming, il logging di tipo append-only e l'elaborazione di grandi dataset riga per riga. Gli stream di Node.js si allineano perfettamente con questo formato, permettendoti di leggere e trasformare milioni di record senza esaurire la memoria. Lato client, le API FileReader e Streams del browser consentono l'elaborazione JSONL interamente sul dispositivo dell'utente. In questa guida imparerai come leggere JSONL sia in Node.js che nel browser, scrivere file JSONL, costruire pipeline di trasformazione in streaming e scegliere la libreria npm giusta per il tuo progetto.

Leggere JSONL in Node.js

Node.js fornisce il modulo readline per leggere file in modo efficiente riga per riga. Combinato con fs.createReadStream, questo è il metodo consigliato per elaborare file JSONL sul server perché trasmette i dati in streaming invece di caricare l'intero file in memoria.

Usa fs.createReadStream collegato a readline.createInterface per leggere un file JSONL una riga alla volta. Questo approccio utilizza una quantità minima di memoria indipendentemente dalla dimensione del file.

Lettura in streaming con 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]);

Per file JSONL piccoli che entrano comodamente in memoria, puoi leggere l'intero file in una volta e dividere per nuova riga. Questo sacrifica l'efficienza dello streaming in favore della semplicità.

One-Liner Rapido (File Piccoli)
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`);

Leggere JSONL nel Browser

Nel browser, gli utenti possono caricare file JSONL tramite un input file. Puoi leggere il file utilizzando l'API FileReader o la moderna API Streams, il tutto senza inviare dati a un server.

Usa FileReader per leggere un file selezionato dall'utente, poi dividi il contenuto testuale in righe e analizza ciascuna. Questo mantiene tutti i dati lato client per la privacy.

API FileReader del Browser
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`);
});

Per file grandi nel browser, usa l'API Streams con TextDecoderStream per elaborare il file blocco per blocco. Questo evita di caricare l'intero file in memoria contemporaneamente.

API Streams del Browser (File Grandi)
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);
}

Scrivere JSONL in Node.js

Scrivere file JSONL in Node.js è semplice: serializza ogni oggetto JavaScript in una stringa JSON e aggiungi un carattere di nuova riga. Per le migliori prestazioni con grandi dataset, usa un write stream invece di costruire l'intera stringa in memoria.

Usa fs.writeFileSync o fs.createWriteStream per scrivere record in un file JSONL. Ogni record è una singola riga di JSON valido seguita da una nuova riga.

Scrittura Base 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`);

Quando si scrivono milioni di record, usa un writable stream per evitare di costruire l'intera stringa di output in memoria. Lo stream gestisce automaticamente la backpressure, mettendo in pausa le scritture quando il buffer del sistema operativo è pieno.

Scrittura in Streaming per Grandi Quantità di Dati
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 Stream per Pipeline JSONL

I Transform stream di Node.js ti permettono di costruire pipeline di dati componibili che leggono JSONL, elaborano ogni record e scrivono i risultati. Questo pattern è ideale per job ETL, elaborazione di log e migrazione di dati.

Transform Stream per Pipeline 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');

Questa pipeline legge un file JSONL riga per riga, applica una trasformazione a ogni record (aggiungendo i campi processed e processedAt) e scrive i risultati in un nuovo file. Il Transform stream gestisce automaticamente la backpressure, quindi l'uso di memoria resta costante anche per file molto grandi. Puoi concatenare più trasformazioni per flussi di lavoro ETL complessi.

Librerie JavaScript per JSONL

Mentre il JSON.parse integrato gestisce bene la maggior parte dei casi, diversi pacchetti npm forniscono utility comode per flussi di lavoro specifici per JSONL come streaming, validazione ed elaborazione batch.

JSON.parse (Integrato)

Integrato

I metodi integrati JSON.parse() e JSON.stringify() sono altamente ottimizzati in V8 e sufficienti per la maggior parte dei casi d'uso JSONL. Combinali con readline per lo streaming. Nessuna dipendenza necessaria e prestazioni eccellenti per file fino a diverse centinaia di MB.

ndjson

Popolare

ndjson è un pacchetto npm popolare che fornisce parser e serializzatori JSONL (Newline Delimited JSON) in streaming, compatibili con gli stream di Node.js. Gestisce gli errori di parsing in modo elegante e si integra bene con le pipeline di stream esistenti. Ottimo per la prototipazione rapida.

jsonl-parse-stringify

Semplice

jsonl-parse-stringify è una libreria leggera senza dipendenze che fornisce metodi semplici parse() e stringify() per dati JSONL. Gestisce casi limite come nuove righe finali e righe vuote. Ideale quando vuoi un'API sincrona pulita senza configurare gli stream.

Prova i Nostri Strumenti JSONL Gratuiti

Non vuoi scrivere codice? Usa i nostri strumenti online gratuiti per visualizzare, convertire e formattare file JSONL direttamente nel tuo browser. Tutta l'elaborazione avviene localmente, quindi i tuoi dati restano privati.

JSONL streaming guide
large JSONL files
JSONL validator

Lavora con File JSONL Online

Visualizza, valida e converti file JSONL fino a 1GB direttamente nel tuo browser. Nessun upload richiesto, 100% privato.

Domande Frequenti

JSONL in JavaScript — Leggere, Scrivere e Streaming JSON ...