Try / Catch를 사용하지 않고 문자열이 JavaScript에서 유효한 JSON 문자열인지 확인하는 방법

다음과 같은 것 :

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정규 표현식을 사용하여 문자열을 확인하면 모든 경우가 아니라 대부분의 경우 작동합니다.

https://github.com/douglascrockford/JSON-js/blob/master/json2.js 에서 450 줄을 둘러보십시오.

유효한 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.

무언가가 ( 구문 분석 된 JSON) Array인지 확인하려면 다음을 수행하십시오 .Object

// 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 : 문자열 , 개체, 문자열, 문자열

크롬 : 개체, 개체, 문자열, 문자열

나는 당신이 그것을 피하고 싶은 이유를 알고 있다고 생각합니다. 그러나 어쩌면 시도 & 캐치! == 시도 & 캐치. ; o) 이것은 내 마음에왔다 :

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 코드를 가진 저장해야 하고 동시에 푸딩 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.org의JSON.parse 함수를 사용할 수 있습니다 .

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-ness 를 보장 합니다. jsonString순수 JSON이 아닌 경우 eval은 예외를 throw합니다.

아, 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)하지 않습니다. GraphiQL
에서 json 출력의 유효성을 검사하려고 시도했지만 항상 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

부울을 반환하고 결과를 포함하는 byref 매개 변수를 처리하는 "try"함수의 .Net 규칙을 좋아하는 사람들을 위해. 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
});

매우 간단한 한 줄짜리 코드 (그러나 Hacky 접근 방식)

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

참고 : 이것은 id와 같은 JSON 문자열이 예상되는 경우에만 작동합니다. API에 사용하고 JSON 또는 일부 오류 문자열로 결과를 기대합니다.