문자열이 JSON인지 테스트하는 방법?

간단한 AJAX 호출이 있으며 서버는 유용한 데이터가 포함 된 JSON 문자열 또는 PHP 함수에서 생성 된 오류 메시지 문자열을 반환합니다 mysql_error(). 이 데이터가 JSON 문자열인지 또는 오류 메시지인지 테스트하려면 어떻게해야합니까?

isJSON함수 instanceof를 사용하여 무언가가 Array인지 테스트 하는 것처럼 호출되는 함수를 사용하는 것이 좋습니다 .

이것이 내가 원하는거야:

if (isJSON(data)){
    //do some data stuff
}else{
    //report the error
    alert(data);
}

JSON.parse 사용

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

이 코드는 JSON.parse(1234)또는 JSON.parse(0)또는 JSON.parse(false)또는 JSON.parse(null)모두가 true를 돌려줍니다.

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

그래서 나는 이런 식으로 코드를 다시 작성했습니다.

function isJson(item) {
    item = typeof item !== "string"
        ? JSON.stringify(item)
        : item;

    try {
        item = JSON.parse(item);
    } catch (e) {
        return false;
    }

    if (typeof item === "object" && item !== null) {
        return true;
    }

    return false;
}

테스트 결과 :

isJson 테스트 결과

이것을 다시 한 번 살펴 보겠습니다 (2019+ 이상).

인수 : 값은 같은 true, false, nullJSON 유효 (?)

사실 :이 프리미티브 값은 JSON 구문 분석이 가능 하지만 올바르게 구성된 JSON 구조 는 아닙니다 . JSON 사양 은 JSON이 이름 / 값 쌍 (오브젝트) 또는 정렬 된 값 목록 (배열)의 두 가지 구조로 구축되었음을 나타냅니다.

인수 : 예외 처리를 사용하여 예상되는 작업을 수행해서는 안됩니다.
(이것은 25 개 이상의 공감을 가진 의견입니다!)

사실 : 아니요! 특히 이와 같은 경우 try / catch를 사용하는 것이 합법적입니다. 그렇지 않으면 토큰 화 / 정규식 작업과 같은 많은 문자열 분석 작업을 수행해야합니다. 끔찍한 성능을 발휘합니다.

hasJsonStructure()

일부 데이터 / 텍스트에 올바른 JSON 교환 형식이 있는지 확인하는 것이 목표 인 경우에 유용합니다.

function hasJsonStructure(str) {
    if (typeof str !== 'string') return false;
    try {
        const result = JSON.parse(str);
        const type = Object.prototype.toString.call(result);
        return type === '[object Object]' 
            || type === '[object Array]';
    } catch (err) {
        return false;
    }
}

용법:

hasJsonStructure('true')             // —» false
hasJsonStructure('{"x":true}')       // —» true
hasJsonStructure('[1, false, null]') // —» true

safeJsonParse()

또한 일부 데이터를 JavaScript 값으로 구문 분석 할 때주의해야 할 경우에 유용합니다.

function safeJsonParse(str) {
    try {
        return [null, JSON.parse(str)];
    } catch (err) {
        return [err];
    }
}

용법:

const [err, result] = safeJsonParse('[Invalid JSON}');
if (err) {
    console.log('Failed to parse JSON: ' + err.message);
} else {
    console.log(result);
}

서버가 JSON으로 응답하는 경우 application/json컨텐츠 유형이 있고 일반 텍스트 메시지로 응답하는 경우 컨텐츠 유형이 있어야 text/plain합니다. 서버가 올바른 컨텐츠 유형으로 응답하는지 확인하고 테스트하십시오.

jQuery $.ajax()응답을 사용할 때 responseJSON응답이 JSON 인 경우 속성 을 가지므로 다음과 같이 확인할 수 있습니다.

if (xhr.hasOwnProperty('responseJSON')) {}

