Wie analysiere ich Elemente aus einem großen JSON-Stream in JavaScript?

Oct 28 2020

Also habe ich den Wikidata JSON-Dump heruntergeladen und er ist ungefähr 90 GB groß, zu groß, um ihn in den Speicher zu laden. Es besteht aus einer einfachen JSON-Struktur wie dieser:

[
  item,
  item,
  item,
  ...
]

Jeder "Gegenstand" sieht ungefähr so aus:

{
  "type": "item",
  "id": "Q23",
  "labels": {
    "<lang>": obj
  },
  "descriptions": {
    "<lang>": {
      "language": "<lang>",
      "value": "<string>"
    },
  },
  "aliases": {
    "<key>": [
      obj,
      obj,
    ],
  },
  "claims": {
    "<keyID>": [
       {
        "mainsnak": {
          "snaktype": "value",
          "property": "<keyID>",
          "datavalue": {
            "value": {
              "entity-type": "<type>",
              "numeric-id": <num>,
              "id": "<id>"
            },
            "type": "wikibase-entityid"
          },
          "datatype": "wikibase-item"
        },
        "type": "statement",
        "id": "<anotherId>",
        "rank": "preferred",
        "references": [
          {
            "hash": "<hash>",
            "snaks": {
              "<keyIDX>": [
                {
                  "snaktype": "value",
                  "property": "P854",
                  "datavalue": obj,
                  "datatype": "url"
                }
              ]
            },
            "snaks-order": [
              "<propID>"
            ]
          }
        ]
      }
    ]
  },
  "sitelinks": {
    "<lang>wiki": {
      "site": "<lang>wiki",
      "title": "<string>",
      "badges": []
    }
  }
}

Der JSON-Stream ist folgendermaßen konfiguriert:

const fs   = require('fs')
const zlib = require('zlib')
const { parser } = require('stream-json')

let stream = fs.createReadStream('./wikidata/latest-all.json.gz')
stream
  .pipe(zlib.createGunzip())
  .pipe(parser())
  .on('data', buildItem)

function buildItem(data) {
  switch (data.name) {
    case `startArray`:
      break
    case `startObject`:
      break
    case `startKey`:
      break
    case `stringChunk`:
      break
    case `endKey`:
      break
    case `keyValue`:
      break
    case `startString`:
      break
    case `endString`:
      break
    case `stringValue`:
      break
    case `endObject`:
      break
    case `endArray`:
      break
  }
}

Beachten buildItemSie, dass das die Schlüsselinformationen hat, es zeigt, dass der JSON-Stream Objekte wie dieses ausgibt (dies sind die Protokolle):

{ name: 'startArray' }
{ name: 'startObject' }
{ name: 'startKey' }
{ name: 'startString' }
{ name: 'stringValue', value: 'type' }
{ name: 'endString' }
...

Wie analysieren Sie dies in itemObjekte wie das oben genannte? Das Parsen dieses linearen Stroms in einen Baum ist sehr schwer zu verstehen.

Eine Probe von Ausgabe aus dem JSON - Stream ist hier , was Sie einen Parser zu testen , verwenden könnten , wenn es hilft.

Antworten

4 Steve Oct 31 2020 at 04:54

Verwenden integrierter Funktionen (StreamArray)

stream-jsonhat bereits integrierte Funktionen, die Streams in Objekte konvertieren (in diesem Fall suchen Sie nach StreamArray ). Möglicherweise möchten Sie die integrierten Funktionen verwenden, da sie im Hinblick auf die Leistung codiert wurden.

Um es zu benutzen, würde es ungefähr so aussehen:

const fs   = require('fs')
const zlib = require('zlib')
const { parser } = require('stream-json')
const { streamArray } = require('stream-json/streamers/StreamArray')

let stream = fs.createReadStream('./wikidata/latest-all.json.gz')
stream
  .pipe(zlib.createGunzip())
  .pipe(parser())
  .pipe(streamArray())
  .on('data', d => processData(d.value))

function processData(data) {
  console.log(data)
}

Ich empfehle einen Blick in das Wiki unter https://github.com/uhop/stream-json/wiki Weitere Informationen, da es zusätzliche Funktionen hat, insbesondere zum Filtern oder Transformieren, die wahrscheinlich für Sie nützlich sind, insbesondere wenn Geschwindigkeit ein Problem darstellt.

1 LukaKralj Oct 31 2020 at 03:55

Wenn ich dich richtig verstanden habe, willst du so etwas. Ich habe eine ObjectBuilderKlasse verwendet, die alle Methoden kombiniert, um ein JSON-Objekt zu erstellen. Es wird verwendet parentStack, um alle Objekte und Arrays zu verfolgen. Wenn das Objekt / Array mit startObject/startArrayeinem neuen JSON-Objekt / Array gestartet wird, wird es auf den Stapel verschoben. Sobald dieses Objekt / Array fertig ist, wird es vom Stapel genommen. Das letzte Objekt, das vom Stapel entfernt wird, ist das gesamte Objektobjekt und kann weiter verarbeitet werden (im folgenden Beispiel drucke ich es einfach aus).

Das aktuelle Objekt oder Array, das gerade erstellt wird, befindet sich immer oben auf dem Stapel.

Ich musste eine Teilmenge des von Ihnen bereitgestellten Beispiels verwenden, da es keine übereinstimmende Anzahl von startObjectund endObjectElementen enthielt , was zu einem ungültigen JSON führte. Ich habe diese Teilmenge unter dem Code eingefügt.

Hoffentlich haben Sie danach gesucht :)

(Beachten Sie, dass ich die buildItem()Funktion nur in die runSample()Funktion eingeschlossen habe, damit ich das Beispiel-JSON unten einfügen kann, damit es in diesem Online-Editor übersichtlicher aussieht. Sie können die buildItem()Funktion nach außen verschieben.)