857 
isJsonString('{ "Id": 1, "Name": "Coke" }')

should be true and

isJsonString('foo')
isJsonString('<div>foo</div>')

should be false.

I'm looking for a solution that doesn't use try/catch because I have my debugger set to "break on all errors" and that causes it to break on invalid JSON strings.

Improve this question
7
  • 5
    For those curious, here is how the V8 engine does its JSON Parsing: v8.googlecode.com/svn/trunk/src/json-parser.h Commented Sep 7, 2014 at 7:57
  • 8
    Use just 2 lines to check it with try catch. var isValidJSON = true; try { JSON.parse(jsonString) } catch { isValidJSON = false; } Commented Aug 30, 2016 at 18:29
  • Also I'd answered overhere: stackoverflow.com/a/39236371/3765109 Commented Jan 4, 2017 at 17:16
  • 24
    While that works, it's terribly kludgy and bad practice. Try/catch is meant for exceptional behavior and error handling, not general program flow. Commented Jun 26, 2017 at 19:31
  • 37
    @Tasgall As a general rule, yes. But what do you do if the try/catch approach is more performant than any validator-based approach? Go with the (sometimes significantly) slower option just because the alternative is "bad practice"? There's nothing functionally wrong with the try/catch method, so there's no reason not to use it. It's important to have new programmers develop good coding standards, but it's equally important to not reinforce blind adherence to conventional guidelines, especially in cases where the guidelines make things more difficult than they need to be. Commented Aug 15, 2018 at 17:53

29 Answers 29

Reset to default
1401

Here's a function that uses JSON.parse to return a bool indicating whether the JSON string can be successfully parsed:

function isJsonString(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return true;
}

Here's a similar function that will either return the parsed object, or null if it couldn't be parsed.

function parse_json(json_string)
{
    let json_object = null;
    
    try
    {
        json_object = JSON.parse(json_string);
    }
    
    catch (e)
    {
        return null;
    }
    
    return json_object;
}
Improve this answer
Sign up to request clarification or add additional context in comments.

17 Comments

Thank you, but I just ran this with the team and they want something that doesn't use try/catch. The question is edited along with a new title. Sorry about that.
@trejder: it does that because 1 is not a string, try it with "1"
The problem with this answer is, if the string does check out, and you parse it, you'll have parsed it twice. Couldn't you instead return false on a bad parse, but return the object on success?
@Carcigenicate You could do that. However, JSON.parse("false") evaluates to false as well.
@user3651476 That's because "12345678" is a valid json string. JSON documents have a single root node, which can be null, a boolean, a number, a string, an array or an object.
|
614

I know i'm 3 years late to this question, but I felt like chiming in.

