- Startseite
- Anleitung
- JSONL in JavaScript: lesen, schreiben und parsen
JSONL in JavaScript: lesen, schreiben und parsen
Dieser Leitfaden zeigt Ihnen, wie Sie mit JSONL-Dateien (JSON Lines) in JavaScript arbeiten. Sie erfahren, wie Sie JSONL-Daten in Node.js und im Browser mit integrierten APIs und gängigen Bibliotheken lesen, schreiben, parsen und streamen.
Warum JavaScript für JSONL?
JavaScript eignet sich besonders gut für die Arbeit mit JSONL-Dateien. JSON hat seinen Ursprung in JavaScript, und mit den integrierten Methoden JSON.parse() und JSON.stringify() bringt die Sprache die nötigen Funktionen zum Parsen und Serialisieren bereits mit. Ob Sie eine Datenpipeline in Node.js entwickeln, Logdateien auf einem Server verarbeiten oder Benutzern das Hochladen von JSONL-Dateien im Browser ermöglichen: JavaScript bietet Ihnen die Werkzeuge für jeden Schritt.
JSONL (JSON Lines) speichert pro Zeile ein JSON-Objekt. Das macht das Format ideal für Streaming, für Logs, an die nur neue Einträge angehängt werden, und für die zeilenweise Verarbeitung großer Datenmengen. Node.js-Streams passen genau zu diesem Format: Damit können Sie Millionen von Datensätzen lesen und transformieren, ohne dass der Arbeitsspeicher ausgeht. Im Browser ermöglichen die FileReader- und Streams-APIs eine JSONL-Verarbeitung, die vollständig auf dem Gerät des Benutzers stattfindet. In diesem Leitfaden erfahren Sie, wie Sie JSONL in Node.js und im Browser lesen, JSONL-Dateien schreiben, Streaming-Pipelines zur Datentransformation aufbauen und die passende npm-Bibliothek für Ihr Projekt auswählen.
JSONL in Node.js lesen
Mit dem readline-Modul können Sie in Node.js Dateien effizient Zeile für Zeile lesen. Zusammen mit fs.createReadStream ist es die empfohlene Lösung für die Verarbeitung von JSONL-Dateien auf dem Server: Die Daten werden gestreamt, statt die gesamte Datei in den Arbeitsspeicher zu laden.
Übergeben Sie den von fs.createReadStream erzeugten Stream an readline.createInterface, um eine JSONL-Datei Zeile für Zeile zu lesen. Der Speicherbedarf bleibt dabei unabhängig von der Dateigröße gering.
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]);Kleine JSONL-Dateien, die problemlos in den Arbeitsspeicher passen, können Sie vollständig einlesen und an den Zeilenumbrüchen aufteilen. Das ist einfacher, verzichtet aber auf die Effizienz des Streamings.
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 Dateiauswahlfeld hochladen. Mit der FileReader-API oder der modernen Streams-API lesen Sie die Datei ein, ohne Daten an einen Server zu senden.
Lesen Sie eine vom Benutzer ausgewählte Datei mit FileReader ein, teilen Sie den Text in Zeilen auf und parsen Sie jede Zeile einzeln. Alle Daten bleiben dabei zum Schutz der Privatsphäre auf dem Gerät des Benutzers.
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`);
});Verwenden Sie für große Dateien im Browser die Streams-API zusammen mit TextDecoderStream. So verarbeiten Sie die Datei blockweise, ohne sie vollständig in den Arbeitsspeicher zu laden.
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
JSONL-Dateien lassen sich in Node.js einfach schreiben: Serialisieren Sie jedes JavaScript-Objekt zu einem JSON-String und hängen Sie einen Zeilenumbruch an. Für eine möglichst hohe Performance bei großen Datenmengen verwenden Sie einen Schreibstream, statt den gesamten String im Arbeitsspeicher aufzubauen.
Mit fs.writeFileSync oder fs.createWriteStream schreiben Sie Datensätze in eine JSONL-Datei. Jeder Datensatz besteht aus einer Zeile mit gültigem JSON und einem anschließenden Zeilenumbruch.
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`);Verwenden Sie beim Schreiben von Millionen von Datensätzen einen Writable Stream. So müssen Sie nicht den gesamten Ausgabestring im Arbeitsspeicher aufbauen. Der Stream kümmert sich automatisch um Backpressure und pausiert die Schreibvorgänge, wenn der Puffer des Betriebssystems voll ist.
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
Mit Transform Streams in Node.js bauen Sie Datenpipelines aus kombinierbaren Verarbeitungsschritten auf: JSONL einlesen, jeden Datensatz verarbeiten und die Ergebnisse schreiben. Dieses Muster eignet sich besonders für ETL-Jobs, die Verarbeitung von Logs und Datenmigrationen.
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, transformiert jeden Datensatz durch Hinzufügen der Felder processed und processedAt und schreibt die Ergebnisse in eine neue Datei. Der Transform Stream kümmert sich automatisch um Backpressure, sodass der Speicherverbrauch auch bei sehr großen Dateien konstant bleibt. Für komplexe ETL-Workflows können Sie mehrere Transform Streams hintereinanderschalten.
JavaScript-Bibliotheken für JSONL
Das integrierte JSON.parse reicht in den meisten Fällen aus. Für JSONL-spezifische Workflows wie Streaming, Validierung und Batch-Verarbeitung bieten verschiedene npm-Pakete jedoch praktische Hilfsfunktionen.
JSON.parse (integriert)
IntegriertDie integrierten Methoden JSON.parse() und JSON.stringify() sind in V8 stark optimiert und reichen für die meisten JSONL-Anwendungsfälle aus. Für Streaming kombinieren Sie sie mit readline. Sie benötigen keine zusätzlichen Abhängigkeiten und erzielen bei Dateien bis zu mehreren hundert MB eine hervorragende Performance.
ndjson
Beliebtndjson ist ein beliebtes npm-Paket mit Streaming-Parsern und Serialisierern für JSONL (Newline Delimited JSON), die mit Node.js-Streams kompatibel sind. Es geht robust mit Parsing-Fehlern um und lässt sich gut in bestehende Stream-Pipelines einbinden. Damit eignet es sich besonders für schnelles Prototyping.
jsonl-parse-stringify
Einfachjsonl-parse-stringify ist eine schlanke Bibliothek ohne externe Abhängigkeiten. Sie bietet einfache parse()- und stringify()-Methoden für JSONL-Daten und berücksichtigt Sonderfälle wie Zeilenumbrüche am Dateiende und Leerzeilen. Ideal, wenn Sie eine übersichtliche synchrone API verwenden möchten, ohne Streams einzurichten.
Testen Sie unsere kostenlosen JSONL-Tools
Sie möchten keinen Code schreiben? Mit unseren kostenlosen Online-Tools können Sie JSONL-Dateien direkt im Browser anzeigen, konvertieren und formatieren. Die gesamte Verarbeitung erfolgt lokal, sodass Ihre Daten privat bleiben.
Erfahren Sie, wie Sie JSONL-Daten mit Node.js, Python, Server-Sent Events und WebSockets in Echtzeit streamen. Erstellen Sie Streaming-Pipelines für Logs, Metriken und Live-Datenfeeds.
Strategien für JSONL-Daten im Gigabyte-Bereich: Lesen per Streaming, Speicherverwaltung, Aufteilen von Dateien, Komprimierung und Online-Tools.
Validieren Sie JSONL-Dateien Zeile für Zeile und erkennen Sie Syntaxfehler, Probleme mit der Zeichenkodierung und Formatfehler sofort.
Bewährte Vorgehensweisen für JSONL: Formatierung, einheitliche Schemas, Fehlerbehandlung, Performance-Optimierung und Dateiorganisation. Praktische Beispiele helfen Ihnen, typische Fallstricke zu vermeiden.
Ein umfassender Leitfaden für JSONL-Dateien in Python. Lernen Sie, JSONL mit json, pandas und orjson zu lesen, zu schreiben und zu parsen und große Dateien per Streaming zu verarbeiten.