JSON의 유효성을 검사하는 정규식

90

json의 유효성을 검사 할 수있는 Regex를 찾고 있습니다.

저는 Regex를 처음 접했고 Regex를 사용한 구문 분석이 나쁘다는 것을 충분히 알고 있지만 유효성 검사에 사용할 수 있습니까?

regex  json 
— 사금파리
소스
31
별도의 검증 단계를 수행해야하는 이유는 무엇입니까? 대부분의 언어에는 JSON을 구문 분석 할 수있는 JSON 라이브러리가 있으며 구문 분석 할 수 있으면 유효했습니다. 그렇지 않은 경우 도서관에서 알려줄 것입니다.
— Epcylon 2010 년
당신은 ... 그것을 확인하기 위해 구문 분석 텍스트 필요
— 켄
3
@mario-모르겠어요 ... 저는 모두 정규식을 남용하고 있으며 "정규식은 정규식과 일치해야합니다"오류에 대한 귀하의 반대에 대해 극도로 동정합니다.하지만 실제적인 업무 관련 질문은 아닙니다. 여기에 가장 좋은 대답은 정말 Epcylon의 코멘트 (? 어쩌면이 토론은 채팅에 속함)입니다
— 코비
1
또 다른 실용적인 사용 사례는 더 큰 문자열 내에서 JSON 표현식을 찾는 것 입니다. "여기에이 문자열이 JSON 객체입니까?"라고 묻고 싶다면, 예, JSON 구문 분석 라이브러리가 더 나은 도구 일 것입니다. 그러나 더 큰 구조 내에서 JSON 객체를 찾을 수 없습니다.
— Mark Amery
1
이것은 대답이 아니지만 Crockford의 JSON-js 라이브러리의이 부분을 사용할 수 있습니다 . 4 개의 정규식을 사용하고 영리한 방식으로 결합합니다.
— imgx64

답변:

184

예, 완전한 정규식 유효성 검사가 가능합니다.

대부분의 최신 정규식 구현은 완전한 JSON 직렬화 구조를 확인할 수있는 재귀 정규식을 허용합니다. json.org 사양 은 매우 간단합니다.

$pcre_regex = '
  /
  (?(DEFINE)
     (?<number>   -? (?= [1-9]|0(?!\d) ) \d+ (\.\d+)? ([eE] [+-]? \d+)? )    
     (?<boolean>   true | false | null )
     (?<string>    " ([^"\\\\]* | \\\\ ["\\\\bfnrt\/] | \\\\ u [0-9a-f]{4} )* " )
     (?<array>     \[  (?:  (?&json)  (?: , (?&json)  )*  )?  \s* \] )
     (?<pair>      \s* (?&string) \s* : (?&json)  )
     (?<object>    \{  (?:  (?&pair)  (?: , (?&pair)  )*  )?  \s* \} )
     (?<json>   \s* (?: (?&number) | (?&boolean) | (?&string) | (?&array) | (?&object) ) \s* )
  )
  \A (?&json) \Z
  /six   
';

그것은 PCRE 기능을 가진 PHP에서 아주 잘 작동 합니다 . Perl에서 수정하지 않고 작동해야합니다. 다른 언어에도 적용 할 수 있습니다. 또한 JSON 테스트 케이스 에서도 성공합니다 .

더 간단한 RFC4627 검증

더 간단한 접근 방식은 RFC4627, 섹션 6에 지정된 최소 일관성 검사 입니다. 그러나 이는 보안 테스트 및 기본 비유 효성 예방 조치 일뿐입니다.

  var my_JSON_object = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
         text.replace(/"(\\.|[^"\\])*"/g, ''))) &&
     eval('(' + text + ')');
