it-swarm.com.de

Wie analysiert man JSON mit Node.js?

Wie kann ich JSON mit Node.js analysieren? Gibt es ein Modul, das JSON sicher validiert und analysiert?

894
Tikhon Jelvis

Sie können einfach JSON.parse verwenden. 

Die Definition des JSON-Objekts ist Teil der ECMAScript 5-Spezifikation . node.js basiert auf der V8 - Engine von Google Chrome, die dem ECMA-Standard entspricht. Daher hat node.js auch ein globales Objekt JSON[docs]

Hinweis - JSON.parse kann den aktuellen Thread verknüpfen, da es sich um eine synchrone Methode handelt. Wenn Sie große JSON-Objekte analysieren möchten, verwenden Sie einen Streaming-Json-Parser.

1029
Felix Kling

sie können erforderlich .json-Dateien.

var parsedJSON = require('./file-name');

Wenn Sie beispielsweise eine config.json -Datei im selben Verzeichnis wie Ihre Quellcodedatei haben, würden Sie Folgendes verwenden:

var config = require('./config.json');

oder (Dateierweiterung kann weggelassen werden):

var config = require('./config');

beachte, dass require synchron ist und die Datei nur einmal liest , folgende Aufrufe geben das Ergebnis aus dem Cache zurück

Beachten Sie auch, dass Sie dies nur für lokale Dateien unter Ihrer absoluten Kontrolle verwenden sollten, da hierdurch möglicherweise Code innerhalb der Datei ausgeführt wird.

649
eliocs

Sie können JSON.parse() verwenden.

Sie sollten das JSON-Objekt in jeder ECMAScript 5 -kompatiblen JavaScript-Implementierung verwenden können. Und V8 , auf dem Node.js aufgebaut ist, ist einer von ihnen.

Hinweis: Wenn Sie eine JSON-Datei zum Speichern vertraulicher Informationen (z. B. Kennwörter) verwenden, ist dies der falsche Weg. Sehen Sie, wie Heroku es tut: https://devcenter.heroku.com/articles/config-vars#setting-up-config-vars-for-a-deployed-application . Finden Sie heraus, wie Ihre Plattform dies tut, und verwenden Sie process.env, um die Konfigurationsvariablen aus dem Code abzurufen.


Analyse einer Zeichenfolge, die JSON-Daten enthält

var str = '{ "name": "John Doe", "age": 42 }';
var obj = JSON.parse(str);

Analyse einer Datei mit JSON-Daten

Sie müssen einige Dateioperationen mit dem Modul fs durchführen.

Asynchrone Version

var fs = require('fs');

fs.readFile('/path/to/file.json', 'utf8', function (err, data) {
    if (err) throw err; // we'll not consider error handling for now
    var obj = JSON.parse(data);
});

Synchrone Version

var fs = require('fs');
var json = JSON.parse(fs.readFileSync('/path/to/file.json', 'utf8'));

Sie möchten require verwenden? Denk nochmal!

Sie können manchmal require verwenden :

var obj = require('path/to/file.json');

Ich empfehle das jedoch aus mehreren Gründen nicht:

  1. require ist synchron. Wenn Sie über eine sehr große JSON-Datei verfügen, wird die Ereignisschleife verschluckt. Sie müssen unbedingt JSON.parse mit fs.readFile verwenden.
  2. require liest die Datei nur einmal. Nachfolgende Aufrufe von require für dieselbe Datei geben eine zwischengespeicherte Kopie zurück. Keine gute Idee, wenn Sie eine ständig aktualisierte .json-Datei lesen möchten. Sie könnten einen Hack verwenden. An diesem Punkt ist es jedoch einfacher, fs zu verwenden.
  3. Wenn Ihre Datei nicht die Erweiterung .json hat, behandelt require den Inhalt der Datei nicht als JSON.

Ernsthaft! Verwenden Sie JSON.parse.


load-json-file modul

Wenn Sie eine große Anzahl von .json-Dateien lesen (und wenn Sie extrem faul sind), ist es ärgerlich, jedes Mal einen Boilerplate-Code zu schreiben. Sie können einige Zeichen mit dem Modul load-json-file speichern.

const loadJsonFile = require('load-json-file');

Asynchrone Version

loadJsonFile('/path/to/file.json').then(json => {
    // `json` contains the parsed object
});

Synchrone Version

let obj = loadJsonFile.sync('/path/to/file.json');

JSON aus Streams analysieren