나는 가장 좋은 대답을 좋아하지만 빈 문자열이면 true를 반환합니다. 그래서 여기 수정이 있습니다 :

function isJSON(MyTestStr){
    try {
        var MyJSON = JSON.stringify(MyTestStr);
        var json = JSON.parse(MyJSON);
        if(typeof(MyTestStr) == 'string')
            if(MyTestStr.length == 0)
                return false;
    }
    catch(e){
        return false;
    }
    return true;
}

var parsedData;

try {
    parsedData = JSON.parse(data)
} catch (e) {
    // is not a valid JSON string
}

그러나 귀하의 http 통화 / 서비스는 항상 동일한 형식의 데이터를 반환해야한다고 제안합니다. 따라서 오류가있는 경우이 오류를 래핑하는 JSON 객체가 있어야합니다.

{"error" : { "code" : 123, "message" : "Foo not supported" } } 

HTTP 상태뿐만 아니라 5xx 코드도 사용할 수 있습니다.

글쎄 ... 데이터 수신 방법에 따라 다릅니다. 서버가 JSON 형식 문자열로 응답한다고 생각합니다 (예 : PHP에서 json_encode () 사용). JQuery 게시를 사용하고 응답 데이터를 JSON 형식으로 설정하고 형식이 잘못된 JSON 인 경우 오류가 발생합니다.

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        //Supposing x is a JSON property...
        alert(response.x);

  },
  dataType: 'json',
  //Invalid JSON
  error: function (){ alert("error!"); }
});

그러나 유형 응답을 텍스트로 사용하는 경우 $ .parseJSON을 사용해야합니다. jquery 사이트에 따르면 : "잘못된 JSON 문자열을 전달하면 예외가 발생할 수 있습니다." 따라서 코드는 다음과 같습니다.

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        try {
            parsedData = JSON.parse(response);
        } catch (e) {
            // is not a valid JSON string
        }

  },
  dataType: 'text',
});

이 아마도 당신이 JSON은 항상에 둘러싸여 것입니다 반환 것을 알고있는 경우 예를 들어, 당신이 할 수있는 테스트 {및 }다음 해당 문자 또는 다른 해키 방법을 테스트 할 수있다. 또는 json.org JS 라이브러리를 사용하여 구문 분석하고 성공했는지 테스트 할 수 있습니다.

그러나 나는 다른 접근법을 제안 할 것입니다. 호출이 성공하면 PHP 스크립트는 현재 JSON을 반환하지만 그렇지 않으면 다른 것을 반환합니다. 왜 항상 JSON을 반환 하지 않습니까?

예 :

성공적인 전화 :

{ "status": "success", "data": [ <your data here> ] }

잘못된 전화 :

{ "status": "error", "error": "Database not found" }

이렇게하면 클라이언트 쪽 JS를 훨씬 쉽게 작성할 수 있습니다. "상태"멤버와 그에 따른 동작을 확인하기 만하면됩니다.

나는 그것을 수행하기 위해 단 2 줄을 사용합니다 :

var isValidJSON = true;
try { JSON.parse(jsonString) } catch { isValidJSON = false }

그게 다야!

그러나 2 개의 트랩이 있음을 명심
하십시오 . 1. JSON.parse(null)리턴 null
2. 임의의 숫자 또는 문자열을 JSON.parse()메소드 로 구문 분석 할 수 있습니다 .
   JSON.parse("5")반품 5
   JSON.parse(5)반품5

코드를 약간 살펴 보자.

// TEST 1
var data = '{ "a": 1 }'

// Avoiding 'null' trap! Null is confirmed as JSON.
var isValidJSON = data ? true : false
try { JSON.parse(data) } catch(e) { isValidJSON = false }

console.log("data isValidJSON: ", isValidJSON);
console.log("data isJSONArray: ", isValidJSON && JSON.parse(data).length ? true : false);

Console outputs:
data isValidJSON:  true
data isJSONArray:  false


