Cómo verificar si una cadena es una cadena JSON válida en JavaScript sin usar Try / Catch

Algo como:

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

//should be true
IsJsonString(jsonString);

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

La solución no debe contener try / catch. Algunos de nosotros activamos "romper todos los errores" y no les gusta que el depurador rompa esas cadenas JSON no válidas.

Un comentario primero. La pregunta era sobre no usar try/catch.
Si no le importa usarlo, lea la respuesta a continuación. Aquí solo verificamos una JSONcadena usando una expresión regular, y funcionará en la mayoría de los casos, no en todos los casos.

Eche un vistazo a la línea 450 en https://github.com/douglascrockford/JSON-js/blob/master/json2.js

Hay una expresión regular que comprueba un JSON válido, algo así como:

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

}

EDITAR : La nueva versión de json2.js hace un análisis más avanzado que el anterior, pero aún se basa en un reemplazo de expresiones regulares (del comentario de @Mrchief )

Use un analizador JSON como JSON.parse:

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

Sé que llego 3 años tarde a esta pregunta, pero sentí ganas de hablar.

Si bien la solución de Gumbo funciona muy bien, no maneja algunos casos en los que no se plantea ninguna excepción para JSON.parse({something that isn't JSON})

También prefiero devolver el JSON analizado al mismo tiempo, para que el código de llamada no tenga que llamar JSON.parse(jsonString) por segunda vez.

Esto parece funcionar bien para mis necesidades:

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({}) será false, isJSON('{}')será true.

Para verificar si algo es un Arrayo Object( JSON analizado ):

// 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({}) será true, isAO('{}')será false.

Aquí mi código de trabajo:

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

Utilicé un método realmente simple para verificar si una cadena es un JSON válido o no.

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

Resultado con una cadena JSON válida:

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

Resultado con una cadena simple;

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

Resultado con un objeto:

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

Resultado con entrada nula:

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

El último devuelve falso porque el tipo de variables nulas es objeto.

Esto funciona todo el tiempo. :)

En prototypeJS, tenemos el método isJSON . Puedes probar eso. Incluso json podría ayudar.

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

De la String.isJSONdefinición del marco prototipo aquí

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

así que esta es la versión que se puede usar pasando un objeto de cadena

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

Esta respuesta para reducir el costo de la declaración trycatch.

Usé JQuery para analizar cadenas JSON y usé la declaración trycatch para manejar excepciones, pero lanzar excepciones para cadenas no analizables ralentizó mi código, por lo que usé Regex simple para verificar la cadena si es una posible cadena JSON o no sin pluma comprobando su sintaxis, luego usé la forma regular al analizar la cadena usando JQuery:

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

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

}

Envolví el código anterior en una función recursiva para analizar respuestas JSON anidadas.

Tal vez sea útil:

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

salida:

IE7: cadena , objeto, cadena, cadena

CROMO: objeto, objeto, cadena, cadena

Creo que sé por qué quieres evitar eso. Pero tal vez intente y atrape! == intente y atrape. ; o) Esto vino a mi mente:

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

Por lo tanto, también puede hacer un clip sucio al objeto JSON, como:

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

Como esto está tan encapsulado como sea posible, es posible que no se rompa por error.

Aquí está la versión mecanografiada también:

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

Por el comentario inicial deduzco que el caso de uso está delineando si una respuesta es HTML o JSON. En cuyo caso, cuando lo hagas recibir JSON, probablemente debería ser el análisis y la manipulación de JSON no válida en algún momento de su código de todos modos. Aparte de cualquier cosa, ¡imagino que le gustaría que su navegador le informara si se espera JSON pero se recibe JSON no válido (al igual que los usuarios por proxy de algún mensaje de error significativo)!

Por lo tanto, hacer una regex completa para JSON es innecesario (como sería, en mi experiencia, para la mayoría de los casos de uso). Probablemente sería mejor usar algo como lo siguiente:

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

eso debería evitar que tenga que manejar un código no JSON válido y cuidar de duff json al mismo tiempo.

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

Espero que esto funcione para usted también

function get_json(txt)
{  var data

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

   return data;
}

Si hay errores, devuelva falso.

Si no hay errores, devuelva datos json

Puede usar la función de evaluación de JavaScript () para verificar si es válida.

p.ej

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
}

Alternativamente, puede usar la JSON.parsefunción de json.org :

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

if (json) {
  //this is json
}

Espero que esto ayude.

ADVERTENCIA : eval()es peligroso si alguien agrega código JS malicioso, ya que lo ejecutará. Asegúrese de que la cadena JSON sea confiable , es decir, la obtuvo de una fuente confiable.

Editar Para mi primera solución, se recomienda hacer esto.

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

Para garantizar json-ness. Si el jsonStringJSON no es puro, la evaluación arrojará una excepción.

Oh, definitivamente puedes usar try catch para verificar si es o no un JSON válido

Probado en Firfox Quantom 60.0.1

use la función dentro de una función para hacer que se pruebe el JSON y use esa salida para validar la cadena. escucha un ejemplo.

    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 función IsJsonString(str), que está usando JSON.parse(str), no funciona en mi caso.
Intenté validar la salida json de GraphiQL , siempre devuelve falso. Por suerte, isJSON funciona mejor:

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

});

Salida de muestra:

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

Para las personas a las que les gusta la convención .Net de funciones "probar" que devuelven un valor booleano y manejan un parámetro byref que contiene el resultado. Si no necesita el parámetro out, puede omitirlo y simplemente usar el valor de retorno.

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

Código de línea simple muy simple (pero enfoque de Hacky)

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

NOTA: Esto solo funciona si espera que algo sea una cadena JSON como id. Lo estoy usando para una API y espero el resultado en JSON o en alguna cadena de error.