Wenn der JSON-Inhalt über das Netzwerk gestreamt wird, müssen Sie einen Streaming-JSON-Parser verwenden. Andernfalls wird der Prozessor gebunden und die Ereignisschleife blockiert, bis der JSON-Inhalt vollständig gestreamt ist.

Dafür gibt es viele Pakete in NPM verfügbar . Wählen Sie aus, was für Sie am besten ist.


Fehlerbehandlung/Sicherheit

Wenn Sie sich nicht sicher sind, ob gültige JSON an JSON.parse() übergeben wird, müssen Sie den Aufruf von JSON.parse() in einen try/catch-Block einschließen. Ein von einem Benutzer bereitgestellter JSON-String könnte Ihre Anwendung zum Absturz bringen und sogar zu Sicherheitslücken führen. Stellen Sie sicher, dass die Fehlerbehandlung erfolgt, wenn Sie extern bereitgestellte JSON-Dateien analysieren.

299
sampathsris

benutze das JSON Objekt :

JSON.parse(str);
79
Mark Kahn

Ein weiteres Beispiel für JSON.parse:

var fs = require('fs');
var file = __dirname + '/config.json';

fs.readFile(file, 'utf8', function (err, data) {
  if (err) {
    console.log('Error: ' + err);
    return;
  }

  data = JSON.parse(data);

  console.dir(data);
});
33
pyprism

Ich möchte erwähnen, dass es Alternativen zum globalen JSON-Objekt gibtJSON.parse und JSON.stringify sind beide synchron. Wenn Sie also mit großen Objekten arbeiten möchten, sollten Sie einige der asynchronen JSON-Module ausprobieren.

Werfen Sie einen Blick auf: https://github.com/joyent/node/wiki/Module#wiki-parsers-json

32
Haider

Fügen Sie die node-fs-Bibliothek hinzu.

var fs = require("fs");
var file = JSON.parse(fs.readFileSync("./PATH/data.json", "utf8"));

Weitere Informationen zur 'fs'-Bibliothek finden Sie in der Dokumentation unter http://nodejs.org/api/fs.html .

28
Abhishek Verma

Da Sie nicht wissen, dass Ihre Zeichenfolge tatsächlich gültig ist, würde ich sie zuerst in einen try catch setzen. Da try catch-Blöcke nicht von node optimiert werden, würde ich die gesamte Sache in eine andere Funktion integrieren:

function tryParseJson(str) {
    try {
        return JSON.parse(str);
    } catch (ex) {
        return null;
    }
}

ODER im "asynchronen Stil"

function tryParseJson(str, callback) {
    process.nextTick(function () {
      try {
          callback(null, JSON.parse(str));
      } catch (ex) {
          callback(ex)
      }
    })
}
9
Vlad

Parsen eines JSON-Streams? Verwenden Sie JSONStream.

var request = require('request')
  , JSONStream = require('JSONStream')

request({url: 'http://isaacs.couchone.com/registry/_all_docs'})
    .pipe(JSONStream.parse('rows.*'))
    .pipe(es.mapSync(function (data) {
      return data
    }))

https://github.com/dominictarr/JSONStream

8
Burcu Dogan
JSON.parse("your string");

Das ist alles.

7
debianmaster

wie andere Antworten hier bereits erwähnt haben, möchten Sie wahrscheinlich entweder eine lokale Json-Datei anfordern, von der Sie wissen, dass sie sicher und vorhanden ist, beispielsweise eine Konfigurationsdatei:

var objectFromRequire = require('path/to/my/config.json'); 

oder um das globale JSON-Objekt zu verwenden, um einen Zeichenfolgenwert in ein Objekt zu parsen:

var stringContainingJson = '\"json that is obtained from somewhere\"';
var objectFromParse = JSON.parse(stringContainingJson);

wenn Sie eine Datei benötigen, wird der Inhalt dieser Datei ausgewertet. Dies führt zu einem Sicherheitsrisiko, falls es sich nicht um eine Json-Datei, sondern um eine JS-Datei handelt.

hier habe ich eine Demo veröffentlicht, in der Sie beide Methoden sehen und online mit ihnen spielen können (das Beispiel zum Analysieren befindet sich in der Datei app.js - klicken Sie dann auf die Schaltfläche Ausführen und sehen Sie das Ergebnis im Terminal): http://staging1.codefresh.io/labs/api/env/json-parse-example

sie können den Code ändern und die Auswirkungen sehen ...

6
nathan g

