JSONL in JavaScript: Lezen, Schrijven & Parseren

Een complete gids voor het werken met JSONL (JSON Lines)-bestanden in JavaScript. Leer hoe je JSONL-gegevens kunt lezen, schrijven, parseren en streamen in zowel Node.js als de browser met ingebouwde API's en populaire bibliotheken.

Laatst bijgewerkt: februari 2026

Waarom JavaScript voor JSONL?

JavaScript is een natuurlijke keuze voor het werken met JSONL-bestanden. JSON zelf is ontstaan uit JavaScript, dus de taal heeft eersteklas parseerondersteuning via de ingebouwde JSON.parse() en JSON.stringify() methoden. Of je nu een Node.js-datapipeline bouwt, logbestanden verwerkt op een server, of gebruikers JSONL laat uploaden in de browser, JavaScript geeft je de tools om elke stap af te handelen.

JSONL (JSON Lines) slaat één JSON-object per regel op, waardoor het ideaal is voor streaming, append-only logging en het regel voor regel verwerken van grote datasets. Node.js streams sluiten perfect aan bij dit formaat, zodat je miljoenen records kunt lezen en transformeren zonder geheugengebrek te krijgen. Aan de clientzijde maken de browser FileReader en Streams API's JSONL-verwerking volledig op het apparaat van de gebruiker mogelijk. In deze gids leer je hoe je JSONL kunt lezen in zowel Node.js als de browser, JSONL-bestanden kunt schrijven, streaming transformatiepipelines kunt bouwen en de juiste npm-bibliotheek voor je project kunt kiezen.

JSONL Lezen in Node.js

Node.js biedt de readline-module om bestanden efficiënt regel voor regel te lezen. In combinatie met fs.createReadStream is dit de aanbevolen manier om JSONL-bestanden op de server te verwerken, omdat het de gegevens streamt in plaats van het hele bestand in het geheugen te laden.

Gebruik fs.createReadStream doorgestuurd naar readline.createInterface om een JSONL-bestand regel voor regel te lezen. Deze aanpak gebruikt minimaal geheugen, ongeacht de bestandsgrootte.

Stream Lezen met 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]);

Voor kleine JSONL-bestanden die comfortabel in het geheugen passen, kun je het hele bestand in één keer lezen en splitsen op nieuwe regel. Dit ruilt streaming-efficiëntie in voor eenvoud.

Snelle One-Liner (Kleine Bestanden)
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`);

JSONL Lezen in de Browser

In de browser kunnen gebruikers JSONL-bestanden uploaden via een bestandsinvoer. Je kunt het bestand lezen met de FileReader API of de moderne Streams API, allemaal zonder gegevens naar een server te sturen.

Gebruik FileReader om een door de gebruiker geselecteerd bestand te lezen, splits vervolgens de tekstinhoud in regels en parseer elke regel. Dit houdt alle gegevens aan de clientzijde voor privacy.

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

Voor grote bestanden in de browser gebruik je de Streams API met TextDecoderStream om het bestand blok voor blok te verwerken. Dit voorkomt dat het hele bestand in één keer in het geheugen wordt geladen.

Browser Streams API (Grote Bestanden)
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);
}

JSONL Schrijven in Node.js

JSONL-bestanden schrijven in Node.js is eenvoudig: serialiseer elk JavaScript-object naar een JSON-string en voeg een nieuwregelteken toe. Voor de beste prestaties met grote datasets gebruik je een schrijfstream in plaats van de hele string in het geheugen op te bouwen.

Gebruik fs.writeFileSync of fs.createWriteStream om records naar een JSONL-bestand te schrijven. Elk record is een enkele regel van geldige JSON gevolgd door een nieuwregel.

Basis Schrijven met 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`);

Bij het schrijven van miljoenen records gebruik je een beschrijfbare stream om te voorkomen dat de hele uitvoerstring in het geheugen wordt opgebouwd. De stream handelt backpressure automatisch af en pauzeert je schrijfbewerkingen wanneer de OS-buffer vol is.

Streaming Schrijven voor Grote Data
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 voor JSONL-pipelines

Node.js Transform streams laten je samenstellbare datapipelines bouwen die JSONL lezen, elk record verwerken en de resultaten schrijven. Dit patroon is ideaal voor ETL-taken, logverwerking en datamigratie.

Transform Streams voor JSONL-pipelines
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');

Deze pipeline leest een JSONL-bestand regel voor regel, past een transformatie toe op elk record (voegt processed en processedAt velden toe), en schrijft de resultaten naar een nieuw bestand. De Transform stream handelt backpressure automatisch af, zodat het geheugengebruik constant blijft, zelfs voor zeer grote bestanden. Je kunt meerdere transforms koppelen voor complexe ETL-workflows.

JavaScript-bibliotheken voor JSONL

Hoewel de ingebouwde JSON.parse de meeste gevallen goed afhandelt, bieden verschillende npm-pakketten handige hulpmiddelen voor JSONL-specifieke workflows zoals streaming, validatie en batchverwerking.

JSON.parse (Ingebouwd)

Ingebouwd

De ingebouwde JSON.parse() en JSON.stringify() zijn sterk geoptimaliseerd in V8 en voldoende voor de meeste JSONL-toepassingen. Combineer ze met readline voor streaming. Geen afhankelijkheden nodig, en de prestaties zijn uitstekend voor bestanden tot enkele honderden MB.

ndjson

Populair

ndjson is een populair npm-pakket dat streaming JSONL (Newline Delimited JSON) parsers en serializers biedt die compatibel zijn met Node.js streams. Het gaat elegant om met parseerfouten en integreert goed met bestaande stream-pipelines. Uitstekend voor snelle prototyping.

jsonl-parse-stringify

Eenvoudig

jsonl-parse-stringify is een lichtgewicht bibliotheek zonder afhankelijkheden die eenvoudige parse() en stringify() methoden biedt voor JSONL-gegevens. Het handelt randgevallen af zoals achterliggende nieuwe regels en lege regels. Ideaal wanneer je een schone synchrone API wilt zonder stream-setup.

Probeer Onze Gratis JSONL-tools

Wil je geen code schrijven? Gebruik onze gratis online tools om JSONL-bestanden te bekijken, converteren en formatteren in je browser. Alle verwerking gebeurt lokaal, zodat je gegevens privé blijven.

JSONL streaming guide
large JSONL files
JSONL validator

Werk met JSONL-bestanden Online

Bekijk, valideer en converteer JSONL-bestanden tot 1GB direct in je browser. Geen uploads nodig, 100% privé.

Veelgestelde Vragen

JSONL in JavaScript — Lezen, schrijven & streamen van JSO...