parse - Como verificar se uma string é uma string JSON válida em JavaScript sem usar Try / Catch




to check (16)

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

Uso: isJSON({}) será false , isJSON('{}') será true .

Para verificar se algo é uma Array ou Object (JSON analisado ):

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

Algo como:

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

//should be true
IsJsonString(jsonString);

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

A solução não deve conter try / catch. Alguns de nós ativam "interromper todos os erros" e não gostam que o depurador quebre essas cadeias JSON inválidas.


function get_json(txt)
{  var data

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

   return data;
}

Se houver erros, retorne false.

Se não houver erros, retorne os dados do json


Talvez seja ú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));

saída:

IE7: string , objeto, string, string

CHROME: objeto, objeto, string, string


Inferi no comentário de abertura que o caso de uso está delineando se uma resposta é HTML ou JSON. Nesse caso, quando você recebe JSON, provavelmente deve analisá-lo e manipular JSON inválido em algum momento do seu código. Além de qualquer coisa, imagino que você gostaria de ser informado pelo seu navegador, caso o JSON seja esperado, mas o JSON inválido foi recebido (assim como os usuários por proxy de alguma mensagem de erro significativa)!

Fazer um regex completo para JSON é, portanto, desnecessário (como seria - na minha experiência - para a maioria dos casos de uso). Você provavelmente estaria melhor usando algo como o abaixo:

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

Isso deve evitar que você tenha que lidar com código não-JSON válido e cuidar de duff json ao mesmo tempo.


Você pode usar a função javascript eval() para verificar se é válida.

por exemplo

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, você pode usar a função https://github.com/douglascrockford/JSON-js/blob/master/json2.js do 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 isto ajude.

ATENÇÃO : eval() é perigoso se alguém adicionar código JS malicioso, já que ele será executado. Certifique-se de que o JSON String seja confiável , ou seja, você o obteve de uma fonte confiável.

Editar Para a minha primeira solução, é recomendável fazer isso.

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

Para garantir json-ness. Se o jsonString não for puro JSON, o eval lançará uma exceção.


Use um analisador JSON como JSON.parse :

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

Do framework de protótipo String.isJSON definição 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);
  }

então esta é a versão que pode ser usada passando um objeto de 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, \"[email protected]\" : \"val\"}" ) )

console.log("this is not a json", isJSON( "{ \"key\" : 1, \"[email protected]\" : pippo }" ) )


Eu acho que sei porque você quer evitar isso. Mas talvez tente & catch! == try & catch. o) Isso veio em minha mente:

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

Então você também pode clip sujo para o objeto JSON, como:

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

Como isso encapsulado quanto possível, ele não pode quebrar em erro.


Aqui está a versão typescript também:

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

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


Esta resposta para reduzir o custo da declaração trycatch.

Eu usei o JQuery para analisar strings JSON e usei a instrução trycatch para lidar com exceções, mas lançar exceções para strings não analisáveis ​​desacelerou meu código, então usei o Regex simples para verificar a string se ela é uma string JSON possível ou não sem passar verificando sua sintaxe, então eu usei o modo normal analisando a string usando JQuery:

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

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

}

Eu agrupei o código anterior em uma função recursiva para analisar respostas JSON aninhadas.


Eu usei um método muito simples para verificar uma string como é um JSON válido ou não.

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

Resultado com uma string JSON válida:

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

Resultado com uma string simples;

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

Resultado com um objeto:

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

Resultado com entrada nula:

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

O último retorna false porque o tipo de variáveis ​​nulas é objeto.

Isso funciona toda vez. :)


Eu sei que estou atrasado 3 anos para esta pergunta, mas eu senti vontade de entrar.

Embora a solução da Gumbo funcione muito bem, ela não JSON.parse({something that isn't JSON}) a alguns casos em que nenhuma exceção é levantada para o JSON.parse({something that isn't JSON})

Eu também prefiro retornar o JSON analisado ao mesmo tempo, então o código de chamada não precisa chamar JSON.parse(jsonString) uma segunda vez.

Isso parece funcionar bem para minhas necessidades:

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

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

Espero que isto funcione para você também


Aqui meu código de trabalho:

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

Use a alternância de classes, não a edição de estilo. . .

Usando classes designadas para elementos "escondidos" é fácil e também um dos métodos mais eficientes. Alternar uma classe 'hidden' com um estilo de Display 'none' será mais rápido do que editar esse estilo diretamente. Expliquei um pouco disso bastante na questão do . Tornando dois elementos visíveis / ocultos na mesma div .

Melhores Práticas e Otimização de JavaScript

Aqui está um vídeo verdadeiramente esclarecedor de um engenheiro de front-end do Google Tech Talk do Google, Nicholas Zakas:





javascript json