HOWTO · Node.js
Parsen von Json in Node.js
Dieses Tutorial zeigt, wie man json in Node.js analysiert
Auf dieser Seite
Beim Parsen wird JSON-Text in einen JavaScript-Wert umgewandelt, zum Beispiel in ein Objekt, ein Array, eine Zeichenfolge, eine Zahl, einen booleschen Wert oder null. In Node.js verwenden Sie JSON.parse(), wenn Ihnen der Text bereits vorliegt. Bei einer lokalen JSON-Datei wählen Sie zuerst eine Methode zum Einlesen und parsen anschließend den erhaltenen Text. Die folgenden Beispiele verwenden integrierte Module von Node.js und legen bei Bedarf eigene temporäre Eingabedateien an.
Einen JSON-String mit JSON.parse() parsen
Übergeben Sie JSON-Text an JSON.parse(). Der zurückgegebene Wert besteht aus gewöhnlichen JavaScript-Daten. Sie können daher auf seine Eigenschaften zugreifen und ihn im restlichen Programm verwenden. Die Eingabe sollte JSON-Text sein. Ein bereits geparstes Objekt zu übergeben, ist meist ein Fehler: JSON.parse() wandelt das Argument zunächst in eine Zeichenfolge um. Ein gewöhnliches Objekt wird dabei meist zu einem Text wie [object Object], der kein gültiges JSON ist und einen SyntaxError auslöst. Objekte mit einem anderen Verhalten bei der Umwandlung in Zeichenfolgen können ein anderes Ergebnis liefern.
Führen Sie dieses Beispiel aus:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
const jsonText = '{"name":"Amina","role":"developer"}';
const person = JSON.parse(jsonText);
console.log(person.name);
JSON.parse() akzeptiert außerdem optional eine Reviver-Funktion, die Werte während des Parsens umwandeln kann. Die meisten Anwendungen benötigen keinen Reviver. Lassen Sie ihn daher weg, sofern Sie keine bestimmte Umwandlung durchführen müssen.
Eine lokale JSON-Datei synchron laden
Für eine kleine, statische Konfigurationsdatei, die einmal geladen wird, ist require() eine knappe Lösung:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'json-')), 'settings.json');
fs.writeFileSync(file, '{"theme":"dark"}');
const settings = require(file);
console.log(settings.theme);
Das Laden von JSON mit require() erfolgt synchron, und Node.js speichert das geladene Modul im Cache. Wird die Datei später im selben Prozess geändert, liefert ein erneuter Aufruf von require() mit diesem Pfad normalerweise den zwischengespeicherten Wert zurück. Für Daten, die Änderungen an der Datei widerspiegeln müssen, verwenden Sie stattdessen fs.readFileSync() oder fs.readFile(). Sie können require.cache manuell leeren, doch dadurch wird das Programmverhalten meist schwerer nachvollziehbar.
Verwenden Sie fs.readFileSync(), wenn das Programm eine lokale Datei vollständig einlesen muss, bevor es fortfährt. Geben Sie eine Kodierung wie utf8 an, um eine Zeichenfolge zu erhalten, und rufen Sie anschließend JSON.parse() auf:
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'json-')), 'settings.json');
fs.writeFileSync(file, '{"theme":"dark"}');
const text = fs.readFileSync(file, 'utf8');
const settings = JSON.parse(text);
console.log(settings.theme);
Ohne Angabe einer Kodierung gibt fs.readFileSync() einen Buffer statt einer Zeichenfolge zurück. JSON.parse() erwartet Text. Geben Sie daher eine Kodierung an oder wandeln Sie den Puffer mit .toString('utf8') um. Ein synchroner Lesevorgang blockiert die Ereignisschleife, solange die Datei eingelesen wird. Das kann beim Programmstart oder in einem kurzen Skript sinnvoll sein; blockieren Sie jedoch nicht die Anfragenverarbeitung durch langsame oder umfangreiche Lesevorgänge.
Eine lokale JSON-Datei asynchron lesen und parsen
fs.readFile() beginnt mit dem asynchronen Einlesen einer Datei und ruft den Callback auf, sobald der Vorgang abgeschlossen ist. Prüfen Sie den Fehler im Callback, bevor Sie parsen, damit eine fehlende oder nicht lesbare Datei nicht an JSON.parse() übergeben wird:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'json-')), 'settings.json');
fs.writeFileSync(file, '{"theme":"dark"}');
fs.readFile(file, 'utf8', (err, text) => {
if (err) {
console.error(`Could not read JSON file: ${err.message}`);
return;
}
const settings = JSON.parse(text);
console.log(settings.theme);
});
console.log('Reading has started.');
Das Einlesen der Datei erfolgt asynchron. Während die Dateioperation läuft, kann Node.js daher andere Aufgaben ausführen. JSON.parse() selbst bleibt synchron: Das Parsen einer sehr großen Zeichenfolge kann die Ereignisschleife auch nach Abschluss des Lesevorgangs noch beanspruchen. Schlägt das Parsen fehl, wird der resultierende SyntaxError im Callback ausgelöst. Behandeln Sie ihn dort oder leiten Sie ihn an eine geeignete Fehlerbehandlung weiter.
Ungültiges JSON und Dateifehler behandeln
Dateifehler und Parsing-Fehler haben unterschiedliche Ursachen und sollten getrennt behandelt werden. Ein Lesefehler bedeutet, dass das Programm den Text nicht erhalten hat; ungültiges JSON bedeutet, dass der erhaltene Text nicht der JSON-Syntax entspricht. Versuchen Sie nicht zu parsen, wenn der Lese-Callback einen Fehler meldet.
Umschließen Sie JSON.parse() mit try...catch, wenn die Eingabe fehlerhaft sein könnte. Fangen Sie SyntaxError ab, um eine hilfreiche Meldung auszugeben oder eine Wiederherstellungsstrategie anzuwenden. Ersetzen Sie fehlerhafte Eingaben nicht stillschweigend durch ein leeres Objekt: Dadurch kann eine beschädigte Datei verborgen bleiben, und spätere Fehler lassen sich schwerer diagnostizieren. Bei einem synchronen Lesevorgang sollten Sie sowohl Dateisystemfehler rund um den Lesevorgang als auch Parsing-Fehler rund um JSON.parse() behandeln.
Dieses Beispiel behandelt ein fehlerhaftes Dokument nach einem erfolgreichen Lesevorgang:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'json-')), 'settings.json');
fs.writeFileSync(file, '{"theme":}');
fs.readFile(file, 'utf8', (err, text) => {
if (err) {
console.log(`Could not read file: ${err.message}`);
return;
}
try {
JSON.parse(text);
console.log('JSON parsed successfully.');
} catch (error) {
if (error instanceof SyntaxError) {
console.log('The file contains malformed JSON.');
} else {
console.log(`Unexpected error: ${error.message}`);
}
}
});
Erhält der Callback einen Dateisystemfehler, melden Sie ihn oder geben Sie ihn weiter und kehren Sie vor dem Parsen zurück. Für Promise-basierten Code gilt dieselbe Trennung: Behandeln Sie die Ablehnung des Lesevorgangs und fangen Sie Parsing-Fehler dort ab, wo JSON.parse() ausgeführt wird.
Vorgehen für große oder veränderliche Daten wählen
Verwenden Sie JSON.parse() direkt für JSON-Text, der bereits im Speicher liegt. Verwenden Sie require() für eine kleine, stabile JSON-Konfiguration, die einmal geladen wird und den Modul-Cache nutzen kann. Verwenden Sie fs.readFileSync(), wenn einfache, aufeinanderfolgende Aufgaben beim Programmstart davon profitieren, dass das Programm bis zur Verfügbarkeit der Datei wartet. Verwenden Sie fs.readFile(), wenn das Programm während ausstehender Datei-Ein-/Ausgabe fortfahren soll, und prüfen Sie vor dem Parsen das Fehlerargument.
Bei sehr großen JSON-Eingaben kann es viel Speicher beanspruchen, die gesamte Datei einzulesen und daraus einen vollständigen JavaScript-Wert zu erstellen. Auch das Parsen einer großen Zeichenfolge erfolgt synchron. Ein Streaming-Parser kann geeignete Formate schrittweise verarbeiten, erhöht jedoch die Komplexität und erfordert möglicherweise ein Paket oder ein für Streaming ausgelegtes Format. Wählen Sie diesen Ansatz, wenn Messungen und Datenformat den zusätzlichen Aufwand rechtfertigen. Kann sich eine Datei ändern, lesen Sie sie bei Bedarf erneut mit einer Dateisystem-API ein, um aktuelle Inhalte zu erhalten; der Cache von require() wird nicht automatisch aktualisiert.