// TEST 2
var data2 = '[{ "b": 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data2) } catch(e) { isValidJSON = false }

console.log("data2 isValidJSON: ", isValidJSON);
console.log("data2 isJSONArray: ", isValidJSON && JSON.parse(data2).length ? true : false);

Console outputs:
data2 isValidJSON:  true
data2 isJSONArray:  true


// TEST 3
var data3 = '[{ 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data3) } catch(e) { isValidJSON = false }

console.log("data3 isValidJSON: ", isValidJSON);
console.log("data3 isJSONArray: ", isValidJSON && JSON.parse(data3).length ? true : false);

Console outputs:
data3 isValidJSON:  false
data3 isJSONArray:  false


// TEST 4
var data4 = '2'

var isValidJSON = data ? true : false
try { JSON.parse(data4) } catch(e) { isValidJSON = false }

console.log("data4 isValidJSON: ", isValidJSON);
console.log("data4 isJSONArray: ", isValidJSON && JSON.parse(data4).length ? true : false);


Console outputs:
data4 isValidJSON:  true
data4 isJSONArray:  false


// TEST 5
var data5 = ''

var isValidJSON = data ? true : false
try { JSON.parse(data5) } catch(e) { isValidJSON = false }

console.log("data5 isValidJSON: ", isValidJSON);
console.log("data5 isJSONArray: ", isValidJSON && JSON.parse(data5).length ? true : false);


Console outputs:
data5 isValidJSON:  false
data5 isJSONArray:  false

// TEST 6
var data6; // undefined

var isValidJSON = data ? true : false
try { JSON.parse(data6) } catch(e) { isValidJSON = false }

console.log("data6 isValidJSON: ", isValidJSON);
console.log("data6 isJSONArray: ", isValidJSON && JSON.parse(data6).length ? true : false);

Console outputs:
data6 isValidJSON:  false
data6 isJSONArray:  false

그것을 해독하고 예외를 잡을 수 있습니다 (native 또는 json2.js ).

try {
  newObj = JSON.parse(myJsonString);
} catch (e) {
  console.log('Not JSON');
}

그러나 응답을 항상 유효한 JSON으로 만드는 것이 좋습니다. MySQL 쿼리에서 오류가 발생하면 다음 오류와 함께 JSON을 다시 보내십시오.

{"error":"The MySQL error string."}

그리고:

if (myParsedJSON.error) {
  console.log('An error occurred: ' + myParsedJSON.error);
}

경고 : 에 의존하는 방법에 대해서는 JSON.parse- 둘러싸인 문자열을 배열하고 인용하는 것은 너무 통과 할 것이다. (예 console.log(JSON.parse('[3]'), JSON.parse('"\uD800"')))

객체가 아닌 JSON 프리미티브 (부울, 널, 배열, 숫자, 문자열)를 피하려면 다음을 사용하는 것이 좋습니다.

/* Validate a possible object ie. o = { "a": 2 } */
const isJSONObject = (o) => 
  !!o && (typeof o === 'object') && !Array.isArray(o) && 
  (() => { try { return Boolean(JSON.stringify(o)); } catch { return false } })()

/* Validate a possible JSON object represented as string ie. s = '{ "a": 3 }' */
function isJSONObjectString(s) {
    try {
        const o = JSON.parse(s);
        return !!o && (typeof o === 'object') && !Array.isArray(o)
    } catch {
        return false
    }
}

코드 설명

• !! o- 허위 아님 (null 제외, typeof 'object'로 등록)
• (typeof o === 'object') -부울, 숫자 및 문자열 제외
• ! Array.isArray (o)-배열 제외 (typeof 'object'로 등록)
• try ... JSON.stringify / JSON.parse- 유효한 JSON인지 확인하도록 JavaScript 엔진에 요청합니다.

hasJsonStructure () 답변을 사용하지 않는 이유는 무엇입니까?