While Gumbo's solution works great, it doesn't handle a few cases where no exception is raised for JSON.parse({something that isn't JSON})

I also prefer to return the parsed JSON at the same time, so the calling code doesn't have to call JSON.parse(jsonString) a second time.

This seems to work well for my needs:

/**
 * If you don't care about primitives and only objects then this function
 * is for you, otherwise look elsewhere.
 * This function will return `false` for any valid json primitive.
 * EG, 'true' -> false
 *     '123' -> false
 *     'null' -> false
 *     '"I'm a string"' -> false
 */
function tryParseJSONObject (jsonString){
    try {
        var o = JSON.parse(jsonString);

        // Handle non-exception-throwing cases:
        // Neither JSON.parse(false) or JSON.parse(1234) throw errors, hence the type-checking,
        // but... JSON.parse(null) returns null, and typeof null === "object", 
        // so we must check for that, too. Thankfully, null is falsey, so this suffices:
        if (o && typeof o === "object") {
            return o;
        }
    }
    catch (e) { }

    return false;
};
Improve this answer

21 Comments

Of the answers on the page, this is the most robust and reliable.
o && o !== null is superfluous.
So is using triple-equals with typeof, which always returns a string. :)
Despite being an old post, I thought it worthwhile to put a fiddle up demonstrating your answer @matth, please note that objects won't be valid.. you must pass a JSON string. Might come in handy for anyone starting out I guess.
The function should return undefined, not false because false is a valid json string and there is no way to differentiate between tryParseJSON("false") and tryParseJSON("garbage")
|
214

A comment first. The question was about not using try/catch.
If you do not mind to use it, read the answer below. Here we just check a JSON string using a regexp, and it will work in most cases, not all cases.

Have a look around the line 450 in https://github.com/douglascrockford/JSON-js/blob/master/json2.js

There is a regexp that check for a valid JSON, something like:

if (/^[\],:{}\s]*$/.test(text.replace(/\\["\\\/bfnrtu]/g, '@').
replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {

  //the json is ok

}else{

  //the json is not ok

}

EDIT: The new version of json2.js makes a more advanced parsing than above, but still based on a regexp replace ( from the comment of @Mrchief )

Improve this answer

17 Comments

This is only checking if the code is safe for eval to use. For example the following string '2011-6-27' would pass that test.
@SystemicPlural, yes but the question was about not using try/catch
You cannot test whether a string is valid JSON with a regex in JavaScript, since JS regexes don't support the necessary extensions (recursive regexes) that let you do so. Your above code fails on "{".
@Mic json2.js no longer uses that simple check (instead uses a 4 stage parsing to determine valid JSON). Would suggest to revise or remove your answer. Note that I don't think there's anythign wrong with "not having a try/catch as the sole mechanism to check for JSON" as an approach.
Just because it helps him, doesn't mean it helps the rest of us, who, years later, have the same question.
|
96 
// vanillaJS
function isJSON(str) {
    try {
        return (JSON.parse(str) && !!str);
    } catch (e) {
        return false;
    }
}

Usage: isJSON({}) will be false, isJSON('{}') will be true.

To check if something is an Array or Object (parsed JSON):

// vanillaJS
function isAO(val) {
    return val instanceof Array || val instanceof Object;
}

// ES2015
var isAO = (val) => val instanceof Array || val instanceof Object;

Usage: isAO({}) will be true, isAO('{}') will be false.

Improve this answer

7 Comments

Be careful since null passes this validation.
return !!(JSON.parse(str) && str); should block null values. I will update the answer with this code.
This is the best answer, since it also allow you to also check if the JSON has been objectified, and thus not passing the parse() test, causing WTF's.
How about isJSON('"saddf"') ? It returns true!
@Maulik, it seems a single string value is a valid JSON, [SO: Is a single string value considered valid JSON? [duplicate]](stackoverflow.com/questions/13318420/…)
|
46

Here my working code:

function IsJsonString(str) {
  try {
    var json = JSON.parse(str);
    return (typeof json === 'object');
  } catch (e) {
    return false;
  }
}
Improve this answer

4 Comments

IsJsonString(null); //returns true. It can be fixed by comparing typeof str === 'string'
null represents the empty value of an object, so this looks ok from my point of view... it might not apply to your specific scenario, but it is what it is
IsJsonString('{aa:33}') returns false
@MaulikPipaliyaJoyy I think it should be '{"aa":33}'
38

I used a really simple method to check a string how it's a valid JSON or not.

function testJSON(text){
    if (typeof text!=="string"){
        return false;
    }
    try{
        var json = JSON.parse(text);
        return (typeof json === 'object');
    }
    catch (error){
        return false;
    }
}

Result with a valid JSON string:

var input='["foo","bar",{"foo":"bar"}]';
testJSON(input); // returns true;

Result with a simple string;

var input='This is not a JSON string.';
testJSON(input); // returns false;

Result with an object:

var input={};
testJSON(input); // returns false;

Result with null input:

var input=null;
testJSON(input); // returns false;

The last one returns false because the type of null variables is object.

This works everytime. :)

Improve this answer

3 Comments

JSON.parse(null), JSON.parse("false") doesn't throw errors, probably there are more examples
Yeah, you are right, I forgot to check how the input is a string or not, If I do that, this method with null input it gives back false. But the "false" input is a valid JSON string. This will be parsed to boolean (false). Now I modify the code to be more accurate.
This will validate { a: 1, a: 2} as valid. Any ideas to make this to validate false?
22

In prototypeJS, we have method isJSON. You can try that. Even json might help.

"something".isJSON();
// -> false
"\"something\"".isJSON();
// -> true
"{ foo: 42 }".isJSON();
// -> false
"{ \"foo\": 42 }".isJSON();
// -> true
Improve this answer

5 Comments

Thanks, but I think using the prototype library to do this is a little overkilled.
You gave FOUR examples but only THREE results. What is the result for "{ foo: 42 }".isJSON()? If false, as I assume (result should follow function it document), then good question is, why it is false? { foo: 42 } seems to be perfectly valid JSON.
@trejder Unfortunately, the JSON spec requires quoted keys.
And "2002-12-15".isJSON returns true, while JSON.parse("2002-12-15") throws an error.
I think the better answer here would be to pull that function out of the prototype library and place it here. Especially since api.prototypejs.org/language/string/prototype/isjson is 404.
12

I am way too late to the party. This is what I ended up doing. Using a quick regex pre-check improves performs by a big margin

if(/^\s*(\{|\[)/.test(str)){
    try{
        JSON.parse(str)
        // do something here, or return obj/true
    }catch(e){
        //  do nothing or return false
    }
}

The regex will check if string opens with a [ or {. This will eliminate most false cases (not all). Here is a quick performance test for you https://jsbench.me/awl6fgn8jb/1

Worst case this can be 10-15% slower than using try directly, worst case meaning all strings are valid json string.

Best case this is 99% faster than pure try, best case meaning all strings are non-valid json.

This only looks for strings that parse into objects or arrays. Note that stringified js-premitive values like "true" are valid JSON strings, I'm purposefully ignoring them for the sake of simplicity. For a comprehensive pre-check please add additional checks depending on your usecase.

Improve this answer

2 Comments

This is the best answer that validates and parses in one routine. I would add an "else return false" for the initial if. Best answer !
Some of "false positive" strings excluded by regex above: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
10

Here is the typescript version too:

JSONTryParse(input: any) {
    try {
        //check if the string exists
        if (input) {
            var o = JSON.parse(input);

            //validate the result too
            if (o && o.constructor === Object) {
                return o;
            }
        }
    }
    catch (e: any) {
    }

    return false;
};
Improve this answer

1 Comment

This works for me just add function JSONTryParse(input: any) { ..
9

  • isValidJsonString - check for valid json string

  • JSON data types - string, number, object (JSON object), array, boolean, null (https://www.json.org/json-en.html)

  • falsy values in javascript - false, 0, -0, 0n, ", null, undefined, NaN - (https://developer.mozilla.org/en-US/docs/Glossary/Falsy)

  • JSON.parse

    • works well for number , boolean, null and valid json String won't raise any error. please refer example below

      • JSON.parse(2) // 2
      • JSON.parse(null) // null
      • JSON.parse(true) // true
      • JSON.parse('{"name":"jhamman"}') // {name: "jhamman"}
      • JSON.parse('[1,2,3]') // [1, 2, 3]

    • break when you parse undefined , object, array etc

      • it gave Uncaught SyntaxError: Unexpected end of JSON input . please refer example below
      • JSON.parse({})
      • JSON.parse([])
      • JSON.parse(undefined)
      • JSON.parse("jack")
function isValidJsonString(jsonString){
    
    if(!(jsonString && typeof jsonString === "string")){
        return false;
    }

    try{
       JSON.parse(jsonString);
       return true;
    }catch(error){
        return false;
    }

}
Improve this answer

Comments

8

This answer to reduce the cost of trycatch statement.

I used JQuery to parse JSON strings and I used trycatch statement to handle exceptions, but throwing exceptions for un-parsable strings slowed down my code, so I used simple Regex to check the string if it is a possible JSON string or not without going feather by checking it's syntax, then I used the regular way by parsing the string using JQuery :

if (typeof jsonData == 'string') {
    if (! /^[\[|\{](\s|.*|\w)*[\]|\}]$/.test(jsonData)) {
        return jsonData;
    }
}

try {
    jsonData = $.parseJSON(jsonData);
} catch (e) {

}

I wrapped the previous code in a recursive function to parse nested JSON responses.

Improve this answer

1 Comment

What does jQuery do that JSON.parse() doesn't do?
8

From Prototype framework String.isJSON definition here

/**
   *  String#isJSON() -> Boolean
   *
   *  Check if the string is valid JSON by the use of regular expressions.
   *  This security method is called internally.
   *
   *  ##### Examples
   *
   *      "something".isJSON();
   *      // -> false
   *      "\"something\"".isJSON();
   *      // -> true
   *      "{ foo: 42 }".isJSON();
   *      // -> false
   *      "{ \"foo\": 42 }".isJSON();
   *      // -> true
  **/
  function isJSON() {
    var str = this;
    if (str.blank()) return false;
    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
    return (/^[\],:{}\s]*$/).test(str);
  }

so this is the version that can be used passing a string object

function isJSON(str) {
    if ( /^\s*$/.test(str) ) return false;
    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
    return (/^[\],:{}\s]*$/).test(str);
  }


function isJSON(str) {
    if ( /^\s*$/.test(str) ) return false;
    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
    return (/^[\],:{}\s]*$/).test(str);
  }

console.log ("this is a json",  isJSON( "{ \"key\" : 1, \"key2@e\" : \"val\"}" ) )

console.log("this is not a json", isJSON( "{ \"key\" : 1, \"key2@e\" : pippo }" ) )

Improve this answer

3 Comments

Anyone have test suite for comparing all these answers? I'd like to see if this one is correct.
@LonnieBest good point. My 2 cents. I have used for years in production and it has always worked fine and with a reasonable execution time.
Word of warning for anyone planning to use this, not everything that is true from the above isJSON function will actually parse with JSON.parse successfully, the regexes don't fully test all possible strings. Examples of very simple truthy strings that would throw an error on JSON.parse: '[' ']' '{' '}' '{"a"}'. So just user beware, the try/catch method is likely safer for strings you don't control.
6

Maybe it will useful:

    function parseJson(code)
{
    try {
        return JSON.parse(code);
    } catch (e) {
        return code;
    }
}
function parseJsonJQ(code)
{
    try {
        return $.parseJSON(code);
    } catch (e) {
        return code;
    }
}

var str =  "{\"a\":1,\"b\":2,\"c\":3,\"d\":4,\"e\":5}";
alert(typeof parseJson(str));
alert(typeof parseJsonJQ(str));
var str_b  = "c";
alert(typeof parseJson(str_b));
alert(typeof parseJsonJQ(str_b));

output:

IE7: string,object,string,string

CHROME: object,object,string,string

Improve this answer

Comments

6

I think I know why you want to avoid that. But maybe try & catch !== try & catch. ;o) This came into my mind:

var json_verify = function(s){ try { JSON.parse(s); return true; } catch (e) { return false; }};

So you may also dirty clip to the JSON object, like:

JSON.verify = function(s){ try { JSON.parse(s); return true; } catch (e) { return false; }};

As this as encapsuled as possible, it may not break on error.

Improve this answer

Comments

4 

var jsonstring='[{"ConnectionString":"aaaaaa","Server":"ssssss"}]';

if(((x)=>{try{JSON.parse(x);return true;}catch(e){return false}})(jsonstring)){

document.write("valide json")

}else{
document.write("invalide json")
}

Improve this answer

Comments

2 
function get_json(txt)
{  var data

   try     {  data = eval('('+txt+')'); }
   catch(e){  data = false;             }

   return data;
}

If there are errors, return false.

If there are no errors, return json data

Improve this answer

3 Comments

In the question: "The solution should not contain try/catch".
Why? This is guaranteed way... Would be foolish to disuse! I'm sorry for not know English. I used Google Translate
Interesting. I'd like to see a performance comparison of JSON.parse versus this eval based solution. Yet this look scary from a security/injection perspective.
2

I infer from the opening comment that the use case is delineating whether a response is HTML or JSON. In which case, when you do receive JSON, you probably ought to be parsing it and handling invalid JSON at some point in your code anyway. Aside from anything, I imagine you would like to be informed by your browser should JSON be expected but invalid JSON received (as will users by proxy of some meaningful error message)!

Doing a full regex for JSON is unnecessary therefore (as it would be - in my experience - for most use-cases). You would probably be better off using something like the below:

function (someString) {
  // test string is opened with curly brace or machine bracket
  if (someString.trim().search(/^(\[|\{){1}/) > -1) {
    try { // it is, so now let's see if its valid JSON
      var myJson = JSON.parse(someString);
      // yep, we're working with valid JSON
    } catch (e) {
      // nope, we got what we thought was JSON, it isn't; let's handle it.
    }
  } else {
    // nope, we're working with non-json, no need to parse it fully
  }
}

that should save you having to exception handle valid non-JSON code and take care of duff json at the same time.

Improve this answer

1 Comment

This hybrid solution seems like it would be an efficient way to avoid having to do a try catch in most non-JSON cases. I like that aspect of your approach.
2 
if(resp) {
    try {
        resp = $.parseJSON(resp);
        console.log(resp);
    } catch(e) {
        alert(e);
    }
}

hope this works for you too

Improve this answer

Comments

2

If you're dealing with a response from an AJAX (or XMLHttpRequest) call, what worked for me is to check the response content type and parse or not the content accordingly.

Improve this answer

Comments

2

I thought I'd add my approach, in the context of a practical example. I use a similar check when dealing with values going in and coming out of Memjs, so even though the value saved may be string, array or object, Memjs expects a string. The function first checks if a key/value pair already exists, if it does then a precheck is done to determine if value needs to be parsed before being returned:

  function checkMem(memStr) {
    let first = memStr.slice(0, 1)
    if (first === '[' || first === '{') return JSON.parse(memStr)
    else return memStr
  }

Otherwise, the callback function is invoked to create the value, then a check is done on the result to see if the value needs to be stringified before going into Memjs, then the result from the callback is returned.

  async function getVal() {
    let result = await o.cb(o.params)
    setMem(result)
    return result

    function setMem(result) {
      if (typeof result !== 'string') {
        let value = JSON.stringify(result)
        setValue(key, value)
      }
      else setValue(key, result)
    }
  }

The complete code is below. Of course this approach assumes that the arrays/objects going in and coming out are properly formatted (i.e. something like "{ key: 'testkey']" would never happen, because all the proper validations are done before the key/value pairs ever reach this function). And also that you are only inputting strings into memjs and not integers or other non object/arrays-types.

async function getMem(o) {
  let resp
  let key = JSON.stringify(o.key)
  let memStr = await getValue(key)
  if (!memStr) resp = await getVal()
  else resp = checkMem(memStr)
  return resp

  function checkMem(memStr) {
    let first = memStr.slice(0, 1)
    if (first === '[' || first === '{') return JSON.parse(memStr)
    else return memStr
  }

  async function getVal() {
    let result = await o.cb(o.params)
    setMem(result)
    return result

    function setMem(result) {
      if (typeof result !== 'string') {
        let value = JSON.stringify(result)
        setValue(key, value)
      }
      else setValue(key, result)
    }
  }
}
Improve this answer

Comments

1

You can use the javascript eval() function to verify if it's valid.

e.g.

var jsonString = '{ "Id": 1, "Name": "Coke" }';
var json;

try {
  json = eval(jsonString);
} catch (exception) {
  //It's advisable to always catch an exception since eval() is a javascript executor...
  json = null;
}

if (json) {
  //this is json
}

Alternatively, you can use JSON.parse function from json.org:

try {
  json = JSON.parse(jsonString);
} catch (exception) {
  json = null;
}

if (json) {
  //this is json
}

Hope this helps.

WARNING: eval() is dangerous if someone adds malicious JS code, since it will execute it. Make sure the JSON String is trustworthy, i.e. you got it from a trusted source.

Edit For my 1st solution, it's recommended to do this.

 try {
      json = eval("{" + jsonString + "}");
    } catch (exception) {
      //It's advisable to always catch an exception since eval() is a javascript executor...
      json = null;
    }

To guarantee json-ness. If the jsonString isn't pure JSON, the eval will throw an exception.

Improve this answer

11 Comments

First example using eval says that "<div>foo</div>" is valid JSON. It may work differently in different browsers, but it appears that in FireFox, eval() accepts XML.
Thank you, but I just ran this with the team and they want something that doesn't use try/catch. The question is edited along with a new title. Sorry about that.
@Chi Chan. You can use option 2 without using try/catch. Without using try/catch you basically allowing harm to come to your program.
eval also accepts valid JavaScript, like "alert(5);" and strings in single quotes, which are not valid JSON.
@Mark Lutton, I hope you read my warning sentence. I said that eval executes Javascript code so alert(5) is valid for eval. Check my updated post.
|
1

Just keeping it simple

function isValidJsonString(tester) {
    //early existing
    if(/^\s*$|undefined/.test(tester) || !(/number|object|array|string|boolean/.test(typeof tester))) 
        {
        return false;
    };
//go ahead do you parsing via try catch
return true;

};

Improve this answer

Comments

1

this worked just fine for me

function isJSON(str) {
   try {
      let newJson = JSON.parse(str);
      return typeof newJson === "object" && newJson !== str || false
      
   } catch (e) {
      return false;
   }
};
Improve this answer

1 Comment

Your answer could be improved with additional supporting information. Please edit to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers in the help center.
0

Oh you can definitely use try catch to check whether its or not a valid JSON

Tested on Firfox Quantom 60.0.1

use function inside a function to get the JSON tested and use that output to validate the string. hears an example.

    function myfunction(text){

       //function for validating json string
        function testJSON(text){
            try{
                if (typeof text!=="string"){
                    return false;
                }else{
                    JSON.parse(text);
                    return true;                            
                }
            }
            catch (error){
                return false;
            }
        }

  //content of your real function   
        if(testJSON(text)){
            console.log("json");
        }else{
            console.log("not json");
        }
    }

//use it as a normal function
        myfunction('{"name":"kasun","age":10}')
Improve this answer

Comments

0

The function IsJsonString(str), that is using JSON.parse(str), doesn't work in my case.
I tried to validate json output from GraphiQL it always return false. Lucky me, isJSON works better:

var test = false;

$('body').on('DOMSubtreeModified', '.resultWrap', function() {

    if (!test) {   
        var resultWrap = "{" + $('#graphiql .resultWrap').text().split("{").pop();
        if isJSON(resultWrap) {test = !test;}
        console.log(resultWrap); 
        console.log(resultWrap.isJSON());
    }

});

Sample output:

THREE.WebGLRenderer 79
draw.js:170 {xxxxxxxxxx​
draw.js:170 false
draw.js:170 {xxxxxxxxxx ​
draw.js:170 false
draw.js:170 {xxxxxxxxxx ​
draw.js:170 false
draw.js:170 {xxxxxxxxxx ​
draw.js:170 false
draw.js:170 {​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,  "width": 396.984,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,  "width": 396.984,  "height": 327​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,  "width": 396.984,  "height": 327}​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,  "width": 396.984,  "height": 327}
draw.js:170 true
Improve this answer

Comments

0

For people who like the .Net convention of "try" functions that return a boolean and handle a byref param containing the result. If you don't need the out parameter you can omit it and just use the return value.

StringTests.js

  var obj1 = {};
  var bool1 = '{"h":"happy"}'.tryParse(obj1); // false
  var obj2 = {};
  var bool2 = '2114509 GOODLUCKBUDDY 315852'.tryParse(obj2);  // false

  var obj3 = {};
  if('{"house_number":"1","road":"Mauchly","city":"Irvine","county":"Orange County","state":"California","postcode":"92618","country":"United States of America","country_code":"us"}'.tryParse(obj3))
    console.log(obj3);

StringUtils.js

String.prototype.tryParse = function(jsonObject) {
  jsonObject = jsonObject || {};
  try {
    if(!/^[\[{]/.test(this) || !/[}\]]$/.test(this)) // begin / end with [] or {}
      return false; // avoid error handling for strings that obviously aren't json
    var json = JSON.parse(this);
    if(typeof json === 'object'){
      jsonObject.merge(json);
      return true;
    }
  } catch (e) {
    return false;
  }
}

ObjectUtils.js

Object.defineProperty(Object.prototype, 'merge', {
  value: function(mergeObj){
    for (var propertyName in mergeObj) {
      if (mergeObj.hasOwnProperty(propertyName)) {
        this[propertyName] = mergeObj[propertyName];
      }      
    }
    return this;
  },
  enumerable: false, // this is actually the default
});
Improve this answer

Comments

0

If you don't want to do try/catch anywhere, looking for a single liner, and don't mind using async functions:

const isJsonString = async str => ( await ((async v => JSON.parse(v))(str)).then(_ => true).catch(_ => false) );

await isJsonString('{ "Id": 1, "Name": "Coke" }'); // true
await isJsonString('foo'); // false
await isJsonString('<div>foo</div>'); // false
Improve this answer

5 Comments

async/await here is useless
@awHamer How else would you avoid using try/catch if JSON.parse() would throw an exception?
function validate() { try { JSON.parse("bad json"); return true; } catch (err) { console.log (err); return false; } } The same way, but without making function async...
see @Matt H. answer
I specifically stated that this answer avoids try/catch anywhere
0

if you have a doubt the value is or not json

  function isStringified(jsonValue) { // use this function to check
   try {
    console.log("need to parse");
    return JSON.parse(jsonValue);
   } catch (err) {
    console.log("not need to parse");

     return jsonValue; 
    }
  }

and then

  const json = isStringified(stringValue);

  if (typeof json == "object") {
      console.log("string is a valid json")
    }else{
      console.log("string is not a valid json")
    }
Improve this answer

4 Comments

this is just wrong. If you try parse something what is not valid json it will throw exception, please remove your answer from here, so nobody try this
it is true it will throw an exception if it's not a valid json that's why i have added checks in it to make sure what we get is actually a valid json and i'm using this way in one of my project that's why i posted this answer.
First provided code, which is not in try/catch block (const json = JSON.parse(string) ) will throw an exception and kill program and you will never get to to the typeof == "object" Try it in developers console
if you see here isStringified(stringValue); it is a function that is being called with some value inside the stringValue variable and when function starts to execute there is the try catch block that will either run successfully or catch any error and return accordingly after that it will reach the line typeof == "object". I tested this inside console and i'm using it in my project as well.
0

For those who:

  1. don't mind using try / catch blocks,
  2. want to parse "false" as a valid JSON (after all both of them are valid JSON),
  3. want to return parsed JSON in case it is valid thereby avoiding to parse the input string twice
/**
 * Function to check if a string is a valid JSON string
 * @param str string to check
 * @returns
 *  parsed JSON, if string is a valid JSON string
 *  undefined, if string is not a valid JSON string
 */
const checkIsValidJson = (str) => {
  let parsedJson;
  try {
    parsedJson = JSON.parse(str);
    /** parsed JSON will not be undefined if it is parsed successfully because undefined is not a valid JSON */
    return parsedJson;
  } catch (e) {
    /** returning undefined because null, boolean, string, array or object is a valid JSON whereas undefined is invalid JSON  */
    return undefined;
  }
};

And then you can consume it like:

const strToCheck = "false";
if (checkIsValidJson(strToCheck) !== "undefined") {
   // strToCheck is a valid JSON
} else {
   // strToCheck is invalid JSON
}

Note: If you return false or null instead of undefined, you would not be able to differentiate whether the string was invalid JSON or whether "false"/"null" was provided as input (in which case it is a valid JSON).

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.