— 마리오
소스
22
+1 정규식 구문을 얻지 못하고 오용하는 사람들로부터 세상에는 너무나 나쁜 것이 있습니다. 그것을 싫어하는 이유로 :(
— NikiC
8
@mario, 당신이 내가 반대자 부서 에 있다고 생각하는지 확실하지 않지만 나는 아닙니다. "대부분의 최신 정규식 구현은 재귀 정규식을 허용 합니다 "라는 진술 은 논쟁의 여지가 많습니다 . AFAIK, Perl, PHP 및 .NET 만 재귀 패턴을 정의 할 수 있습니다. 나는 그것을 "대부분"이라고 부르지 않을 것이다.
— Bart Kiers
3
@Bart : 예, 그것은 정당하게 논쟁의 여지가 있습니다. 가장 아이러니하게도 Javascript 정규식 엔진은 이러한 재귀 정규식을 사용하여 JSON을 확인할 수 없습니다 (또는 정교한 해결 방법으로 만). 따라서 regex == posix regex이면 옵션이 아닙니다. 그럼에도 불구하고 현대적인 구현으로 가능하다는 것은 흥미 롭습니다. 실제 사용 사례가 거의 없어도. (그러나 사실, libpcre는 모든 곳에서 널리 사용되는 엔진이 아닙니다.)-또한 기록을 위해 : 합성 리버설 배지를 원했지만, 몇 가지 악 대차 업 보트를 얻지 못한 것은이를 방해합니다. : /
— mario
4
아니. 나는 20 표가 필요하지만 여전히 당신의 대답에 10 표가 필요한 포퓰리스트 배지를 따랐습니다. 따라서 반대로 귀하의 질문에 대한 반대표는 저에게 이익이되지 않습니다.
— mario
2
더 나아가이 정규 표현식에는 다른 많은 문제가 있습니다. JSON 데이터와 일치하지만 일부 비 JSON 데이터도 일치합니다. 예를 들어, 단일 리터럴은 false일치하는 반면 최상위 JSON 값은 배열 또는 객체 여야합니다. 또한 문자열이나 공백에서 허용되는 문자 집합에 많은 문제가 있습니다.
— 고인돌
32

예, 정규 표현식이 정규 언어 와 만 일치 할 수 있다는 것은 일반적인 오해입니다 . 실제로 PCRE 함수는 일반 언어보다 훨씬 더 많이 일치 할 수 있으며 컨텍스트가없는 일부 언어 와도 일치 할 수 있습니다! RegExps 에 대한 Wikipedia의 기사 에는 그것에 대한 특별한 섹션이 있습니다.

JSON은 PCRE를 사용하여 여러 가지 방법으로 인식 할 수 있습니다! @mario는 명명 된 하위 패턴과 역 참조를 사용하는 하나의 훌륭한 솔루션을 보여주었습니다 . 그런 다음 그는 재귀 패턴을 사용하는 솔루션이 있어야한다고 지적했습니다 (?R). 다음은 PHP로 작성된 정규 표현식의 예입니다.

$regexString = '"([^"\\\\]*|\\\\["\\\\bfnrt\/]|\\\\u[0-9a-f]{4})*"';
$regexNumber = '-?(?=[1-9]|0(?!\d))\d+(\.\d+)?([eE][+-]?\d+)?';
$regexBoolean= 'true|false|null'; // these are actually copied from Mario's answer
$regex = '/\A('.$regexString.'|'.$regexNumber.'|'.$regexBoolean.'|';    //string, number, boolean
$regex.= '\[(?:(?1)(?:,(?1))*)?\s*\]|'; //arrays
$regex.= '\{(?:\s*'.$regexString.'\s*:(?1)(?:,\s*'.$regexString.'\s*:(?1))*)?\s*\}';    //objects
$regex.= ')\Z/is';

내가 사용하고 (?1)대신 (?R)하여 후자의 참조 때문에 전체 패턴,하지만 우리는이 \A와 \Z서브 패턴 내에서 사용할 수 없습니다 시퀀스. (?1)가장 바깥 쪽 괄호로 표시된 정규 표현식에 대한 참조 (이것이 가장 바깥 쪽 ( )이로 시작하지 않는 이유 입니다 ?:). 따라서 RegExp는 268 자 길이가됩니다. :)

/\A("([^"\\]*|\\["\\bfnrt\/]|\\u[0-9a-f]{4})*"|-?(?=[1-9]|0(?!\d))\d+(\.\d+)?([eE][+-]?\d+)?|true|false|null|\[(?:(?1)(?:,(?1))*)?\s*\]|\{(?:\s*"([^"\\]*|\\["\\bfnrt\/]|\\u[0-9a-f]{4})*"\s*:(?1)(?:,\s*"([^"\\]*|\\["\\bfnrt\/]|\\u[0-9a-f]{4})*"\s*:(?1))*)?\s*\})\Z/is

