Использование try / catch для проверки JSON? [Дубликат]

в прототипе js мы имеем метод isSON. попробуйте

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

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

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

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

Из определения Prototype 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 }" ) )

Я знаю, что я на 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.