asynchronous version of JSON.stringify and JSON.parse

Question

 var assert = require('assert');
 var parseJSON = require('json-parse-async');

 var contact = new Object();
 contact.firstname = "Jesper";
 contact.surname = "Aaberg";
 contact.phone = ["555-0100", "555-0120"];

 var contact2 = new Object();
 contact2.firstname = "JESPER";
 contact2.surname = "AABERG";
 contact2.phone = ["555-0100", "555-0120"];

 contact.toJSON = function(key) {
   var replacement = new Object();
   for (var val in this) {
     if (typeof(this[val]) === 'string')
       replacement[val] = this[val].toUpperCase();
     else
       replacement[val] = this[val]
   }
   return replacement;
 };

 var jsonText = JSON.stringify(contact);
 contact = JSON.parse(jsonText);
 console.log(contact);
 console.log(contact2);

 assert.deepEqual(contact, contact2, 'these two objects are the same');

What are the asynchronous equivalent functions of JSON.parse, JSON.stringify and assert.deepEqual? I am trying to create a race condition and non-deterministic behavior within the following code but I have not been able lto find non-blocking, asynchronous equivalents of the functions mentioned above.

Answer 1

I've recently faced this problem myself, so I decided to create a library to handle JSON parsing in a really asynchronous way.

The idea behind it is to divide the parsing process into chunks, and then run each separately in the event loop so that other events (user interactions, etc) can still be evaluated within a few milliseconds, keeping the UI interactive.

If you are interested, the library it's called RAJI and you can find it here: https://github.com/federico-terzi/raji

After installing RAJI, you can then convert your synchronous JSON.parse calls into async raji.parse calls, such as:

const object = await parse(payload);

These calls won't block the UI

Answer 2

node.js does not have an actual asynchronous JSON parser built-in. If you want something that will actually do the parsing outside the main node.js Javascript thread, then you would have to find a third party module that parses the JSON outside of the Javascript thread (e.g. in a native code thread or in some other process). There are some modules in NPM that advertise themselves as asynchronous such as async-json-parser or async-json-parse or json-parse-async. You would have to verify that whichever implementation you were interested in was truly an asynchronous implementation (your Javascript continues to run while the parsing happens in the background).

But, reading the detail in your question about the problem you're trying to solve, it doesn't sound like you actually need a parser that truly happens in the background. To give you your ability to test what you're trying to test, it seems to me like you just need an indeterminate finish that allows other code to run before the parsing finishes. That can be done by wrapping the synchronous JSON.parse() in a setTimeout() with a promise that has a random delay. That will give some random amount of time for other code to run (to try to test for your race conditions). That could be done like this:

JSON.parseAsyncRandom = function(str) {
    return new Promise(function(resolve, reject) {
        // use a random 0-10 second delay
        setTimeout(function() {
            try {
                resolve(JSON.parse(str));
            } catch(e) {
                 reject(e);
            }
        }, Math.floor(Math.random() * 10000));
    });
}


JSON.parseAsyncRandom(str).then(function(obj) {
    // process obj here
}, function(err) {
    // handle err here
});

Note: This is not true asynchronous execution. It's an asynchronous result (in that it arrives some random time later and other code will run before the result arrives), but true asynchronous execution happens in the background in parallel with other JS running and this isn't quite that. But, given your comment that you just want variable and asynchronous results for testing purposes, this should do that.

Answer 3

You can use 'bluebird', like this example to convert calling function to promise.

I write code below using javascript es6.

const Promise = require('bluebird')

function stringifyPromise(jsonText) {
   return Promise.try(() => JSON.stringify(jsonText))
}

function parsePromise(str) {
   return Promise.try(() => JSON.parse(str))
}

stringifyPromise(contact)
  .then(jsonText => parsePromise(jsonText))
  .then(contact => {
    assert.deepEqual(contact, contact2, 'these two objects are the same')
  })
})