어쨌든 이것은 실질적인 해결책이 아니라 "기술 데모"로 취급되어야합니다. PHP에서 json_decode()함수 를 호출하여 JSON 문자열의 유효성을 검사합니다 (@Epcylon이 언급 한 것처럼). 해당 JSON 을 사용 하려는 경우 (검증 된 경우) 이것이 가장 좋은 방법입니다.

— Hrant Khachatrian
소스
1
사용 \d은 위험합니다. 많은 정규 표현식 구현 \d에서 숫자의 유니 코드 정의와 일치 할 [0-9]뿐만 아니라 대체 스크립트를 포함합니다.
— 고인돌
@dolmen : 당신 말이 맞을지 모르지만 질문에 직접 편집해서는 안됩니다. 주석으로 추가하는 것만으로도 충분합니다.
— Dennis Haarbrink 2013 년
\dPHP의 PCRE 구현에서 유니 코드 번호와 일치하지 않는다고 생각 합니다. 예를 들어 ٩심볼 (0x669 아랍어 인도어 구 자리) 패턴을 이용하여 정합 될 #\p{Nd}#u수 있지만#\d#u
— Hrant Khachatrian
@ hrant-khachatrian : /u플래그를 사용하지 않았기 때문이 아닙니다 . JSON은 UTF-8로 인코딩됩니다. 적절한 정규 표현식의 경우 해당 플래그를 사용해야합니다.
— dolmen
1
@dolmen u수정자를 사용 했습니다. 이전 댓글의 패턴을 다시 살펴보십시오. :) 문자열, 숫자 및 부울은 최상위 수준에서 올바르게 일치합니다. 여기 긴 정규 표현식 붙여 넣을 수 있습니다 quanetic.com/Regex을 자신을 시도
— Hrant Khachatrian
14

JSON (중첩 된 {...}-s) 의 재귀 적 특성으로 인해 정규식은 유효성을 검사하는 데 적합하지 않습니다. 물론 일부 정규식 버전은 재귀 적으로 패턴 과 일치 할 수 있지만 * (그리고이를 위해 JSON과 일치시킬 수 있음) 결과 패턴은보기에 끔찍하며 프로덕션 코드 IMO에서 절대 사용해서는 안됩니다!

* 그러나 많은 정규식 구현은 재귀 패턴을 지원 하지 않습니다 . 널리 사용되는 프로그래밍 언어 중 Perl, .NET, PHP 및 Ruby 1.9.2와 같은 재귀 패턴을 지원합니다.

— 바트 키 어스
소스
3
— Darien
16
@all down voters : "정규식이 그것을 검증하는 데 적합 하지 않다 " 는 것은 특정 정규식 엔진이 그것을 할 수 없다는 것을 의미하지 않습니다 (적어도 그것이 제가 의미 한 바입니다). 물론 일부 정규식 구현 은 할 수 있지만 올바른 생각을 가진 사람은 단순히 JSON 파서를 사용합니다. 누군가 망치만으로 완전한 집을 짓는 방법을 묻는 것처럼 망치는 작업에 적합하지 않다고 대답하고 완전한 툴킷과 기계가 필요합니다. 물론 인내심이 충분한 사람은 망치만으로도 할 수 있습니다.
— Bart Kiers 2011-06-06
1
이는 유효한 경고 일 수 있지만 질문에 대한 답변은 아닙니다 . 정규식이 올바른 도구가 아닐 수 있지만 어떤 사람들은 선택의 여지가 없습니다. 우리는 상태를 확인하기 위해 서비스의 출력을 평가하는 공급 업체 제품에 갇혀 있으며 공급 업체가 사용자 지정 상태 확인을 위해 제공하는 유일한 옵션은 정규식을 허용하는 웹 양식입니다. 서비스 상태를 평가하는 공급 업체 제품은 우리 팀이 관리하지 않습니다. 우리에게 정규식을 사용하여 JSON을 평가하는 것은 이제 요구 사항이므로 "부적합"이라는 대답은 실행 가능하지 않습니다. (나는 여전히 당신을 downvote하지 않았다.)
— 존 터스에게
12

