Come verificare se una stringa è una stringa JSON valida in JavaScript senza utilizzare Try / Catch

Qualcosa di simile a:

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

//should be true
IsJsonString(jsonString);

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

La soluzione non deve contenere try / catch. Alcuni di noi attivano "rompi tutti gli errori" e non amano che il debugger si rompa su quelle stringhe JSON non valide.

Prima un commento. La domanda riguardava il non utilizzo try/catch.
Se non ti dispiace usarlo, leggi la risposta qui sotto. Qui controlliamo solo una JSONstringa usando un regexp, e funzionerà nella maggior parte dei casi, non in tutti i casi.

Dai un'occhiata alla linea 450 in https://github.com/douglascrockford/JSON-js/blob/master/json2.js

Esiste una regexp che verifica la presenza di un JSON valido, qualcosa del tipo:

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 nuova versione di json2.js effettua un parsing più avanzato di quanto sopra, ma ancora basato su un regexp sostitutivo (dal commento di @Mrchief )

Utilizzare un parser JSON come JSON.parse:

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

So di essere in ritardo di 3 anni a questa domanda, ma mi andava di rispondere.

Mentre la soluzione di Gumbo funziona alla grande, non gestisce alcuni casi in cui non viene sollevata alcuna eccezione JSON.parse({something that isn't JSON})

Preferisco anche restituire il JSON analizzato allo stesso tempo, quindi il codice chiamante non deve chiamare JSON.parse(jsonString) una seconda volta.

Questo sembra funzionare bene per le mie esigenze:

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

Uso: isJSON({}) sarà false, isJSON('{}')saràtrue .

Per verificare se qualcosa è un Arrayo Object( JSON analizzato ):

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

Uso: isAO({}) sarà true, isAO('{}')saràfalse .

Ecco il mio codice di lavoro:

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

Ho usato un metodo davvero semplice per controllare una stringa come sia o meno un JSON valido.

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

Risultato con una stringa JSON valida:

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

Risultato con una stringa semplice;

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

Risultato con un oggetto:

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

Risultato con input null:

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

L'ultimo restituisce false perché il tipo di variabili null è object.

Funziona sempre. :)

In prototypeJS, abbiamo il metodo isJSON . Puoi provarlo. Anche JSON potrebbe aiutare.

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

Dalla String.isJSONdefinizione del framework prototipo qui

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

quindi questa è la versione che può essere utilizzata passando un oggetto stringa

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

Questa risposta per ridurre il costo dell'istruzione trycatch.

Ho usato JQuery per analizzare le stringhe JSON e ho usato l'istruzione trycatch per gestire le eccezioni, ma lanciare eccezioni per stringhe non analizzabili ha rallentato il mio codice, quindi ho usato Regex semplice per controllare la stringa se è una possibile stringa JSON o no senza andare in piuma controllando la sua sintassi, quindi ho usato il modo normale analizzando la stringa usando JQuery:

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

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

}

Ho racchiuso il codice precedente in una funzione ricorsiva per analizzare le risposte JSON nidificate.

Forse sarà 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));

produzione:

IE7: stringa , oggetto, stringa, stringa

CHROME: oggetto, oggetto, stringa, stringa

Penso di sapere perché vuoi evitarlo. Ma forse prova a catturare! == prova a catturare. ; o) Mi è venuto in mente:

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

Quindi puoi anche sporcare la clip sull'oggetto JSON, come:

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

Essendo quanto più incapsulato possibile, potrebbe non rompersi in caso di errore.

Ecco anche la versione dattiloscritta:

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

Dal commento di apertura desumo che il caso d'uso stia delineando se una risposta è HTML o JSON. Nel qual caso, quando lo fai ricevere JSON, probabilmente dovrebbe essere l'analisi e la manipolazione delle JSON valido ad un certo punto nel codice in ogni caso. A parte tutto, immagino che ti piacerebbe essere informato dal tuo browser qualora JSON fosse previsto ma JSON non valido ricevuto (come faranno gli utenti per delega di alcuni messaggi di errore significativi)!

Fare una regex completa per JSON non è quindi necessario (come sarebbe - secondo la mia esperienza - per la maggior parte dei casi d'uso). Probabilmente staresti meglio usando qualcosa di simile al seguente:

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

ciò dovrebbe evitare di dover gestire eccezionalmente un codice non JSON valido e prendersi cura di duff json allo stesso tempo.

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

spero che questo funzioni anche per te

function get_json(txt)
{  var data

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

   return data;
}

In caso di errori, restituire false.

Se non ci sono errori, restituire i dati JSON

È possibile utilizzare la funzione javascript eval () per verificare se è valida.

per esempio

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
}

In alternativa, puoi usare la JSON.parsefunzione di json.org :

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

if (json) {
  //this is json
}

Spero che sia di aiuto.

ATTENZIONE : eval()è pericoloso se qualcuno aggiunge codice JS dannoso, poiché lo eseguirà. Assicurarsi che la stringa JSON sia affidabile , ovvero che tu l'abbia ottenuta da una fonte attendibile.

Modifica Per la mia prima soluzione, si consiglia di farlo.

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

Per garantire json-ness. Se il jsonStringJSON non è puro, eval genererà un'eccezione.

Oh, puoi sicuramente usare try catch per verificare se è un JSON valido o meno

Testato su Firfox Quantom 60.0.1

utilizzare la funzione all'interno di una funzione per ottenere il test JSON e utilizzare tale output per convalidare la stringa. sente un esempio.

    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 funzione IsJsonString(str)che sta usando JSON.parse(str)non funziona nel mio caso.
Ho provato a convalidare l'output json da GraphiQL che restituisce sempre false. Fortunatamente, isJSON funziona meglio:

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

});

Uscita campione:

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

Per le persone a cui piace la convenzione .Net delle funzioni "provare" che restituiscono un valore booleano e gestiscono un parametro byref contenente il risultato. Se non è necessario il parametro out, è possibile ometterlo e utilizzare semplicemente il valore restituito.

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

Codice one-liner molto semplice (ma approccio Hacky)

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

NOTA: Funziona solo se ti aspetti che qualcosa sia una stringa JSON come id. Lo sto usando per un'API e mi aspetto il risultato in JSON o in qualche stringa di errore.