Analizar archivos JSON grandes en Nodejs

Justo cuando estaba pensando que sería divertido escribir un analizador JSON de streaming, también pensé que tal vez debería hacer una búsqueda rápida para ver si ya hay uno disponible.

Resulta que sí.

• JSONStream "streaming JSON.analizar y stringify "

Desde que lo encontré, obviamente no lo he usado, así que no puedo comentar sobre su calidad, pero me interesará saber si funciona.

Funciona considere lo siguiente CoffeeScript:

stream.pipe(JSONStream.parse('*'))
.on 'data', (d) ->
    console.log typeof d
    console.log "isString: #{_.isString d}"

Esto registrará los objetos a medida que entran si la secuencia es una matriz de objetos. Por lo tanto, lo único que se almacena en búfer es un objeto a la vez.

A partir de octubre de 2014, puedes hacer algo como lo siguiente (usando JSONStream) - https://www.npmjs.org/package/JSONStream

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

    var getStream() = function () {
        var jsonData = 'myData.json',
            stream = fs.createReadStream(jsonData, {encoding: 'utf8'}),
            parser = JSONStream.parse('*');
            return stream.pipe(parser);
     }

     getStream().pipe(MyTransformToDoWhateverProcessingAsNeeded).on('error', function (err){
        // handle any errors
     });

Para demostrar con un ejemplo de trabajo:

npm install JSONStream event-stream

Data.json:

{
  "greeting": "hello world"
}

Hola.js:

var fs = require('fs'),
  JSONStream = require('JSONStream'),
  es = require('event-stream');

var getStream = function () {
    var jsonData = 'data.json',
        stream = fs.createReadStream(jsonData, {encoding: 'utf8'}),
        parser = JSONStream.parse('*');
        return stream.pipe(parser);
};

 getStream()
  .pipe(es.mapSync(function (data) {
    console.log(data);
  }));


$ node hello.js
// hello world

Me doy cuenta de que desea evitar leer todo el archivo JSON en la memoria si es posible, sin embargo, si tiene la memoria disponible, puede que no sea una mala idea en cuanto al rendimiento. Usando node.require () de js en un archivo json carga los datos en la memoria muy rápido.

Ejecuté dos pruebas para ver cómo se veía el rendimiento al imprimir un atributo de cada característica de un archivo geojson de 81 MB.

En la primera prueba, leí todo el archivo geojson en la memoria usando var data = require('./geo.json'). Que tomó 3330 milisegundos y luego imprimir un atributo de cada entidad tomó 804 milisegundos para un total general de 4134 milisegundos. Sin embargo, apareció ese nodo.js estaba usando 411MB de memoria.

En la segunda prueba, usé la respuesta de @arcseldon con JSONStream + event-stream. Modifiqué la consulta JSONPath para seleccionar solo lo que necesitaba. Esta vez la memoria nunca fue superior a 82MB, sin embargo, todo el asunto ahora tomó 70 segundos para completar!

Tenía un requisito similar, necesito leer un archivo json grande en el nodo js y procesar datos en trozos y llamar a una api y guardarlos en mongodb. inputFile.json es como:

{
 "customers":[
       { /*customer data*/},
       { /*customer data*/},
       { /*customer data*/}....
      ]
}

Ahora utilicé JsonStream y EventStream para lograr esto sincrónicamente.

 var JSONStream = require('JSONStream');
    var  es = require('event-stream');

    fileStream = fs.createReadStream(filePath, {encoding: 'utf8'});
        fileStream.pipe(JSONStream.parse('customers.*')).pipe(es.through(function (data) {
            console.log('printing one customer object read from file ::');
            console.log(data);
            this.pause();
            processOneCustomer(data, this);
            return data;
        },function end () {
            console.log('stream reading ended');
            this.emit('end');
          });

    function processOneCustomer(data,es){
     DataModel.save(function(err,dataModel){
     es.resume();
    });
}

Resolví este problema usando el módulo split npm. Pipe su corriente en split, y se "Romper un flujo y volver a montarlo de modo que cada línea es un trozo".

Código de ejemplo:

var fs = require('fs')
  , split = require('split')
  ;

var stream = fs.createReadStream(filePath, {flags: 'r', encoding: 'utf-8'});
var lineStream = stream.pipe(split());
linestream.on('data', function(chunk) {
    var json = JSON.parse(chunk);           
    // ...
});

Si tiene control sobre el archivo de entrada, y es una matriz de objetos, puede resolver esto más fácilmente. Organice la salida del archivo con cada registro en una línea, así:

[
   {"key": value},
   {"key": value},
   ...

Esto sigue siendo JSON válido.

Entonces, use el nodo.módulo js readline para procesarlos una línea a la vez.

var fs = require("fs");

var lineReader = require('readline').createInterface({
    input: fs.createReadStream("input.txt")
});

lineReader.on('line', function (line) {
    line = line.trim();

    if (line.charAt(line.length-1) === ',') {
        line = line.substr(0, line.length-1);
    }

    if (line.charAt(0) === '{') {
        processRecord(JSON.parse(line));
    }
});

function processRecord(record) {
    // Process the records one at a time here! 
}

Escribí un módulo que puede hacer esto, llamado BFJ. Específicamente, el método bfj.match se puede usar para dividir un flujo grande en trozos discretos de JSON:

const bfj = require('bfj');
const fs = require('fs');

const stream = fs.createReadStream(filePath);

bfj.match(stream, (key, value, depth) => depth === 0, { ndjson: true })
  .on('data', object => {
    // do whatever you need to do with object
  })
  .on('dataError', error => {
    // a syntax error was found in the JSON
  })
  .on('error', error => {
    // some kind of operational error occurred
  })
  .on('end', error => {
    // finished processing the stream
  });

Aquí, bfj.match devuelve un flujo legible en modo objeto que recibirá los elementos de datos analizados, y se le pasan 3 argumentos:

1. Un flujo legible que contiene el JSON de entrada.

2. Predicado que indica qué elementos del JSON analizado se enviarán al resultado flujo.

3. Un objeto options que indica que la entrada es JSON delimitada por una nueva línea (esto es para procesar el formato B desde la pregunta, no es necesario para el formato A).

Al ser llamado, bfj.match analizará JSON desde la profundidad del flujo de entrada, llamando al predicado con cada valor para determinar si debe o no enviar ese elemento al flujo de resultados. Al predicado se le pasan tres argumentos:

1. La clave de propiedad o índice de matriz (esto será undefined para los elementos de nivel superior).

2. El valor en sí.

3. La profundidad del elemento en la estructura JSON (cero para los elementos de nivel superior).

Por supuesto, un predicado más complejo también se puede usar según sea necesario de acuerdo con los requisitos. También puede pasar una cadena o una expresión regular en lugar de una función de predicado, si desea realizar coincidencias simples con claves de propiedad.

Creo que necesitas usar una base de datos. MongoDB es una buena opción en este caso porque es compatible con JSON.

ACTUALIZACIÓN: Puede usar la herramienta mongoimport para importar datos JSON a MongoDB.

mongoimport --collection collection --file collection.json