@mario의 대답을 시도했지만 JSON.org ( archive ) 에서 테스트 스위트를 다운로드 했고 4 개의 실패한 테스트 (fail1.json, fail18.json, fail25.json, fail27) 가 있었기 때문에 작동하지 않았습니다 . json).

나는 오류를 조사하고, 발견 한 fail1.json(수동의에 따라 실제로 올 노트 와 RFC-7159 유효한 문자열도 유효한 JSON)입니다. 파일도 사실 fail18.json이 아니 었습니다. 실제로 깊이 중첩 된 JSON이 실제로 포함되어 있기 때문입니다.

[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]

그래서 두 개의 파일 왼쪽 : fail25.json및 fail27.json:

["  tab character   in  string  "]

과

["line
break"]

둘 다 잘못된 문자가 포함되어 있습니다. 그래서 다음과 같은 패턴을 업데이트했습니다 (문자열 하위 패턴 업데이트 됨).

$pcreRegex = '/
          (?(DEFINE)
             (?<number>   -? (?= [1-9]|0(?!\d) ) \d+ (\.\d+)? ([eE] [+-]? \d+)? )
             (?<boolean>   true | false | null )
             (?<string>    " ([^"\n\r\t\\\\]* | \\\\ ["\\\\bfnrt\/] | \\\\ u [0-9a-f]{4} )* " )
             (?<array>     \[  (?:  (?&json)  (?: , (?&json)  )*  )?  \s* \] )
             (?<pair>      \s* (?&string) \s* : (?&json)  )
             (?<object>    \{  (?:  (?&pair)  (?: , (?&pair)  )*  )?  \s* \} )
             (?<json>   \s* (?: (?&number) | (?&boolean) | (?&string) | (?&array) | (?&object) ) \s* )
          )
          \A (?&json) \Z
          /six';

이제 json.org의 모든 법적 테스트를 통과 할 수 있습니다.

— 지노 창
소스
이것은 JSON 객체 / 배열이 아닌 JSON 값 (문자열, 부울, 숫자) 과도 일치합니다.
— kowsikbabu
4

JSON 에 대한 문서를 살펴보면 목표가 적합성을 확인하는 것이라면 정규식이 단순히 세 부분이 될 수 있습니다.

  1. 문자열은 또는로 시작 하고 끝납니다.[]{}
    • [{\[]{1}...[}\]]{1}
  2. 과
    1. 이 문자는 허용되는 JSON 제어 문자입니다 (하나만).
      • ... [,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]...
    2. 또는 a에 포함 된 문자 집합""
      • ... ".*?"...

모두 함께: [{\[]{1}([,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]|".*?")+[}\]]{1}

json으로 문자열이 포함되어 있으면 newline문자를, 당신은 사용해야 singleline있도록 정규식 맛에 스위치를 .일치 newline. 모든 잘못된 JSON에서 실패하지는 않지만 기본 JSON 구조가 유효하지 않으면 실패합니다. 이는 파서에 전달하기 전에 기본 온 전성 유효성 검사를 수행하는 간단한 방법입니다.

— cjbarth
소스
1
제안 된 정규식에는 특정 테스트 케이스에서 끔찍한 역 추적 동작이 있습니다. '{ "a": false, "b": true, "c": 100, "'이 불완전한 json에서 실행하려고하면 중지됩니다. 예 : regex101.com/r/Zzc6sz . 간단한 수정은 다음과 같습니다 . : [{[] {1} ([, : {} [] 0-9. \-+ Eaeflnr-u \ n \ r \ t] | ". *?") + [}]] {1}
— Toonijn
@Toonijn 귀하의 의견을 반영하기 위해 업데이트했습니다. 감사!
— cjbarth
3

작동하는 Mario 솔루션의 Ruby 구현을 만들었습니다.

# encoding: utf-8

module Constants
  JSON_VALIDATOR_RE = /(
         # define subtypes and build up the json syntax, BNF-grammar-style
         # The {0} is a hack to simply define them as named groups here but not match on them yet
         # I added some atomic grouping to prevent catastrophic backtracking on invalid inputs
         (?<number>  -?(?=[1-9]|0(?!\d))\d+(\.\d+)?([eE][+-]?\d+)?){0}
         (?<boolean> true | false | null ){0}
         (?<string>  " (?>[^"\\\\]* | \\\\ ["\\\\bfnrt\/] | \\\\ u [0-9a-f]{4} )* " ){0}
         (?<array>   \[ (?> \g<json> (?: , \g<json> )* )? \s* \] ){0}
         (?<pair>    \s* \g<string> \s* : \g<json> ){0}
         (?<object>  \{ (?> \g<pair> (?: , \g<pair> )* )? \s* \} ){0}
         (?<json>    \s* (?> \g<number> | \g<boolean> | \g<string> | \g<array> | \g<object> ) \s* ){0}
       )
    \A \g<json> \Z
    /uix
end

########## inline test running
if __FILE__==$PROGRAM_NAME

  # support
  class String
    def unindent
      gsub(/^#{scan(/^(?!\n)\s*/).min_by{|l|l.length}}/u, "")
    end
  end

  require 'test/unit' unless defined? Test::Unit
  class JsonValidationTest < Test::Unit::TestCase
    include Constants

    def setup

    end

    def test_json_validator_simple_string
      assert_not_nil %s[ {"somedata": 5 }].match(JSON_VALIDATOR_RE)
    end

    def test_json_validator_deep_string
      long_json = <<-JSON.unindent
      {
          "glossary": {
              "title": "example glossary",
          "GlossDiv": {
                  "id": 1918723,
                  "boolean": true,
                  "title": "S",
            "GlossList": {
                      "GlossEntry": {
                          "ID": "SGML",
                "SortAs": "SGML",
                "GlossTerm": "Standard Generalized Markup Language",
                "Acronym": "SGML",
                "Abbrev": "ISO 8879:1986",
                "GlossDef": {
                              "para": "A meta-markup language, used to create markup languages such as DocBook.",
                  "GlossSeeAlso": ["GML", "XML"]
                          },
                "GlossSee": "markup"
                      }
                  }
              }
          }
      }
      JSON

      assert_not_nil long_json.match(JSON_VALIDATOR_RE)
    end

  end
end
— pmarreck
소스
\ d 사용은 위험합니다. 많은 정규 표현식 구현에서 \ d는 [0-9]뿐만 아니라 대체 스크립트를 포함하는 숫자의 유니 코드 정의와 일치합니다. 따라서 Ruby의 유니 코드 지원이 여전히 중단되지 않는 한 코드에서 정규 표현식을 수정해야합니다.
— 고인돌
내가 아는 한 Ruby는 \ d가 "digit"의 모든 유니 코드 정의와 일치하지 않는 PCRE를 사용합니다. 아니면 그렇게해야한다고 말하는 건가요?
— pmarreck
그렇지 않다는 것을 제외하고. 거짓 양성 : "\ x00", [True]. 거짓 음성 : "\ u0000", "\ n". 중단 : "[{" ": [{" ": [{" ":"(1000x 반복)).
— nst
테스트 케이스로 추가하고 통과하기 위해 코드를 조정하는 것이 너무 어렵지 않습니다. 그것은 1000의 깊이와 스택을 날려하지 않는받는 방법은 ...하지만, 완전히 다른 문제입니다
— pmarreck
1

"문자열과 숫자"의 경우 숫자에 대한 부분 정규식이 다음과 같다고 생각합니다.

-?(?:0|[1-9]\d*)(?:\.\d+)(?:[eE][+-]\d+)?

대신 다음과 같아야합니다.

-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+\-]?\d+)?