Jeder hier hat von JSON.parse erzählt, also wollte ich noch etwas sagen. Es gibt ein großartiges Modul Connect mit vielen Middleware, um die Entwicklung von Apps einfacher und besser zu machen. Eine der Middleware ist bodyParser . Es analysiert JSON, HTML-Formulare usw. Es gibt auch eine spezielle Middleware für JSON, die nur noop analysiert. 

Schauen Sie sich die Links oben an, es könnte für Sie sehr hilfreich sein. 

5

Meine Lösung:

var fs = require('fs');
var file = __dirname + '/config.json';

fs.readFile(file, 'utf8', function (err, data) {
    if (err) {
        console.log('Error: ' + err);
        return;
    }

    data = JSON.parse(data);

    console.dir(data);
});
5
Ravindra Galav

Verwenden von JSON für Ihre Konfiguration mit Node.js? Lesen Sie dies und erhalten Sie über 9000 Konfigurationsfähigkeiten ...

Hinweis: Personen, die behaupten, dass data = required ('./ data.json') ist; ist ein Sicherheitsrisiko und das Abstimmen der Antworten der Menschen mit eifrigem Eifer: Sie sind genau und vollständigfalsch. Platzieren Sie Nicht-JSON-Dateien in dieser Datei ... Der Knoten gibt einen Fehler aus, genau wie es wäre, wenn Sie dasselbe mit der {viel -Datenbank langsamer und schwerer machen würden Lesen Sie und dann JSON.parse (). Bitte hören Sie auf, falsche Informationen zu verbreiten. Sie verletzen die Welt und helfen nicht. Knoten wurde entworfen um dies zu ermöglichen; es ist kein Sicherheitsrisiko!

Richtige Anwendungen gibt es in 3+Schichtender Konfiguration:

  1. Server/Container-Konfiguration
  2. Anwendungskonfiguration
  3. (optional) Mandant/Community/Organisation Konfig
  4. Benutzerkonfiguration

Die meisten Entwickler behandeln ihren Server und ihre App-Konfiguration so, als könnten sich Änderungen ergeben. Es kann nicht Sie können Ebenenänderungen von höheren Ebenen übereinander erstellen, aber Sie sind Ändern der Basisanforderungen. Einige Dinge brauchen um zu existieren! Machen Sie Ihre Konfiguration so, als wäre sie unveränderlich, denn einige davon sind im Grunde genauso wie Ihr Quellcode.

Wenn Sie nicht feststellen, dass sich viele Ihrer Sachen nach dem Start nicht ändern, führt dies zu Anti-Mustern, wie das Laden Ihrer Konfigurationsdateien mit try/catch-Blöcken, und wenn Sie so tun, als könnten Sie ohne Ihre ordnungsgemäß eingerichtete Anwendung fortsetzen. Du kannst nicht Wenn Sie können, gehört dies zur Community/User-Konfigurationsschicht, nicht zur Server-/App-Konfigurationsschicht. Du machst es einfach falsch. Das optionale Material sollte oben angeordnet sein, wenn die Bootstrap-Anwendung der Anwendung abgeschlossen ist.

Stoppen Sie Ihren Kopf gegen die Wand: Ihre Konfiguration sollte ultra simple sein.

Schauen Sie sich an, wie einfach es ist, etwas so komplexes wie ein Protokoll-agnostic- und datasource-agnostic-Service-Framework einzurichten, indem Sie eine einfache json-Konfigurationsdatei und eine einfache app.js-Datei verwenden.

container-config.js ...

{
    "service": {
        "type"  : "http",
        "name"  : "login",
        "port"  : 8085
    },
    "data": {
        "type"  : "mysql",
        "Host"  : "localhost",
        "user"  : "notRoot",
        "pass"  : "oober1337",
        "name"  : "connect"
    }
}

index.js ... (die Engine, die alles antreibt)

var config      = require('./container-config.json');       // Get our service configuration.
var data        = require(config.data.type);            // Load our data source plugin ('npm install mysql' for mysql).
var service     = require(config.service.type);         // Load our service plugin ('http' is built-in to node).
var processor   = require('./app.js');                  // Load our processor (the code you write).

var connection  = data.createConnection({ Host: config.data.Host, user: config.data.user, password: config.data.pass, database: config.data.name });
var server      = service.createServer(processor);
connection.connect();
server.listen(config.service.port, function() { console.log("%s service listening on port %s", config.service.type, config.service.port); });

app.js ... (der Code, der Ihren Protokollagnostik- und Datenquellen-Agnostikdienst aktiviert)

module.exports = function(request, response){
    response.end('Responding to: ' + request.url);
}

Mit diesem Muster können Sie nun Community- und Benutzerkonfigurationsmaterial auf Ihre gebootete App laden. Dev ops ist bereit, Ihre Arbeit in einen Container zu verschieben und zu skalieren. Sie werden für Mehrfachantragsteller gelesen. Userland ist isoliert. Sie können jetzt die Bedenken hinsichtlich des von Ihnen verwendeten Dienstprotokolls, des verwendeten Datenbanktyps trennen und sich auf das Schreiben von gutem Code konzentrieren.

Da Sie Ebenen verwenden, können Sie sich jederzeit auf eine einzige Quelle der Wahrheit verlassen (das mehrschichtige Konfigurationsobjekt) und Fehlerprüfungen bei jedem Schritt vermeiden. Sorgen Sie sich um "oh Mist, wie soll ich das machen?"this Arbeit ohne korrekte Konfiguration?!? ".

5
Nick Steele

Sie möchten nur die Antwort vervollständigen (da ich einige Zeit mit ihr gekämpft habe), den Zugriff auf die Json-Informationen zeigen möchten.

var request = require('request');
request('https://server/run?oper=get_groups_joined_by_user_id&user_id=5111298845048832', function (error, response, body) {
  if (!error && response.statusCode == 200) {
    var jsonArr = JSON.parse(body);
    console.log(jsonArr);
    console.log("group id:" + jsonArr[0].id);
  }
})

4
Eli

Um dies so kompliziert wie möglich zu gestalten und so viele Pakete wie möglich einzubringen ...

const fs = require('fs');
const bluebird = require('bluebird');
const _ = require('lodash');
const readTextFile = _.partial(bluebird.promisify(fs.readFile), _, {encoding:'utf8',flag:'r'});
const readJsonFile = filename => readTextFile(filename).then(JSON.parse);

So können Sie Folgendes tun:

var dataPromise = readJsonFile("foo.json");
dataPromise.then(console.log);

Oder wenn Sie async/await verwenden:

let data = await readJsonFile("foo.json");

Der Vorteil gegenüber readFileSync besteht darin, dass Ihr Knotenserver andere Anforderungen verarbeiten kann, während die Datei von der Festplatte gelesen wird.

3
mpen

Stellen Sie immer sicher, dass Sie JSON.parse in try catch block verwenden, da der Knoten immer einen unerwarteten Fehler auslöst, wenn Sie beschädigte Daten in Ihrem Json haben. Verwenden Sie daher diesen Code anstelle von JSON.Parse

try{
     JSON.parse(data)
}
catch(e){
   throw new Error("data is corrupted")
  }
2
Rahul Kamboj

Wenn Sie in Ihrem JSON einige Kommentare hinzufügen und nachfolgende Kommas zulassen möchten, können Sie die folgende Implementierung verwenden:

var fs = require('fs');

var data = parseJsData('./message.json');

console.log('[INFO] data:', data);

function parseJsData(filename) {
    var json = fs.readFileSync(filename, 'utf8')
        .replace(/\s*\/\/.+/g, '')
        .replace(/,(\s*\})/g, '}')
    ;
    return JSON.parse(json);
}