의지하는 toString()것은 좋은 생각이 아닙니다. 다른 JavaScript 엔진이 다른 문자열 표현을 반환 할 수 있기 때문입니다. 일반적으로, 이에 의존하는 메소드는 다른 환경에서 실패하거나 엔진이 문자열 결과를 변경하면 나중에 실패 할 수 있습니다.

왜 예외를 잡는 것이 해킹이 아닌가?

무언가의 타당성을 결정하기 위해 예외를 잡는 것이 올바른 길은 아니라는 것이 밝혀졌습니다. 이것은 일반적으로 좋은 조언이지만 항상 그런 것은 아닙니다. 이 경우 예외 포착은 JavaScript 엔진의 JSON 데이터 유효성 검사 구현에 의존하기 때문에 최상의 경로 일 수 있습니다.

JS 엔진에 의존하면 다음과 같은 장점이 있습니다.

1. JSON 사양이 변경됨에 따라보다 철저하고 지속적으로 최신 정보 제공
2. 더 낮은 수준의 코드이므로 더 빠르게 실행될 가능성

JavaScript 엔진에 의지 할 수있는 기회가 주어지면 제안하는 것이 좋습니다. 이 경우 특히 그렇습니다. 이 수 있지만 기분이 예외를 잡기 위해 해키, 당신은 정말 그냥 외부 방법에서 두 가지 반환 상태를 처리하고 있습니다.

다음은 Bourne의 답변에서 약간의 수정이있는 코드입니다. JSON.parse (number)는 예외없이 정상적으로 작동하므로 isNaN이 추가되었습니다.

function isJson(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return isNaN(str);
}

모든 json 문자열은 '{'또는 '['로 시작하고 해당 '}'또는 ']'로 끝나므로 확인하십시오.

Angular.js가 수행하는 방법은 다음과 같습니다.

var JSON_START = /^\[|^\{(?!\{)/;
var JSON_ENDS = {
  '[': /]$/,
  '{': /}$/
};

function isJsonLike(str) {
    var jsonStart = str.match(JSON_START);
    return jsonStart && JSON_ENDS[jsonStart[0]].test(str);
}

https://github.com/angular/angular.js/blob/v1.6.x/src/ng/http.js

Typescript 모드 에서 제안 합니다.

export function stringify(data: any): string {
    try {
         return JSON.stringify(data)
    } catch (e) {
         return 'NOT_STRINGIFIABLE!'
    }
}

나는 이것을 사용했다 (다른 답변의 혼합, 그러나 어쨌든) :

const isJSON = str => {
  if (typeof str === 'string'){
    try {
      JSON.parse(str)
      return true
    } catch(e){
    }
  }
  return false
}



[null, undefined, false, true, [], {}, 
 '', 'asdf', '{}', '[]', "{\"abc\": 2}","{\"abc\": \"2\"}"]
  .map(el => {
      console.log(`[>${el}<] - ${isJSON(el)}`)
})

console.log('-----------------')

숫자, null, 문자열의 유효성을 검사하기 때문에 다음 중 하나를 시도 할 수 있지만 위에 표시된 답변이 올바르게 작동하지 않으므로 위 함수의 수정 일뿐입니다.

function isJson(str) {
  try {
      const obj = JSON.parse(str);
      if (obj && typeof obj === `object`) {
        return true;
      }
    } catch (err) {
      return false;
    }
   return false;
}

이전 답변 외에도 "{}"와 같은 JSON 형식의 유효성을 검사해야하는 경우 다음 코드를 사용할 수 있습니다.

const validateJSON = (str) => {
  try {
    const json = JSON.parse(str);
    if (Object.prototype.toString.call(json).slice(8,-1) !== 'Object') {
      return false;
    }
  } catch (e) {
    return false;
  }
  return true;
}

사용 예 :

validateJSON('{}')
true
validateJSON('[]')
false
validateJSON('')
false
validateJSON('2134')
false
validateJSON('{ "Id": 1, "Name": "Coke" }')
true