JSONL in JavaScript: Lesen, Schreiben & Parsen

Eine vollständige Anleitung zur Arbeit mit JSONL (JSON Lines)-Dateien in JavaScript. Lernen Sie das Lesen, Schreiben, Parsen und Streamen von JSONL-Daten sowohl in Node.js als auch im Browser mit integrierten APIs und beliebten Bibliotheken.

Letzte Aktualisierung: Februar 2026

Warum JavaScript für JSONL?

JavaScript eignet sich hervorragend für die Arbeit mit JSONL-Dateien. JSON selbst stammt aus JavaScript, sodass die Sprache erstklassige Parsing-Unterstützung durch die integrierten Methoden JSON.parse() und JSON.stringify() bietet. Ob Sie eine Node.js-Datenpipeline aufbauen, Protokolldateien auf einem Server verarbeiten oder Benutzern das Hochladen von JSONL im Browser ermöglichen – JavaScript bietet Ihnen die Werkzeuge für jeden Schritt.

JSONL (JSON Lines) speichert ein JSON-Objekt pro Zeile und ist damit ideal für Streaming, Append-Only-Protokollierung und die zeilenweise Verarbeitung großer Datensätze. Node.js-Streams passen perfekt zu diesem Format und ermöglichen das Lesen und Transformieren von Millionen Datensätzen, ohne den Speicher zu erschöpfen. Auf der Client-Seite ermöglichen die Browser FileReader und Streams APIs die JSONL-Verarbeitung vollständig auf dem Gerät des Benutzers. In dieser Anleitung erfahren Sie, wie Sie JSONL sowohl in Node.js als auch im Browser lesen, JSONL-Dateien schreiben, Streaming-Transform-Pipelines aufbauen und die richtige npm-Bibliothek für Ihr Projekt wählen.

JSONL in Node.js lesen

Node.js bietet das readline-Modul zum effizienten zeilenweisen Lesen von Dateien. In Kombination mit fs.createReadStream ist dies die empfohlene Methode zur Verarbeitung von JSONL-Dateien auf dem Server, da die Daten gestreamt werden, anstatt die gesamte Datei in den Speicher zu laden.

Verwenden Sie fs.createReadStream zusammen mit readline.createInterface, um eine JSONL-Datei Zeile für Zeile zu lesen. Dieser Ansatz verbraucht minimalen Speicher, unabhängig von der Dateigröße.

Stream-Lesen mit 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]);

Für kleine JSONL-Dateien, die bequem in den Speicher passen, können Sie die gesamte Datei auf einmal lesen und nach Zeilenumbrüchen aufteilen. Dies opfert Streaming-Effizienz zugunsten von Einfachheit.

Schneller Einzeiler (kleine Dateien)
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 im Browser lesen

Im Browser können Benutzer JSONL-Dateien über ein Datei-Eingabefeld hochladen. Sie können die Datei mit der FileReader API oder der modernen Streams API lesen – ganz ohne Daten an einen Server zu senden.

Verwenden Sie FileReader, um eine vom Benutzer ausgewählte Datei zu lesen, den Textinhalt in Zeilen aufzuteilen und jede einzelne zu parsen. So bleiben alle Daten clientseitig und privat.

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

Für große Dateien im Browser verwenden Sie die Streams API mit TextDecoderStream, um die Datei Stück für Stück zu verarbeiten. So wird vermieden, dass die gesamte Datei auf einmal in den Speicher geladen wird.

Browser Streams API (große Dateien)
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 in Node.js schreiben

Das Schreiben von JSONL-Dateien in Node.js ist unkompliziert: Serialisieren Sie jedes JavaScript-Objekt als JSON-String und hängen Sie ein Zeilenumbruchzeichen an. Für beste Leistung bei großen Datensätzen verwenden Sie einen Write-Stream, anstatt den gesamten String im Speicher aufzubauen.

Verwenden Sie fs.writeFileSync oder fs.createWriteStream, um Datensätze in eine JSONL-Datei zu schreiben. Jeder Datensatz ist eine einzelne Zeile mit gültigem JSON, gefolgt von einem Zeilenumbruch.

Einfaches Schreiben mit 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`);

Beim Schreiben von Millionen Datensätzen verwenden Sie einen Writable Stream, um den Aufbau des gesamten Ausgabestrings im Speicher zu vermeiden. Der Stream verwaltet Backpressure automatisch und pausiert Ihre Schreibvorgänge, wenn der OS-Puffer voll ist.

Streaming-Schreiben für große Datenmengen
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 für JSONL-Pipelines

Node.js Transform Streams ermöglichen den Aufbau zusammensetzbarer Datenpipelines, die JSONL lesen, jeden Datensatz verarbeiten und die Ergebnisse schreiben. Dieses Muster ist ideal für ETL-Jobs, Protokollverarbeitung und Datenmigration.

Transform Streams für 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');

Diese Pipeline liest eine JSONL-Datei Zeile für Zeile, wendet eine Transformation auf jeden Datensatz an (fügt die Felder processed und processedAt hinzu) und schreibt die Ergebnisse in eine neue Datei. Der Transform Stream verwaltet Backpressure automatisch, sodass der Speicherverbrauch auch bei sehr großen Dateien konstant bleibt. Sie können mehrere Transforms für komplexe ETL-Workflows verketten.

JavaScript-Bibliotheken für JSONL

Während das integrierte JSON.parse die meisten Fälle gut abdeckt, bieten mehrere npm-Pakete praktische Hilfsmittel für JSONL-spezifische Workflows wie Streaming, Validierung und Stapelverarbeitung.

JSON.parse (integriert)

Integriert

Die integrierten JSON.parse() und JSON.stringify() sind in V8 hochoptimiert und für die meisten JSONL-Anwendungsfälle ausreichend. Kombinieren Sie sie mit readline für Streaming. Keine Abhängigkeiten nötig, und die Leistung ist für Dateien bis zu mehreren hundert MB hervorragend.

ndjson

Beliebt

ndjson ist ein beliebtes npm-Paket, das Streaming-JSONL (Newline Delimited JSON) Parser und Serialisierer bereitstellt, die mit Node.js Streams kompatibel sind. Es behandelt Parse-Fehler graceful und integriert sich gut in bestehende Stream-Pipelines. Ideal für schnelles Prototyping.

jsonl-parse-stringify

Einfach

jsonl-parse-stringify ist eine leichtgewichtige Bibliothek ohne Abhängigkeiten, die einfache parse()- und stringify()-Methoden für JSONL-Daten bietet. Sie behandelt Randfälle wie abschließende Zeilenumbrüche und leere Zeilen. Ideal, wenn Sie eine saubere synchrone API ohne Stream-Einrichtung wünschen.

Probieren Sie unsere kostenlosen JSONL-Tools

Möchten Sie keinen Code schreiben? Verwenden Sie unsere kostenlosen Online-Tools zum Anzeigen, Konvertieren und Formatieren von JSONL-Dateien direkt in Ihrem Browser. Die gesamte Verarbeitung erfolgt lokal, sodass Ihre Daten privat bleiben.

JSONL streaming guide
large JSONL files
JSONL validator

JSONL-Dateien online bearbeiten

JSONL-Dateien bis zu 1 GB direkt in Ihrem Browser anzeigen, validieren und konvertieren. Kein Upload erforderlich, 100 % privat.

Häufig gestellte Fragen

JSONL in JavaScript — JSON Lines in Node lesen, schreiben...