¿Cómo analizar elementos de un flujo JSON grande en JavaScript?

Oct 28 2020

Así que descargué el volcado de Wikidata JSON y es de aproximadamente 90 GB, demasiado grande para cargarlo en la memoria. Consiste en una estructura JSON simple como esta:

[
  item,
  item,
  item,
  ...
]

Cada "elemento" se parece a esto:

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

La transmisión JSON se configura así:

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

Observe que buildItemtiene la información clave, muestra que el flujo JSON emite objetos como este (estos son los registros):

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

¿Cómo analiza esto en itemobjetos como el anterior? Analizar este flujo lineal en un árbol es muy difícil de comprender.

Aquí hay una muestra de la salida de la secuencia JSON , que puede usar para probar un analizador si ayuda.

Respuestas

4 Steve Oct 31 2020 at 04:54

Uso de funciones integradas (StreamArray)

stream-jsonya tiene funciones integradas que convierten flujos en objetos (en este caso, está buscando StreamArray ). Es posible que desee utilizar las funciones integradas, ya que se han codificado teniendo en cuenta el rendimiento.

Para usarlo, se vería así:

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

Recomiendo echar un vistazo a la wiki en https://github.com/uhop/stream-json/wiki para obtener más información, ya que tiene funciones adicionales, especialmente para el filtrado o la transformación, que probablemente le serán de utilidad, especialmente si la velocidad es un problema.

1 LukaKralj Oct 31 2020 at 03:55

Si te he entendido bien, quieres algo como esto. Usé una ObjectBuilderclase que combina todos los métodos para construir un objeto JSON. Se utiliza parentStackpara realizar un seguimiento de todos los objetos y matrices. Cuando el objeto / matriz se inicia con startObject/startArrayun nuevo objeto / matriz JSON se inserta en la pila. Una vez que este objeto / matriz se completa, se saca de la pila. El último objeto que se extrae de la pila es el objeto ítem completo y se puede procesar más (en el siguiente ejemplo, simplemente lo imprimo).

El objeto o matriz actual que se está construyendo actualmente siempre está en la parte superior de la pila.

Tuve que usar un subconjunto de la muestra que proporcionó porque no contenía un número coincidente de elementos startObjecty endObject, lo que resultó en un JSON no válido. Incluí este subconjunto debajo del código.

Con suerte, esto es lo que estabas buscando :)

(Tenga en cuenta que solo envolví la buildItem()función en runSample()función para poder incluir el JSON de muestra en la parte inferior para que se vea más ordenado en este editor en línea. Puede mover la buildItem()función al exterior).