Beachten Sie, dass es möglicherweise nicht gut funktioniert, wenn Sie in Ihrem JSON etwas wie "abc": "foo // bar" haben. Also YMMV.

2
Nux

Nutzen Sie die Versuchsfunktion von Lodash, ein Fehlerobjekt zurückzugeben, das Sie mit der Funktion isError behandeln können.

// Returns an error object on failure
function parseJSON(jsonString) {
   return _.attempt(JSON.parse.bind(null, jsonString));
}


// Example Usage
var goodJson = '{"id":123}';
var badJson = '{id:123}';
var goodResult = parseJSON(goodJson);
var badResult = parseJSON(badJson);

if (_.isError(goodResult)) {
   console.log('goodResult: handle error');
} else {
   console.log('goodResult: continue processing');
}
// > goodResult: continue processing

if (_.isError(badResult)) {
   console.log('badResult: handle error');
} else {
   console.log('badResult: continue processing');
}
// > badResult: handle error
2
l3x

JSON.parse gewährleistet nicht die Sicherheit der zu analysierenden Json-Zeichenfolge. Sie sollten sich eine Bibliothek wie json-safe-parse oder eine ähnliche Bibliothek ansehen.

Auf der json-safe-parse npm-Seite: 

JSON.parse ist großartig, hat jedoch einen gravierenden Fehler im Kontext von JavaScript: Sie können vererbte Eigenschaften überschreiben. Dies kann zu einem Problem werden, wenn Sie JSON von einer nicht vertrauenswürdigen Quelle aus analysieren (z. B. einem Benutzer) und Funktionen aufrufen, von denen Sie erwarten, dass sie existieren.

