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

Что-то вроде:

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

//should be true
IsJsonString(jsonString);

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

Решение не должно содержать try / catch. Некоторые из нас включают «разбить все ошибки», и им не нравится, когда отладчик ломает эти недопустимые строки JSON.

Сначала комментарий. Вопрос был о неиспользовании try/catch.
Если вы не против его использовать, прочитайте ответ ниже. Здесь мы просто проверяем JSONстроку с помощью регулярного выражения, и она будет работать в большинстве случаев, а не во всех.

Посмотрите вокруг линии 450 в https://github.com/douglascrockford/JSON-js/blob/master/json2.js

Существует регулярное выражение, которое проверяет правильность JSON, что-то вроде:

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

}

РЕДАКТИРОВАТЬ : новая версия json2.js делает более сложный синтаксический анализ, чем выше, но все еще основанный на замене регулярного выражения (из комментария @Mrchief )

Используйте синтаксический анализатор 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.

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

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

Я использовал очень простой метод, чтобы проверить строку, является ли она действительным 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, потому что типом нулевых переменных является объект.

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

В prototypeJS у нас есть метод isJSON . Вы можете попробовать это. Даже JSON может помочь.

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

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

Этот ответ позволит снизить стоимость оператора trycatch.

Я использовал JQuery для анализа строк JSON и использовал оператор trycatch для обработки исключений, но создание исключений для непарсируемых строк замедлило мой код, поэтому я использовал простой Regex, чтобы проверить строку, если это возможная строка JSON или нет, не сходя с ума. проверив его синтаксис, затем я использовал обычный способ, проанализировав строку с помощью JQuery:

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

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

}

Я обернул предыдущий код в рекурсивную функцию для анализа вложенных ответов 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: строка , объект, строка, строка

ХРОМ: объект, объект, строка, строка

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

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

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

Вот версия для машинописи тоже:

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

Из вступительного комментария я делаю вывод, что вариант использования определяет, является ли ответ HTML или JSON. В этом случае, когда вы делаете получить 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);
    }
}

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

function get_json(txt)
{  var data

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

   return data;
}

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

Если ошибок нет, верните данные json

Вы можете использовать функцию 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 заслуживает доверия , т.е. вы получили ее из надежного источника.

Редактировать Для моего первого решения рекомендуется сделать это.

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

Чтобы гарантировать json-несс. Если jsonStringне чистый JSON, eval выдаст исключение.

О, вы определенно можете использовать 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}')

Функция IsJsonString(str), которая используется JSON.parse(str), не работает в моем случае.
Я пытался проверить вывод json из GraphiQL, он всегда возвращал false. К счастью, isJSON работает лучше:

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

});

Пример вывода:

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

Для людей, которым нравится соглашение .Net о функциях try, которые возвращают логическое значение и обрабатывают параметр byref, содержащий результат. Если вам не нужен параметр out, вы можете его пропустить и просто использовать возвращаемое значение.

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

Очень простой однострочный код (но хакерский подход)

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

ПРИМЕЧАНИЕ. Это работает только в том случае, если вы ожидаете, что что-то представляет собой строку JSON, например, id. Я использую его для API и ожидаю результата либо в JSON, либо в какой-то строке ошибки.