Proper way to catch exception from JSON.parse

Question

I’m using JSON.parse on a response that sometimes contains a 404 response. In the cases where it returns 404, is there a way to catch an exception and then execute some other code?

data = JSON.parse(response, function (key, value) {
    var type;
    if (value && typeof value === 'object') {
        type = value.type;
        if (typeof type === 'string' && typeof window[type] === 'function') {
            return new(window[type])(value);
        }
    }
    return value;
});

Answer 1

i post something into an iframe then read back the contents of the iframe with json parse...so sometimes it's not a json string

Try this:

if (response) {
    let a;
    try {
        a = JSON.parse(response);
    } catch (e) {
        return console.error(e); // error in the above string (in this case, yes)!
    }
    // if no error, we can now keep using "a"
}

Answer 2

We can check error & 404 statusCode, and use try {} catch (err) {}.

You can try this :

const req = new XMLHttpRequest();
req.onreadystatechange = function() {
    if (req.status == 404) {
        console.log("404");
        return false;
    }

    if (!(req.readyState == 4 && req.status == 200))
        return false;

    const json = (function(raw) {
        try {
            return JSON.parse(raw);
        } catch (err) {
            return false;
        }
    })(req.responseText);

    if (!json)
        return false;

    document.body.innerHTML = "Your city : " + json.city + "<br>Your isp : " + json.org;
};
req.open("GET", "https://ipapi.co/json/", true);
req.send();

Read more :

• Catch a 404 error for XHR

Answer 3

I am fairly new to Javascript. But this is what I understood: JSON.parse() returns SyntaxError exceptions when invalid JSON is provided as its first parameter. So. It would be better to catch that exception as such like as follows:

try {
    let sData = `
        {
            "id": "1",
            "name": "UbuntuGod",
        }
    `;
    console.log(JSON.parse(sData));
} catch (objError) {
    if (objError instanceof SyntaxError) {
        console.error(objError.name);
    } else {
        console.error(objError.message);
    }
}

The reason why I made the words "first parameter" bold is that JSON.parse() takes a reviver function as its second parameter.

Answer 4

if you are looking for a generalized function for this, give this a shot.

const parseJSON = (inputString, fallback) => {
  if (inputString) {
    try {
      return JSON.parse(inputString);
    } catch (e) {
      return fallback;
    }
  }
};

Answer 5

This is a handy and very simple pattern:

    var blah = null
    try { blah = JSON.parse(someText) }
    catch {
        // this should never, ever happen
        // LOG A DISASTER
    }

    // now, `blah` is either the value, or null

Answer 6

Just for my own fun, I tried to create oneliners out of 2 answers from here:

let response = '{"a": 123}';
let data = (_=> {try { return JSON.parse(response); } catch(err) { return undefined; }})();
if (!data) ...404...

NOTE: return undefined; is just for completeness, as return; will also result in undefined.

let response = '{"a": 123}';
let data = await Promise.resolve(_ => JSON.parse(response)).then(f => f()).catch(err => undefined);
if (!data) ...404...

NOTE: Yeah, I don't know .. the benefits of running a function inside of a Promise just to catch its error ... seems kind of wrong to me ... but non the less an interesting idea.

Please feel free and share your thoughts on those in the comments.

Answer 7

You can try this:

Promise.resolve(JSON.parse(response)).then(json => {
    response = json ;
}).catch(err => {
    response = response
});

Answer 8

This promise will not resolve if the argument of JSON.parse() can not be parsed into a JSON object.

Promise.resolve(JSON.parse('{"key":"value"}')).then(json => {
    console.log(json);
}).catch(err => {
    console.log(err);
});