2

Wenn die JSON-Quelldatei ziemlich groß ist, sollten Sie die asynchrone Route über den systemeigenen async/await-Ansatz mit Node.js 8.0 wie folgt berücksichtigen

const fs = require('fs')

const fsReadFile = (fileName) => {
    fileName = `${__dirname}/${fileName}`
    return new Promise((resolve, reject) => {
        fs.readFile(fileName, 'utf8', (error, data) => {
            if (!error && data) {
                resolve(data)
            } else {
                reject(error);
            }
        });
    })
}

async function parseJSON(fileName) {
    try {
        return JSON.parse(await fsReadFile(fileName));
    } catch (err) {
        return { Error: `Something has gone wrong: ${err}` };
    }
}

parseJSON('veryBigFile.json')
    .then(res => console.log(res))
    .catch(err => console.log(err))
1
Lae Kettavong
var array={
    Action: 'Login',
    ErrorCode: 3,
    Detail: 'Your account not found.'
};
var http=require('http'),
    PORT=8789,
    server=function(req,res){
        res.writeHead(200,{'Content-Type':'application/json'});

        // JSON
        res.end(JSON.stringify(array));
    }

http.createServer(server).listen(PORT);
console.log('Server started.');
1
vuhung3990

Ich benutze fs-extra . Ich mag es sehr, weil es - obwohl es Rückrufe unterstützt - auch Promises unterstützt. So kann ich meinen Code einfach lesbarer schreiben:

const fs = require('fs-extra');
fs.readJson("path/to/foo.json").then(obj => {
    //Do dome stuff with obj
})
.catch(err => {
    console.error(err);
});

Es hat auch viele nützliche Methoden, die nicht mit dem Standardmodul fsund mitgeliefert werden. Außerdem werden die Methoden des nativen Moduls fs gebrückt und versprochen.

HINWEIS: Sie können weiterhin die systemeigenen Node.js-Methoden verwenden. Sie werden versprochen und an fs-extra übergeben. Siehe Hinweise zu fs.read() & fs.write() 

Es sind also im Grunde alle Vorteile. Ich hoffe, andere finden das nützlich.

1
Mig82

Verwenden Sie JSON.parse(str);. Lesen Sie mehr darüber hier .

Hier sind einige Beispiele:

var jsonStr = '{"result":true, "count":42}';

obj = JSON.parse(jsonStr);

console.log(obj.count);    //expected output: 42
console.log(obj.result);   // expected output: true
0
Praveen Poonia

Es müssen keine weiteren Module benötigt werden.
Benutz einfach
var parsedObj = JSON.parse(yourObj);
Ich glaube nicht, dass diesbezüglich Sicherheitsprobleme bestehen

0
Sachin S

Wie in den obigen Antworten erwähnt, können wir JSON.parse() verwenden, um die Zeichenfolgen in JSON zu analysieren. Stellen Sie jedoch vor dem Parsen sicher, dass Sie die richtigen Daten analysieren, da dies sonst Ihre gesamte Anwendung zum Erliegen bringen kann

es ist sicher, es so zu benutzen

let parsedObj = {}
try {
    parsedObj = JSON.parse(data);
} catch(e) {
    console.log("Cannot parse because data is not is proper json format")
}
0
Shekar Mania

Verwenden Sie dies, um auf der sicheren Seite zu sein

var data = JSON.parse(Buffer.concat(arr).toString());

Sie können JSON.parse () verwenden (eine eingebaute Funktion, die Sie wahrscheinlich dazu zwingen wird, es mit try-catch-Anweisungen einzuhüllen).

Oder verwenden Sie eine JSON-Parsing-npm-Bibliothek, z. B. json-parse-or

0
C'estLaVie

NodeJs ist ein auf JavaScript basierender Server, so dass Sie es in reiner JavaScript ...

Stellen Sie sich vor, Sie haben diese Json in NodeJs ...

var details = '{ "name": "Alireza Dezfoolian", "netWorth": "$0" }';
var obj = JSON.parse(details);

Und Sie können oben tun, um eine geparste Version Ihres Json zu erhalten ...

0
Alireza