숫자의 소수 부분은 선택 사항이며 대괄호 사이에 특별한 의미가 있으므로 -기호 를 이스케이프하는 것이 더 안전 할 수 [+-]있습니다.

— 미카에 루
소스
사용 \d은 위험합니다. 많은 정규 표현식 구현 \d에서 숫자의 유니 코드 정의와 일치 할 [0-9]뿐만 아니라 대체 스크립트를 포함합니다.
— 고인돌
-0이 유효한 숫자이지만 RFC 4627에서 허용하고 정규식이이를 준수한다는 점이 약간 이상해 보입니다.
— 년
1

JSON 배열의 후행 쉼표로 인해 Perl 5.16이 중단되었습니다. 역 추적 종료 지시문을 추가해야했습니다.

(?<json>   \s* (?: (?&number) | (?&boolean) | (?&string) | (?&array) | (?&object) )(*PRUNE) \s* )
                                                                                   ^^^^^^^^

이렇게하면 '선택적'( *또는 ?) 이 아닌 구조가 식별되면 다른 것으로 식별하기 위해 역 추적을 시도해서는 안됩니다.

— user117529
소스
0

위에서 설명한대로 사용하는 언어에 JSON 라이브러리가 함께 제공되는 경우이를 사용하여 문자열 디코딩을 시도하고 실패하면 예외 / 오류를 포착하십시오! 언어가 그렇지 않은 경우 (FreeMarker와 같은 경우) 다음 정규식은 최소한 매우 기본적인 유효성 검사를 제공 할 수 있습니다 (PHP / PCRE가 더 많은 사용자를 위해 테스트 / 사용할 수 있도록 작성되었습니다). 허용되는 솔루션만큼 완벽하지는 않지만 무서운 것은 아닙니다. =) :

