Comment vérifier si une chaîne de caractères est une chaîne JSON valide dans JavaScript sans utiliser Try / Catch

utiliser 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 pour cette question, mais j'ai eu envie de répondre.

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

je préfère aussi rendre le parsed JSON en même temps, donc le code d'appel n'a 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 Array ou Object ( analysé JSON):

// 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 .

dans prototype js nous avons la méthode isJSON. essayez

http://api.prototypejs.org/language/string/prototype/isjson /

even http://www.prototypejs.org/learn/json

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

j'ai utilisé une méthode très simple pour vérifier une chaîne en quoi c'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 renvoie false parce que le type de variables nulles est object.

ça marche à chaque fois. :)

Prototype Du cadre String.isJSON définition 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);
  }

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

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

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 JSON.parse fonction de json.org :

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

if (json) {
  //this is json
}

Espérons que cette aide.

AVERTISSEMENT : eval() est dangereux si quelqu'un ajoute malveillants code JS, car il va l'exécuter. Assurez-vous que la chaîne de caractères JSON est digne de confiance , 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;
    }

à garantie json-ness. Si le jsonString n'est pas du pur JSON, l'eval fera une exception.

cette réponse pour réduire le coût de TryCatch statement.

j'ai utilisé JQuery pour analyser les chaînes JSON et j'ai utilisé la déclaration trycatch pour gérer les exceptions, mais lancer des exceptions pour les chaînes Non-parsables a ralenti mon code, donc J'ai utilisé Regex simple pour vérifier la chaîne si elle est une chaîne JSON possible ou non sans aller feather en vérifiant sa syntaxe, puis j'ai utilisé la voie régulière en analysant la chaîne en utilisant JQuery :

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

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

}

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

peut-être qu'il 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));

sortie:

IE7: chaîne ,de l'objet,de la chaîne,la chaîne

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

je crois savoir pourquoi vous voulez éviter ça. Mais peut-être essayer et attraper !== try et catch. ;o) cela me vint à l'esprit:

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

donc vous pouvez aussi Dirty clip à l'objet JSON, comme:

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

comme ceci aussi encapsulé que possible, il ne peut pas casser sur erreur.

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'erreurs, retourner les données json

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

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, quand vous do recevez JSON, vous devriez probablement l'analyser et traiter JSON invalide à un moment donné dans votre code de toute façon. Mis à part quoi que ce soit, j'imagine que vous aimeriez être informé par votre navigateur si JSON était attendu mais non valide JSON reçu (comme le seront les utilisateurs par procuration d'un message d'erreur significatif)!

Doing un regex complet pour JSON est donc inutile (comme ce serait - dans mon expérience - pour la plupart des cas d'utilisation). Vous seriez probablement mieux à l'aide de quelque chose comme ce qui suit:

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

qui devrait vous éviter d'avoir à l'exception gérer valide Non-code JSON et prendre soin de duff json en même temps.

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

espérons que cela fonctionne pour vous aussi

Voici la version dactylographiée aussi:

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

Oh, vous pouvez certainement utiliser try catch de vérifier si elle ou non un JSON valide

testé sur Firfox Quantom 60.0.1

utilise la fonction à l'intérieur d'une fonction pour tester le JSON et utilise 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}')

Voici mon code de travail:

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