Как проверить, является ли строка допустимой строкой JSON в JavaScript без использования Try / Catch

используйте парсер JSON как JSON.parse:

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

Я знаю, что опоздал на 3 года на этот вопрос, но мне хотелось вмешаться.

хотя решение Gumbo отлично работает, оно не обрабатывает несколько случаев, когда для JSON.parse({something that isn't JSON})

Я также предпочитаю возвращать разбираемый JSON одновременно, поэтому вызывающий код не должен вызывать JSON.parse(jsonString) второй раз.

это, кажется, хорошо работает для моих нужд:

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

использование:isJSON({}) будет false,isJSON('{}') будет true.

чтобы проверить, если что-то Array или Object (парсится 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;

использование:isAO({}) будет true,isAO('{}') будет false.

в прототипе js у нас есть метод isJSON. попробуйте это

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

даже http://www.prototypejs.org/learn/json

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

я использовал очень простой метод, чтобы проверить строку, как это допустимый JSON или нет.

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

результат с допустимой строкой JSON:

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

результат с простой строкой;

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

результат с объектом:

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

результат с нулевым входом:

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

последний возвращает false, потому что тип нулевых переменных-object.

это работает каждый раз. :)

из прототипа framework String.isJSON определение здесь

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

так что это версия, которая может быть использована при передаче строкового объекта

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

вы можете использовать javascript eval () функция, чтобы проверить, если это действительно.

например

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
}

кроме того, вы можете использовать JSON.parse функция от json.org:

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

if (json) {
  //this is json
}

надеюсь, что это помогает.

предупреждение:eval() и опасно если кто-то добавляет вредоносный код JS, так как он будет его выполнять. Убедитесь, что строка JSON надежный, т. е. вы получили его от доверенный источник.

Edit для моего 1-го решения, рекомендуется сделать это.

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

до гарантия json-ness. Если jsonString не является чистым JSON, eval выдаст исключение.

этот ответ, чтобы уменьшить стоимость trycatch заявление.

я использовал jQuery для разбора формата JSON строки и я trycatch заявление для обработки исключений, но исключений для ООН-распознаваемо струн замедлился мой код, поэтому я использовал простое регулярное выражение для проверки строки, если это возможно в JSON строку и не без перьев, проверяя это синтаксис, то я использовал обычный способ разбора строки с помощью jQuery :

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

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

}

I завернутый предыдущий код в рекурсивную функцию для анализа вложенных ответов JSON.

может быть, это будет полезно:

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

выход:

IE7:строка, объект, строка, строка

CHROME: объект, объект, строка, строка

Я думаю, что знаю, почему вы хотите этого избежать. Но, может быть, попробовать и поймать !== попробуйте и поймать. ;О) это пришло мне в голову:

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

таким образом, вы можете также грязный клип на объект JSON, например:

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

поскольку это как можно более инкапсулировано, он не может сломаться при ошибке.

function get_json(txt)
{  var data

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

   return data;
}

Если есть ошибки, возвращает false.

если ошибок нет, верните данные 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")
}

Я делаю вывод из вступительного комментария, что прецедент определяет, является ли ответ HTML или JSON. В каком случае, когда вы do получить JSON, вы, вероятно, должны разбирать его и обрабатывать недопустимый JSON в какой-то момент в вашем коде в любом случае. Помимо всего прочего, я полагаю, что вы хотели бы быть проинформированы вашим браузером, если JSON ожидается, но недействительный JSON получен (как и пользователи через прокси-сервер некоторого значимого сообщения об ошибке)!

выполнение полного регулярного выражения для JSON поэтому нет необходимости (как это было бы - по моему опыту - для большинства случаев использования). Вы, вероятно, было бы лучше использовать что-то вроде ниже:

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

это должно избавить вас от необходимости обрабатывать исключения действительный код не JSON и позаботьтесь о duff json в то же время.

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

надеюсь, что это работает для вас тоже

вот версия typescript тоже:

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

О, вы можете определенно использовать try catch, чтобы проверить, является ли его действительным JSON

протестировано на Firfox Quantom 60.0.1

используйте функцию внутри функции, чтобы проверить JSON и использовать этот вывод для проверки строки. слышит пример.

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

вот мой рабочий код:

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