~^\{\s*\".*\}$|^\[\n?\{\s*\".*\}\n?\]$~s

간단한 설명 :

// we have two possibilities in case the string is JSON
// 1. the string passed is "just" a JSON object, e.g. {"item": [], "anotheritem": "content"}
// this can be matched by the following regex which makes sure there is at least a {" at the
// beginning of the string and a } at the end of the string, whatever is inbetween is not checked!

^\{\s*\".*\}$

// OR (character "|" in the regex pattern)
// 2. the string passed is a JSON array, e.g. [{"item": "value"}, {"item": "value"}]
// which would be matched by the second part of the pattern above

^\[\n?\{\s*\".*\}\n?\]$

// the s modifier is used to make "." also match newline characters (can happen in prettyfied JSON)

무심코 이것을 깨뜨릴 수있는 것을 놓친 경우 댓글 감사합니다!

— exside
소스
0

JSONArray가 아닌 간단한 JSON의 유효성을 검사하는 정규식

key (string) : value (string, integer, [{key : value}, {key : value}], {key : value})의 유효성을 검사합니다.

^\{(\s|\n\s)*(("\w*"):(\s)*("\w*"|\d*|(\{(\s|\n\s)*(("\w*"):(\s)*("\w*(,\w+)*"|\d{1,}|\[(\s|\n\s)*(\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})){1}(\s|\n\s)*(,(\s|\n\s)*\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})?)*(\s|\n\s)*\]))((,(\s|\n\s)*"\w*"):(\s)*("\w*(,\w+)*"|\d{1,}|\[(\s|\n\s)*(\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})){1}(\s|\n\s)*(,(\s|\n\s)*\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):("\w*"|\d{1,}))*(\s|\n)*\})?)*(\s|\n\s)*\]))*(\s|\n\s)*\}){1}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d*|(\{(\s|\n\s)*(("\w*"):(\s)*("\w*(,\w+)*"|\d{1,}|\[(\s|\n\s)*(\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})){1}(\s|\n\s)*(,(\s|\n\s)*\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})?)*(\s|\n\s)*\]))((,(\s|\n\s)*"\w*"):(\s)*("\w*(,\w+)*"|\d{1,}|\[(\s|\n\s)*(\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})){1}(\s|\n\s)*(,(\s|\n\s)*\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):("\w*"|\d{1,}))*(\s|\n)*\})?)*(\s|\n\s)*\]))*(\s|\n\s)*\}){1}))*(\s|\n)*\}$

이 JSON으로 유효성을 검사하는 샘플 데이터

{
"key":"string",
"key": 56,
"key":{
        "attr":"integer",
        "attr": 12
        },
"key":{
        "key":[
            {
                "attr": 4,
                "attr": "string"
            }
        ]
     }
}
— 라비 난다 사나
소스
-3

나는 이것이 6 년 전의 것임을 알고 있습니다. 그러나 여기에 아무도 언급하지 않은 정규식보다 쉬운 해결책이 있다고 생각합니다.

function isAJSON(string) {
    try {
        JSON.parse(string)  
    } catch(e) {
        if(e instanceof SyntaxError) return false;
    };  
    return true;
}
— 제이미
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.