Comment analyser les éléments d'un grand flux JSON en JavaScript?

Oct 28 2020

J'ai donc téléchargé le vidage Wikidata JSON et il est d'environ 90 Go, trop volumineux pour être chargé en mémoire. Il se compose d'une structure JSON simple comme celle-ci:

[
  item,
  item,
  item,
  ...
]

Chaque "élément" ressemble à ceci:

{
  "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": []
    }
  }
}

Le flux JSON est configuré comme ceci:

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
  }
}

Notez que le buildItema les informations clés, cela montre que le flux JSON émet des objets comme celui-ci (ce sont les journaux):

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

Comment analysez-vous cela en itemobjets comme ci-dessus? L'analyse de ce flux linéaire dans un arbre est très difficile à comprendre.

Un exemple de sortie du flux JSON est ici , que vous pouvez utiliser pour tester un analyseur si cela vous aide.

Réponses

4 Steve Oct 31 2020 at 04:54

Utilisation des fonctions intégrées (StreamArray)

stream-jsona déjà des fonctions intégrées qui convertissent les flux en objets (dans ce cas, vous recherchez StreamArray ). Vous souhaiterez peut-être utiliser les fonctions intégrées, car elles ont été codées avec les performances à l'esprit.

Pour l'utiliser, cela ressemblerait à quelque chose comme:

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

Je recommande de jeter un œil au wiki à https://github.com/uhop/stream-json/wiki pour plus d'informations, car il a des fonctions supplémentaires, notamment pour le filtrage ou la transformation, qui vous seront probablement utiles, surtout si la vitesse est un problème.

1 LukaKralj Oct 31 2020 at 03:55

Si je vous ai bien compris, vous voulez quelque chose comme ça. J'ai utilisé une ObjectBuilderclasse qui combine toutes les méthodes pour créer un objet JSON. Il utilise parentStackpour garder une trace de tous les objets et tableaux. Lorsque l'objet / tableau est démarré avec startObject/startArrayun nouvel objet / tableau JSON est poussé sur la pile. Une fois que cet objet / tableau est terminé, il est sorti de la pile. Le dernier objet qui est sorti de la pile est l'objet de l'élément entier et peut être traité plus loin (dans l'exemple ci-dessous, je viens de l'imprimer).

L'objet ou le tableau en cours de construction est toujours en haut de la pile.

J'ai dû utiliser un sous-ensemble de l'échantillon que vous avez fourni car il ne contenait pas un nombre correspondant de startObjectet d' endObjectéléments, ce qui a abouti à un JSON invalide. J'ai inclus ce sous-ensemble sous le code.

J'espère que c'est ce que vous recherchiez :)

(Notez que je n'ai encapsulé que buildItem()fonction dans runSample()function afin de pouvoir inclure l'exemple JSON en bas pour le rendre plus net dans cet éditeur en ligne. Vous pouvez déplacer la buildItem()fonction à l'extérieur.)