javascript - try - node js string to json

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

Question

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.

Answer 1

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

Utilicé JQuery para analizar cadenas JSON y utilicé la instrucción trycatch para manejar las excepciones, pero las excepciones para las cadenas no analizables ralentizaron mi código, así que usé Regex simple para verificar la cadena si es una cadena JSON posible o no al verificar su sintaxis, luego utilicé la forma regular analizando 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 las respuestas JSON anidadas.

Answer 2

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

Answer 3

Aquí mi código de trabajo:

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

Answer 4

Creo que sé por qué quieres evitar eso. Pero tal vez intentar y atrapar! == probar y atrapar. ; 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 ensuciar el clip al objeto JSON, como:

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

Como esto está lo más encapsulado posible, puede que no se rompa por error.

Answer 5

De acuerdo con el comentario de apertura, deduzco que el caso de uso es delinear si una respuesta es HTML o JSON. En cuyo caso, cuando reciba JSON, probablemente debería analizarlo y manejar JSON no válido en algún punto de su código de todos modos. Aparte de cualquier cosa, me 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, no es necesario hacer una expresión regular completa para JSON (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 evitarle tener que manejar de manera excepcional el código válido no JSON y cuidar de Duff Json al mismo tiempo.

Answer 6

De la definición de Prototype framework String.isJSON 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);
  }

así que esta es la versión que se puede usar para pasar 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 }" ) )

Answer 7

En el prototipo js tenemos el método isJSON. trata eso

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

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

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

Answer 8

Puede usar la función eval() 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 función https://github.com/douglascrockford/JSON-js/blob/master/json2.js de https://github.com/douglascrockford/JSON-js/blob/master/json2.js :

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 un 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 jsonString no es JSON puro, el eval lanzará una excepción.

Answer 9

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

Answer 10

Use un analizador JSON como JSON.parse :

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

Answer 11

Utilicé un método muy simple para verificar una cadena de cómo 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 un objeto.

Esto funciona cada vez. :)

Answer 12

Sé que tengo 3 años de retraso en esta pregunta, pero me sentí como si estuviera a punto.

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

También prefiero devolver el JSON analizado al mismo tiempo, por lo que el código de llamada no tiene que llamar a 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;
};

Answer 13

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

Eche un vistazo alrededor de 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 una expresión regular (del comentario de @Mrchief )

Answer 14

Oh, definitivamente puedes usar try catch para comprobar 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 probar 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}'')

Answer 15

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

Answer 16

// 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 una Array u 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 .

Answer 17

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, devuelve datos json

Answer 18

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

Espero que esto funcione para usted también