Comment vérifier si une chaîne est une chaîne JSON valide en JavaScript sans utiliser Try / Catch

Quelque chose comme:

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

//should be true
IsJsonString(jsonString);

//should be false
IsJsonString("foo");
IsJsonString("<div>foo</div>")

La solution ne doit pas contenir try / catch. Certains d'entre nous activent "pause sur toutes les erreurs" et ils n'aiment pas que le débogueur se casse sur ces chaînes JSON invalides.

Un commentaire d'abord. La question était de ne pas utiliser try/catch.
Si cela ne vous dérange pas de l'utiliser, lisez la réponse ci-dessous. Ici, nous vérifions simplement une JSONchaîne à l'aide d'une expression rationnelle, et cela fonctionnera dans la plupart des cas, pas dans tous les cas.

Jetez un œil à la ligne 450 dans https://github.com/douglascrockford/JSON-js/blob/master/json2.js

Il y a une expression rationnelle qui vérifie un JSON valide, quelque chose comme:

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 : La nouvelle version de json2.js fait une analyse plus avancée que ci-dessus, mais toujours basée sur un remplacement regexp (d'après le commentaire de @Mrchief )

Utilisez un analyseur JSON comme JSON.parse:

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

Je sais que j'ai 3 ans de retard par rapport à cette question, mais j'avais envie d'intervenir.

Bien que la solution de Gumbo fonctionne très bien, elle ne gère pas quelques cas où aucune exception n'est levée pour JSON.parse({something that isn't JSON})

Je préfère également renvoyer le JSON analysé en même temps, afin que le code appelant n'ait pas à appeler JSON.parse(jsonString)une deuxième fois.

Cela semble bien fonctionner pour mes besoins:

function tryParseJSON (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;
};

// vanillaJS
function isJSON(str) {
    try {
        return (JSON.parse(str) && !!str);
    } catch (e) {
        return false;
    }
}

Utilisation: isJSON({}) sera false, isJSON('{}')sera true.

Pour vérifier si quelque chose est un Arrayou Object( JSON analysé ):

// vanillaJS
function isAO(val) {
    return val instanceof Array || val instanceof Object ? true : false;
}

// ES2015
var isAO = (val) => val instanceof Array || val instanceof Object ? true : false;

Utilisation: isAO({}) sera true, isAO('{}')sera false.

Voici mon code de travail:

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

J'ai utilisé une méthode très simple pour vérifier si une chaîne est un JSON valide ou non.

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

Résultat avec une chaîne JSON valide:

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

Résultat avec une chaîne simple;

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

Résultat avec un objet:

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

Résultat avec entrée nulle:

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

Le dernier retourne false car le type des variables nulles est object.

Cela fonctionne à chaque fois. :)

Dans prototypeJS, nous avons la méthode isJSON . Vous pouvez essayer ça. Même json pourrait aider.

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

De la String.isJSONdéfinition du cadre du prototype ici

/**
   *  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);
  }

c'est donc la version qui peut être utilisée en passant un objet chaîne

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

Cette réponse pour réduire le coût de l'instruction trycatch.

J'ai utilisé JQuery pour analyser les chaînes JSON et j'ai utilisé l'instruction trycatch pour gérer les exceptions, mais le lancement d'exceptions pour les chaînes non analysables a ralenti mon code, j'ai donc utilisé Regex simple pour vérifier la chaîne s'il s'agit d'une chaîne JSON possible ou non sans aller de plume en vérifiant sa syntaxe, j'ai ensuite utilisé la méthode habituelle en analysant la chaîne à l'aide de JQuery:

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

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

}

J'ai encapsulé le code précédent dans une fonction récursive pour analyser les réponses JSON imbriquées.

Peut-être que cela sera utile:

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

production:

IE7: chaîne , objet, chaîne, chaîne

CHROME: objet, objet, chaîne, chaîne

Je pense que je sais pourquoi vous voulez éviter cela. Mais peut-être essayer et attraper! == essayer et attraper. ; o) Cela m'est venu à l'esprit:

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

Ainsi, vous pouvez également ajouter un clip sale à l'objet JSON, comme:

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

Comme cela est aussi encapsulé que possible, il ne peut pas se casser en cas d'erreur.

Voici également la version dactylographiée:

JSONTryParse(input) {
    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) {
    }

    return false;
};

Je déduis du commentaire d'ouverture que le cas d'utilisation délimite si une réponse est HTML ou JSON. Dans ce cas, lorsque vous faites recevoir JSON, vous devriez probablement être l' analyse et la manipulation JSON invalide à un moment donné dans votre code de toute façon. En plus de tout, j'imagine que vous aimeriez être informé par votre navigateur si JSON était attendu mais JSON invalide reçu (tout comme les utilisateurs par proxy d'un message d'erreur significatif)!

Il n'est donc pas nécessaire de faire une regex complète pour JSON (comme ce serait - selon mon expérience - pour la plupart des cas d'utilisation). Vous feriez probablement mieux d'utiliser quelque chose comme ci-dessous:

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

cela devrait vous éviter d'avoir à gérer exceptionnellement du code non JSON valide et à prendre soin de duff json en même temps.

if(resp) {
    try {
        resp = $.parseJSON(resp);
        console.log(resp);
    } catch(e) {
        alert(e);
    }
}

j'espère que cela fonctionne aussi pour vous

function get_json(txt)
{  var data

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

   return data;
}

S'il y a des erreurs, retournez false.

S'il n'y a pas d'erreur, renvoyez les données json

Vous pouvez utiliser la fonction javascript eval () pour vérifier si elle est valide.

par exemple

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
}

Alternativement, vous pouvez utiliser la JSON.parsefonction de json.org :

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

if (json) {
  //this is json
}

J'espère que cela t'aides.

AVERTISSEMENT : eval()est dangereux si quelqu'un ajoute du code JS malveillant, car il l'exécutera. Assurez-vous que la chaîne JSON est fiable , c'est-à-dire que vous l'avez obtenue d'une source fiable.

Modifier Pour ma 1ère solution, il est recommandé de le faire.

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

Pour garantir json-ness. Si le jsonStringJSON n'est pas pur, l'eval lèvera une exception.

Oh, vous pouvez certainement utiliser try catch pour vérifier s'il s'agit ou non d'un JSON valide

Testé sur Firfox Quantom 60.0.1

utilisez la fonction à l'intérieur d'une fonction pour tester le JSON et utilisez cette sortie pour valider la chaîne. entend un exemple.

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

La fonction IsJsonString(str), qui utilise JSON.parse(str), ne fonctionne pas dans mon cas.
J'ai essayé de valider la sortie json de GraphiQL, elle retourne toujours false. Heureusement, isJSON fonctionne mieux:

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

});

Exemple de sortie:

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

Pour les personnes qui aiment la convention .Net des fonctions "try" qui renvoient un booléen et gèrent un paramètre byref contenant le résultat. Si vous n'avez pas besoin du paramètre out, vous pouvez l'omettre et utiliser simplement la valeur de retour.

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

Code simple simple (approche Hacky)

if (expected_json.id === undefined){
   // not a json
}
else{
   // json
}

REMARQUE: cela ne fonctionne que si vous attendez quelque chose comme une chaîne JSON comme id. Je l'utilise pour une API et j'attends le résultat soit en JSON soit en une chaîne d'erreur.