1.1. 용어

이 문서에서 핵심어 "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", 및 "OPTIONAL"은 여기에 표시된 것처럼 모두 대문자로 나타날 때, 그리고 그때에만 BCP 14 [RFC2119] [RFC8174]에 설명된 대로 해석되어야 한다.¶

이 문서의 문법 규칙은 [RFC5234]에 설명된 대로 ABNF로 해석되어야 한다. 이 문서의 ABNF 터미널 값은 UTF-8 인코딩이 아니라 유니코드 스칼라 값을 정의한다. 예를 들어, 유니코드 PLACE OF INTEREST SIGN (U+2318)은 ABNF에서 %x2318로 정의될 것이다.¶

함수는 fname()에서처럼 함수 이름 뒤에 한 쌍의 괄호를 붙여 지칭한다.¶

아래에서 명확히 하는 경우를 제외하고 [RFC8259]의 용어가 적용된다. "primitive"와 "structured"라는 용어는 [RFC8259]의 섹션 1에서와 같이 서로 다른 종류의 값을 묶는 데 사용된다. JSON 객체와 배열은 structured이고, 그 밖의 모든 값은 primitive이다. "object", "array", "number", "string"에 대한 정의는 변경되지 않는다. 특히 "object"와 "array"는 일반적인 프로그래밍 맥락에서처럼 일반적인 의미를 갖지 않는다.¶

[RFC9485]의 용어가 적용된다.¶

이 문서에서 사용되는 추가 용어는 아래에 정의되어 있다.¶

값:

[RFC8259]에 따르면, JSON의 일반 데이터 모델에 부합하는 데이터 항목, 즉 primitive 데이터(숫자, 텍스트 문자열, 그리고 특수 값 null, true, false) 또는 structured 데이터(JSON 객체와 배열)이다. [RFC8259]는 JSON 값의 텍스트 표현에 초점을 맞추며 여기서 가정하는 값 추상화를 완전히 정의하지는 않는다.¶

멤버:

객체 안의 이름/값 쌍이다. (멤버 자체는 값이 아니다.)¶

이름:

멤버를 구성하는 이름/값 쌍에서의 이름(문자열)이다. 이는 [RFC8259]에서도 사용되지만, 해당 명세는 이를 형식적으로 정의하지 않는다. 완전성을 위해 여기에 포함하였다.¶

요소:

JSON 배열 안의 값이다.¶

인덱스:

배열 안의 특정 요소를 식별하는 정수이다.¶

쿼리:

JSONPath 표현식의 짧은 이름이다.¶

쿼리 인자:

JSONPath 표현식이 적용되는 값의 짧은 이름이다.¶

위치:

쿼리 인자 내에서 값의 위치이다. 이는 쿼리 인자 안의 객체와 배열을 통해 값으로 이동하는 이름과 인덱스의 시퀀스로 생각할 수 있으며, 빈 시퀀스는 쿼리 인자 자체를 나타낸다. 위치는 Normalized Path(아래에 정의됨)로 표현될 수 있다.¶

노드:

값과 쿼리 인자 내에서의 해당 위치가 함께 이루는 쌍이다.¶

루트 노드:

그 값이 전체 쿼리 인자인 유일한 노드이다.¶

루트 노드 식별자:

쿼리 인자의 루트 노드를 참조하는 표현식 $이다.¶

현재 노드 식별자:

필터 표현식 평가의 맥락에서 현재 노드를 참조하는 표현식 @이다(나중에 설명됨).¶

자식(노드의):

노드가 배열이면 그 요소들의 노드이고, 노드가 객체이면 그 멤버 값들의 노드이다. 노드가 배열도 객체도 아니면 자식을 갖지 않는다.¶

하위 노드(노드의):

노드의 자식과 그 자식들의 자식, 그리고 그 이후를 재귀적으로 포함한다. 더 형식적으로는, 노드들 사이의 "하위 노드" 관계는 "자식" 관계의 추이적 폐쇄이다.¶

깊이(값 내의 하위 노드의):

값 내에서 해당 노드의 조상 수이다. 값의 루트 노드는 깊이가 0이고, 루트 노드의 자식은 깊이가 1이며, 그 자식들은 깊이가 2이고, 이런 식으로 계속된다.¶

노드 리스트:

노드들의 리스트이다. 노드 리스트는 예를 들어 배열처럼 JSON으로 표현될 수 있지만, 이 문서는 특정 표현을 요구하거나 가정하지 않는다.¶

파라미터:

함수 표현식에서 함수 인자 (실제 파라미터)를 받을 수 있는 (함수의) 형식 파라미터이다.¶

정규화된 경로:

값 안의 노드를 식별하는 JSONPath 표현식의 한 형태로, 정확히 그 노드만을 결과로 산출하는 쿼리를 제공한다. 쿼리 인자 안의 각 노드는 정확히 하나의 Normalized Path로 식별된다 (우리는 그 Normalized Path가 해당 노드에 대해 "고유"하다고 말한다). 특정 쿼리 인자에 대한 Normalized Path가 되려면, Normalized Path는 정확히 하나의 노드를 식별해야 한다. 이는 JSON Pointer [RFC6901]와 유사하지만, 구문적으로는 다르다. 참고: 이 정의는 섹션 2.7의 구문적 정의를 기반으로 한다. 값 안의 노드를 식별하지만 해당 구문에 부합하지 않는 JSONPath 표현식은 Normalized Path가 아니다.¶

유니코드 스칼라 값:

high-surrogate 및 low-surrogate 코드 포인트를 제외한 모든 유니코드 [UNICODE] 코드 포인트(다시 말해, 포함적인 16진수 범위 0부터 D7FF 또는 E000부터 10FFFF까지의 정수)이다. JSONPath 쿼리는 유니코드 스칼라 값의 시퀀스이다.¶

세그먼트:

입력 값의 자식 ([<selectors>]) 또는 하위 노드(..⁠[<selectors>])를 선택하는 구성요소 중 하나이다.¶

선택자:

세그먼트 내의 단일 항목으로, 입력 값을 받아 입력 값의 자식 노드로 이루어진 노드 리스트를 생성한다.¶

단일 쿼리:

특정 방식으로 구문적으로 제한된 세그먼트(섹션 2.3.5.1)로 구성된 JSONPath 표현식으로, 입력 값과 관계없이 표현식이 최대 하나의 노드만 포함하는 노드 리스트를 산출한다. 참고: 항상 단일 노드 리스트를 산출하지만 섹션 2.3.5.1의 구문에 부합하지 않는 JSONPath 표현식은 단일 쿼리가 아니다.¶

1.2. 역사

이 문서는 Stefan Gössner의 인기 있는 JSONPath 제안(2007-02-21일자) [JSONPath-orig]을 기반으로 하며, 그 구현이 널리 배포되면서 얻은 경험을 바탕으로 이에 대한 규범적 명세를 제공한다.¶

부록 B는 JSONPath가 XML의 XPath [XPath]에서 어떻게 영감을 받았는지 설명한다.¶

JSONPath는 PHP 및 JavaScript와 같은 프로그래밍 언어의 JSON 구현을 위한 가벼운 동반자로 의도되었으므로, XPath가 그랬던 것처럼 자체 표현식 언어를 정의하는 대신, JSONPath는 쿼리의 일부를 하위 런타임, 예를 들어 JavaScript의 eval() 함수에 위임했다. JSONPath가 더 많은 환경에서 구현됨에 따라, JSONPath 표현식의 이식성은 점점 낮아졌다. 예를 들어 정규 표현식 처리는 종종 편리한 정규 표현식 엔진에 위임되었다.¶

이 문서는 이러한 구현별 의존성을 제거하고 프로그래밍 언어와 환경 전반에서 사용할 수 있는 공통 JSONPath 명세로 기능하는 것을 목표로 한다. 이는 하위 호환성이 항상 달성되는 것은 아님을 의미한다. 이 문서의 설계 원칙은 사용 가능하고 안정적인 JSON 쿼리 언어를 얻는다는 목적을 위태롭게 하지 않는 한, 대략적이라도 구현 간의 "합의"를 따르는 것이다.¶

JSONPath라는 용어는 XPath의 영감 때문이기도 하고, 또한 쿼리의 결과가 JSON 쿼리 인자에서 노드를 식별하는 경로들로 이루어지기 때문에 선택되었다.¶

1.3. JSON 값

JSONPath 쿼리가 적용되는 JSON 값은 정의상 유효한 JSON 값이다. JSON 값은 종종 JSON 텍스트를 파싱하여 구성된다.¶

JSON 텍스트를 JSON 값으로 파싱하는 것과, JSON 텍스트가 유효한 JSON을 나타내지 않을 때 발생하는 일은 이 문서에서 정의하지 않는다. [RFC8259]의 4 및 8 섹션은 JSON 텍스트의 문법에는 부합할 수 있지만, 예측 불가능한 동작을 유발할 수 있어 상호 운용 가능한 JSON 사용은 아닌 특정 상황을 식별한다. 이 문서는 이러한 상황에서 JSONPath 쿼리에 대해 예측 가능한 동작을 정의하려고 시도하지 않는다.¶

구체적으로, 섹션 2.3.1, 2.3.2, 2.3.5, 및 2.5.2의 "의미론" 하위 섹션은 고려 중인 객체 중 하나에 대한 JSON 값이 하나의 객체에 동일한 멤버 이름을 공유하는 여러 멤버를 가진 JSON 텍스트로부터 구성된 경우 ("중복 이름"; [RFC8259]의 섹션 4 참조) 예측 불가능해지는 동작을 설명한다. 또한 이름으로 자식을 선택할 때(섹션 2.3.1)와 문자열을 비교할 때 (섹션 2.3.5.2.2), 이러한 문자열은 유니코드 스칼라 값의 시퀀스라고 가정된다. 그렇지 않은 경우 동작은 예측 불가능해진다([RFC8259]의 섹션 8.2).¶

1.4. JSONPath 표현식 개요

JSONPath 표현식은 쿼리 인자라고 하는 JSON 값에 적용된다. 출력은 노드 리스트이다.¶

JSONPath 표현식은 식별자 뒤에 0개 이상의 세그먼트 시퀀스가 이어지는 형태이며, 각 세그먼트는 하나 이상의 선택자를 포함한다.¶

$['store']['book'][0]['title']

$.store.book[0].title

$.store.book[?@.price < 10].title

1.5. JSONPath 예제

이 섹션은 정보 제공용이다. JSONPath 표현식의 예제를 제공한다.¶

예제는 그림 1에 표시된 간단한 JSON 값을 기반으로 하며, 서점(자전거도 하나 있음)을 나타낸다.¶

{ "store": {
    "book": [
      { "category": "reference",
        "author": "Nigel Rees",
        "title": "Sayings of the Century",
        "price": 8.95
      },
      { "category": "fiction",
        "author": "Evelyn Waugh",
        "title": "Sword of Honour",
        "price": 12.99
      },
      { "category": "fiction",
        "author": "Herman Melville",
        "title": "Moby Dick",
        "isbn": "0-553-21311-3",
        "price": 8.99
      },
      { "category": "fiction",
        "author": "J. R. R. Tolkien",
        "title": "The Lord of the Rings",
        "isbn": "0-395-19395-8",
        "price": 22.99
      }
    ],
    "bicycle": {
      "color": "red",
      "price": 399
    }
  }
}

표 2는 이 예제에 적용될 수 있는 몇 가지 JSONPath 쿼리와 그 의도된 결과를 보여 준다.¶

2.1. 개요

JSONPath 표현식은 JSON 값 (쿼리 인자)에 적용될 때 인자의 노드를 0개 이상 선택하고 이 노드들을 노드 리스트로 출력하는 문자열이다.¶

쿼리는 UTF-8을 사용하여 인코딩되어야 한다. 이 문서에서 제시하는 쿼리 문법은 그 UTF-8 형식이 먼저 [RFC3629]에 설명된 대로 유니코드 스칼라 값으로 디코딩된다고 가정한다. 동등한 결과를 낳는 구현 접근법도 가능하다.¶

JSONPath 쿼리로 사용될 문자열은 올바른 형식이고 유효해야 한다. 문자열이 이 문서의 ABNF 구문에 부합하면 올바른 형식의 JSONPath 쿼리이다. 올바른 형식의 JSONPath 쿼리가 이 문서가 제시하는 두 가지 의미론적 요구사항도 모두 충족하면 유효하며, 그 요구사항은 다음과 같다:¶

1. JSONPath 처리와 관련된 JSONPath 쿼리 내의 정수 (예: 인덱스 값과 step)는 Internet JSON(I-JSON)에 정의된 정확한 정수 값의 범위 안에 있어야 한다([RFC7493]의 섹션 2.2 참조). 즉 구간 [-(2⁵³)+1, (2⁵³)-1] 안에 있어야 한다.¶
2. 함수 확장의 사용은 섹션 2.4.3에 설명된 대로 올바른 타입이어야 한다.¶

JSONPath 구현은 올바른 형식이 아니거나 유효하지 않은 모든 쿼리에 대해 오류를 발생시켜야 한다. JSONPath 쿼리의 올바른 형식성과 유효성은 쿼리가 적용되는 JSON 값과 독립적이다. 값을 대상으로 쿼리를 적용하는 동안 JSONPath 쿼리의 올바른 형식성 및 유효성과 관련된 추가 오류가 발생할 수 없다. 이는 쿼리의 올바른 형식성/유효성 오류를 실제로 데이터의 결함에서 비롯될 수 있는 불일치와 명확히 분리한다.¶

유효한 쿼리가 기대하는 구조와 데이터에서 발견되는 구조 사이의 불일치는 빈 쿼리 결과로 이어질 수 있으며, 이는 예상치 못한 것이고 어느 한쪽의 버그를 나타낼 수 있다. 따라서 JSONPath 구현은 애플리케이션 개발자가 빈 결과의 원인을 찾는 데 도움이 되는 진단 정보를 제공하고자 할 수 있다.¶

물론 구현은 JSONPath 쿼리를 실행할 때, 예를 들어 리소스 고갈 때문에 여전히 실패할 수 있지만, 이는 이 문서에서 모델링하지 않는다. 그러나 구현은 조용히 오동작해서는 안 된다. 구체적으로, 유효한 JSONPath 쿼리가 쿼리를 올바르게 처리하기에는 크기가 너무 큰 구조화된 값에 대해 평가되는 경우(예를 들어 정확한 값의 범위를 벗어나는 숫자의 처리를 요구하는 경우), 구현은 오버플로 표시를 제공해야 한다.¶

(HTTP 오류 모델에 익숙한 독자는 올바른 형식성과 유효성을 생각할 때 400 유형 오류를 떠올릴 수 있으며, 리소스 고갈 및 관련 오류를 500 유형 오류에 비교할 수 있다고 인식할 수 있다.)¶

jsonpath-query      = root-identifier segments
segments            = *(S segment)

B                   = %x20 /    ; Space
                      %x09 /    ; Horizontal tab
                      %x0A /    ; Line feed or New line
                      %x0D      ; Carriage return
S                   = *B        ; optional blank space

2.2. 루트 식별자

root-identifier     = "$"

{"k": "v"}

2.3. 선택자

선택자는 자식 세그먼트 (섹션 2.5.1)와 하위 세그먼트 (섹션 2.5.2) 안에만 나타난다.¶

선택자는 입력 값의 자식을 0개 이상 포함하는 노드 리스트를 생성한다.¶

객체의 자식, 배열의 자식, 또는 객체와 배열 둘 다의 자식을 생성하는 다양한 종류의 선택자가 있다.¶

selector            = name-selector /
                      wildcard-selector /
                      slice-selector /
                      index-selector /
                      filter-selector

각 종류의 선택자에 대한 구문과 의미론은 아래에 정의되어 있다.¶

name-selector       = string-literal

string-literal      = %x22 *double-quoted %x22 /     ; "string"
                      %x27 *single-quoted %x27       ; 'string'

double-quoted       = unescaped /
                      %x27      /                    ; '
                      ESC %x22  /                    ; \"
                      ESC escapable

single-quoted       = unescaped /
                      %x22      /                    ; "
                      ESC %x27  /                    ; \'
                      ESC escapable

ESC                 = %x5C                           ; \ backslash

unescaped           = %x20-21 /                      ; see RFC 8259
                         ; omit 0x22 "
                      %x23-26 /
                         ; omit 0x27 '
                      %x28-5B /
                         ; omit 0x5C \
                      %x5D-D7FF /
                         ; skip surrogate code points
                      %xE000-10FFFF

escapable           = %x62 / ; b BS backspace U+0008
                      %x66 / ; f FF form feed U+000C
                      %x6E / ; n LF line feed U+000A
                      %x72 / ; r CR carriage return U+000D
                      %x74 / ; t HT horizontal tab U+0009
                      "/"  / ; / slash (solidus) U+002F
                      "\"  / ; \ backslash (reverse solidus) U+005C
                      (%x75 hexchar) ;  uXXXX U+XXXX

hexchar             = non-surrogate /
                      (high-surrogate "\" %x75 low-surrogate)
non-surrogate       = ((DIGIT / "A"/"B"/"C" / "E"/"F") 3HEXDIG) /
                      ("D" %x30-37 2HEXDIG )
high-surrogate      = "D" ("8"/"9"/"A"/"B") 2HEXDIG
low-surrogate       = "D" ("C"/"D"/"E"/"F") 2HEXDIG

HEXDIG              = DIGIT / "A" / "B" / "C" / "D" / "E" / "F"

{
  "o": {"j j": {"k.k": 3}},
  "'": {"@": 2}
}

wildcard-selector   = "*"

{
  "o": {"j": 1, "k": 2},
  "a": [5, 3]
}

index-selector      = int                        ; decimal integer

int                 = "0" /
                      (["-"] DIGIT1 *DIGIT)      ; - optional
DIGIT1              = %x31-39                    ; 1-9 non-zero digit

["a","b"]

slice-selector      = [start S] ":" S [end S] [":" [S step ]]

start               = int       ; included in selection
end                 = int       ; not included in selection
step                = int       ; default: 1

FUNCTION Normalize(i, len):
  IF i >= 0 THEN
    RETURN i
  ELSE
    RETURN len + i
  END IF

FUNCTION Bounds(start, end, step, len):
  n_start = Normalize(start, len)
  n_end = Normalize(end, len)

  IF step >= 0 THEN
    lower = MIN(MAX(n_start, 0), len)
    upper = MIN(MAX(n_end, 0), len)
  ELSE
    upper = MIN(MAX(n_start, -1), len-1)
    lower = MIN(MAX(n_end, -1), len-1)
  END IF

  RETURN (lower, upper)

IF step > 0 THEN

  i = lower
  WHILE i < upper:
    SELECT a(i)
    i = i + step
  END WHILE

ELSE if step < 0 THEN

  i = upper
  WHILE lower < i:
    SELECT a(i)
    i = i + step
  END WHILE

END IF

["a", "b", "c", "d", "e", "f", "g"]

filter-selector     = "?" S logical-expr

logical-expr        = logical-or-expr
logical-or-expr     = logical-and-expr *(S "||" S logical-and-expr)
                        ; disjunction
                        ; binds less tightly than conjunction
logical-and-expr    = basic-expr *(S "&&" S basic-expr)
                        ; conjunction
                        ; binds more tightly than disjunction

basic-expr          = paren-expr /
                      comparison-expr /
                      test-expr

paren-expr          = [logical-not-op S] "(" S logical-expr S ")"
                                        ; parenthesized expression
logical-not-op      = "!"               ; logical NOT operator

test-expr           = [logical-not-op S]
                      (filter-query / ; existence/non-existence
                       function-expr) ; LogicalType or NodesType
filter-query        = rel-query / jsonpath-query
rel-query           = current-node-identifier segments
current-node-identifier = "@"

comparison-expr     = comparable S comparison-op S comparable
literal             = number / string-literal /
                      true / false / null
comparable          = literal /
                      singular-query / ; singular query value
                      function-expr    ; ValueType
comparison-op       = "==" / "!=" /
                      "<=" / ">=" /
                      "<"  / ">"

singular-query      = rel-singular-query / abs-singular-query
rel-singular-query  = current-node-identifier singular-query-segments
abs-singular-query  = root-identifier singular-query-segments
singular-query-segments = *(S (name-segment / index-segment))
name-segment        = ("[" name-selector "]") /
                      ("." member-name-shorthand)
index-segment       = "[" index-selector "]"

number              = (int / "-0") [ frac ] [ exp ] ; decimal number
frac                = "." 1*DIGIT                  ; decimal fraction
exp                 = "e" [ "-" / "+" ] 1*DIGIT    ; decimal exponent
true                = %x74.72.75.65                ; true
false               = %x66.61.6c.73.65             ; false
null                = %x6e.75.6c.6c                ; null

{
  "obj": {"x": "y"},
  "arr": [2, 3]
}

{
  "a": [3, 5, 1, 2, 4, 6,
        {"b": "j"},
        {"b": "k"},
        {"b": {}},
        {"b": "kilo"}
       ],
  "o": {"p": 1, "q": 2, "r": 3, "s": 5, "t": {"u": 6}},
  "e": "f"
}

2.4. 함수 확장

앞선 하위 섹션들에서 정의된 필터 표현식 기능을 넘어, JSONPath는 필터 표현식 기능을 추가하는 데 사용할 수 있는 확장 지점인 "함수 확장"을 정의한다.¶

이 섹션은 확장 지점과 이 확장 지점을 사용하는 몇 가지 함수 확장을 정의한다. 이러한 메커니즘은 확장 지점을 사용하도록 설계되었지만, JSONPath 명세의 필수적인 부분이며 이 명세의 다른 필수적인 부분과 마찬가지로 구현될 것으로 기대된다.¶

함수 확장은 등록된 이름(섹션 3.2 참조)을 정의하며, 이 이름은 0개 이상의 인수 시퀀스에 적용되어 결과를 생성할 수 있다. 등록된 각 함수 이름은 고유하다.¶

함수 확장은 그 평가가 부작용이 없도록 정의되어야 MUST 한다. 즉, 이를 포함하는 표현식에 대해 가능한 모든 평가 순서와 단락 평가 또는 완전 평가의 선택이 동일한 결과로 이어져야 MUST 한다. (참고: 메모이제이션이나 로깅은 이 의미에서 부작용이 아니다. 이는 구현 수준에서만 보이며, 평가 결과에 영향을 주지 않기 때문이다.)¶

function-name       = function-name-first *function-name-char
function-name-first = LCALPHA
function-name-char  = function-name-first / "_" / DIGIT
LCALPHA             = %x61-7A  ; "a".."z"

function-expr       = function-name "(" S [function-argument
                         *(S "," S function-argument)] S ")"
function-argument   = literal /
                      filter-query / ; (includes singular-query)
                      logical-expr /
                      function-expr

쿼리 안의 모든 함수 표현식은 위의 ABNF에 부합하여 올바른 형식이어야 하고 타입이 올바라야 한다. 그렇지 않으면 JSONPath 구현은 오류를 발생시켜야 MUST 한다 (섹션 2.1 참조). 어떤 함수 표현식이 타입이 올바른지를 정의하기 위해, 먼저 타입 시스템을 도입한다.¶

$[?length(@.authors) >= 5]

$[?count(@.*.author) >= 5]

$[?match(@.date, "1974-05-..")]

$[?search(@.author, "[BR]ob")]

$[?value(@..color) == "red"]

2.5. 세그먼트

입력 노드 리스트의 각 노드에 대해, 세그먼트는 하나 이상의 선택자를 노드에 적용하고 각 선택자의 결과를 입력 노드별 노드 리스트로 이어 붙인다. 그런 다음 이들은 입력 노드 리스트의 순서대로 이어 붙여져 하나의 세그먼트 결과 노드 리스트를 형성한다.¶

쿼리에 세그먼트가 많을수록, 결과 노드 리스트의 노드가 입력 값에서 갖는 깊이가 더 커진다는 점을 알 수 있다:¶

• N개의 세그먼트를 가진 쿼리(N >= 0)는 입력 값에서 깊이가 N 이상인 노드들로 이루어진 노드 리스트를 생성한다.¶
• N개의 세그먼트를 가진 쿼리(N >= 0)에서, 그 세그먼트가 모두 자식 세그먼트 (섹션 2.5.1)인 경우, 입력 값에서 정확히 깊이 N인 노드들로 이루어진 노드 리스트를 생성한다.¶

세그먼트에는 두 종류가 있다: 자식 세그먼트와 자손 세그먼트.¶

segment             = child-segment / descendant-segment

각 종류의 세그먼트에 대한 구문과 의미론은 아래에 정의되어 있다.¶

child-segment       = bracketed-selection /
                      ("."
                       (wildcard-selector /
                        member-name-shorthand))

bracketed-selection = "[" S selector *(S "," S selector) S "]"

member-name-shorthand = name-first *name-char
name-first          = ALPHA /
                      "_"   /
                      %x80-D7FF /
                         ; skip surrogate code points
                      %xE000-10FFFF
name-char           = name-first / DIGIT

DIGIT               = %x30-39              ; 0-9
ALPHA               = %x41-5A / %x61-7A    ; A-Z / a-z

["a", "b", "c", "d", "e", "f", "g"]

descendant-segment  = ".." (bracketed-selection /
                            wildcard-selector /
                            member-name-shorthand)

{
  "o": {"j": 1, "k": 2},
  "a": [5, 3, [{"j": 4}, {"k": 6}]]
}

2.6. null의 의미론

참고: JSON null은 다른 모든 JSON 값과 동일하게 처리된다. 즉, "undefined"나 "missing"을 의미하는 것으로 간주되지 않는다.¶

{"a": null, "b": [null], "c": [{}], "null": 1}

2.7. 정규화 경로

정규화 경로는 값 안에서 노드의 위치를 나타내는 고유한 표현이며, 값 안의 노드를 고유하게 식별한다. 구체적으로, 정규화 경로는 제한된 구문(아래에 정의됨)을 가진 JSONPath 쿼리이며, 예를 들어 $['book'][3]와 같이 값에 적용될 때, 정규화 경로가 식별하는 노드만으로 이루어진 노드 리스트를 결과로 낸다. 참고: 정규화 경로는 특정 값 안에서 노드의 정체성을 나타낸다. 값 안의 특정 노드를 식별하는 정규화 경로는 정확히 하나만 존재한다.¶

노드 리스트는 JSON에서 문자열 배열로 간결하게 표현될 수 있으며, 이 문자열들은 정규화 경로이다.¶

정규화 경로는 노드 리스트의 테스트와 후처리, 예를 들어 중복 노드 제거를 단순화하는 예측 가능한 형식을 제공한다. 정규화 경로는 이 문서의 예제에서 결과 경로로 사용된다.¶

정규화 경로는 점 표기법이 아니라 정식 대괄호 표기법을 사용한다.¶

정규화 경로에서는 문자열 멤버 이름을 구분하기 위해 작은따옴표를 사용한다. 이는 정규화 경로가 큰따옴표로 구분된 문자열, 예를 들어 JSON 텍스트 안에 나타날 때 이스케이프가 필요한 문자 수를 줄인다.¶

정규화 경로에서는 특정 문자가 오직 한 가지 방식으로만 이스케이프되며, 그 밖의 모든 문자는 이스케이프되지 않는다.¶

normalized-path      = root-identifier *(normal-index-segment)
normal-index-segment = "[" normal-selector "]"
normal-selector      = normal-name-selector / normal-index-selector
normal-name-selector = %x27 *normal-single-quoted %x27 ; 'string'
normal-single-quoted = normal-unescaped /
                       ESC normal-escapable
normal-unescaped     =    ; omit %x0-1F control codes
                       %x20-26 /
                          ; omit 0x27 '
                       %x28-5B /
                          ; omit 0x5C \
                       %x5D-D7FF /
                          ; skip surrogate code points
                       %xE000-10FFFF

normal-escapable     = %x62 / ; b BS backspace U+0008
                       %x66 / ; f FF form feed U+000C
                       %x6E / ; n LF line feed U+000A
                       %x72 / ; r CR carriage return U+000D
                       %x74 / ; t HT horizontal tab U+0009
                       "'" /  ; ' apostrophe U+0027
                       "\" /  ; \ backslash (reverse solidus) U+005C
                       (%x75 normal-hexchar)
                                       ; certain values u00xx U+00XX
normal-hexchar       = "0" "0"
                       (
                          ("0" %x30-37) / ; "00"-"07"
                             ; omit U+0008-U+000A BS HT LF
                          ("0" %x62) /    ; "0b"
                             ; omit U+000C-U+000D FF CR
                          ("0" %x65-66) / ; "0e"-"0f"
                          ("1" normal-HEXDIG)
                       )
normal-HEXDIG        = DIGIT / %x61-66    ; "0"-"9", "a"-"f"
normal-index-selector = "0" / (DIGIT1 *DIGIT)
                        ; non-negative decimal integer

주어진 노드를 식별하는 정규화 경로는 하나만 있을 수 있으므로, 구문은 어떤 문자를 이스케이프하고 어떤 문자를 이스케이프하지 않는지 규정한다. 따라서 normal-hexchar의 정의는 예를 들어 U+000B LINE TABULATION처럼 그대로 출력하기 쉽지 않지만 \n과 같은 표준 JSON 이스케이프가 없는 문자를 16진수로 이스케이프하도록 설계되었다.¶

3.1. 미디어 타입 application/jsonpath 등록

IANA는 다음 미디어 타입을 등록했다 [RFC6838]:¶

타입 이름:

application¶

하위 타입 이름:

jsonpath¶

필수 매개변수:

N/A¶

선택 매개변수:

N/A¶

인코딩 고려 사항:

binary (UTF-8)¶

보안 고려 사항:

RFC 9535의 보안 고려 사항 섹션 참조.¶

상호운용성 고려 사항:

N/A¶

공개된 명세:

RFC 9535¶

이 미디어 타입을 사용하는 애플리케이션:

JSON 데이터에서 쿼리를 전달해야 하는 애플리케이션¶

프래그먼트 식별자 고려 사항:

N/A¶

추가 정보:

이 타입에 대한 폐기된 별칭 이름:

N/A¶

매직 넘버:

N/A¶

파일 확장자:

N/A¶

Macintosh 파일 타입 코드:

N/A¶

추가 정보를 위한 연락 담당자 및 이메일 주소:

iesg@ietf.org¶

의도된 사용:

COMMON¶

사용 제한:

N/A¶

저자:

JSONPath WG¶

변경 관리자:

IETF¶

3.2. 함수 확장 하위 레지스트리

이 명세에 따라, IANA는 새로운 "JSONPath" 레지스트리 안에 새로운 "Function Extensions" 하위 레지스트리를 만들었다. "Function Extensions" 하위 레지스트리는 "Expert Review" 정책을 가진다 ([RFC8126]의 섹션 4.5).¶

하위 레지스트리의 각 항목은 다음을 포함해야 한다:¶

함수 이름:

문자로 시작하고 이후에 문자, 숫자, 밑줄 문자를 포함할 수 있는 소문자 ASCII [RFC0020] 문자열 ([a-z][_a-z0-9]*). 하위 레지스트리의 다른 항목은 같은 함수 이름을 가질 수 없다.¶

간단한 설명:

간단한 설명¶

매개변수:

이 함수 확장에 대해 예상되는 각 인수마다 하나씩, 0개 이상의 선언 타입을 쉼표로 구분한 목록¶

결과:

이 함수 확장에 대한 결과의 선언 타입¶

변경 관리자:

[RFC8126]의 섹션 2.3 참조.¶

참조:

함수 확장에 대한 설명을 제공하는 참조 문서¶

이 하위 레지스트리의 초기 항목은 표 19에 나열되어 있다. "Change Controller" 열의 항목들은 모두 "IETF" 값을 가지며, "Reference" 열의 항목들은 모두 "RFC 9535의 섹션 2.4" 값을 가진다:¶

4.1. JSONPath 구현에 대한 공격 벡터

역사적으로 JSONPath는 쿼리의 일부를 기본 프로그래밍 언어 엔진, 예를 들어 JavaScript의 eval() 함수에 공급하는 방식으로 구현되는 경우가 많았다. 이 접근 방식은 인젝션 공격으로 이어지는 것으로 잘 알려져 있으며, 이러한 공격을 방지하려면 완벽한 입력 검증이 필요하다 (JSON 자체에 대한 유사한 고려 사항은 [RFC8259]의 섹션 12 참조). 대신 JSONPath 구현은 프로그래밍 언어 엔진의 파서에 의존하지 않고 쿼리의 전체 구문을 구현해야 한다.¶

가용성에 대한 공격은 특정 구현이 특정 경우에 보이는 비정상적으로 비용이 큰 런타임 성능을 유발하려고 시도할 수 있다. (해시 테이블 구현의 문제는 [RFC8949]의 섹션 10, 정규 표현식 구현의 성능 문제는 [RFC9485]의 섹션 8 참조.) 구현자는 공격자가 놀랄 만큼 높은, 어쩌면 지수적인 CPU 사용량을 유발하는 특수하게 제작된 JSONPath 쿼리나 쿼리 인자를 제출하거나, 예를 들어 자손 세그먼트의 단순한 재귀 구현을 통해 스택 오버플로를 유발할 수 있는 한, 좋은 평균 성능만으로는 충분하지 않다는 점을 인식해야 한다. 구현은 이러한 공격을 완화하기 위해 적절한 자원 관리를 갖추어야 한다.¶

4.2. JSONPath 쿼리가 형성되는 방식에 대한 공격 벡터

JSONPath 쿼리는 정적인 경우만 있는 것이 아니라, 필터 표현식에서 비교할 인덱스 값, 멤버 이름, 또는 값을 제공하는 변수로부터 형성되는 경우가 많다. 이러한 변수는 검증되어야 하며(예: 주어진 값이 허용할 때 .name 같은 특정 구성만 형성되도록 허용), 변환되어야 한다(예: 문자열 구분자를 이스케이프). 이러한 검증과 변환을 올바르게 수행하지 않으면 예기치 않은 실패로 이어질 수 있고, 이는 특히 공격자가 값에 대한 제어권을 가지고 있는 경우 (예: 웹 양식에 값을 입력하는 방식으로) 가용성, 기밀성, 무결성 침해로 이어질 수 있다. 그 결과 생기는 공격 종류인 인젝션(예: SQL 인젝션)은 애플리케이션 보안 취약점의 주요 원인 가운데 지속적으로 발견되며, 특별한 주의를 요구한다.¶

4.3. JSONPath를 사용하는 보안 메커니즘에 대한 공격

JSONPath가 보안 메커니즘의 일부로 사용되는 경우, 공격자는 예기치 않거나 예측할 수 없는 동작을 유발하거나 JSONPath 구현 간 동작 차이를 이용하려고 시도할 수 있다.¶

예기치 않거나 예측할 수 없는 동작은 [RFC8259]에서 예측 불가능하다고 설명한 특정 구성을 가진 쿼리 인자에서 발생할 수 있다. 객체의 순서와 관련된 경우를 제외하면, [RFC7493]에 부합하는 모든 쿼리 인자에 대해 예측 가능한 동작을 기대할 수 있다.¶

다른 공격은 UTF-8 ([RFC3629]의 섹션 10 참조)과 유니코드 문자 집합 같은 기반 기술의 동작을 표적으로 삼을 수 있다.¶

B.1. JSONPath와 XPath

XPath 표현식이 XML 문서와 함께 사용되는 것과 같은 방식으로 JSONPath 표현식은 JSON 값에 적용된다. JSONPath는 XPath의 맨 앞 /와 유사하게, 쿼리 인자의 루트 노드를 가리키기 위해 $를 사용한다.¶

JSONPath 표현식은 점 표기법 ($.store.book[0].title) 또는 대괄호 표기법 ($['store']['book'][0]['title'])을 사용해 계층 구조 아래로 더 이동한다. 둘 다 쿼리 표현식 안에서 XPath의 /를 대체하며, 여기서 점 표기법은 가볍지만 제한적인 구문으로 쓰이고, 대괄호 표기법은 무겁지만 더 일반적인 구문으로 쓰인다.¶

JSONPath와 XPath는 모두 와일드카드로 *를 사용한다. ..로 시작하는 JSONPath의 자손 세그먼트 표기법은 [E4X]에서 차용한 것으로, XPath의 //와 유사하다. 배열 슬라이싱 구성 [start:end:step]은 JSONPath에 고유하며, ECMASCRIPT 4의 [SLICE]에서 영감을 받았다.¶

필터 표현식은 다음과 같이 ?<logical-expr> 구문을 통해 지원된다:¶

$.store.book[?@.price < 10].title

표 20은 유사한 XPath 개념과의 비교를 제공하여 표 1을 확장한다.¶

추가 설명을 위해, 표 21은 몇 가지 XPath 표현식과 그에 대응하는 JSONPath 표현식을 보여 준다.¶

XPath는 이 비교에 나열된 것보다 훨씬 더 많은 기능 (축약되지 않은 구문의 위치 경로, 연산자, 함수)을 가진다. 또한 XPath와 JSONPath에서 첨자 연산자가 동작하는 방식에는 상당한 차이가 있다:¶

• XPath 표현식의 대괄호는 항상 앞선 경로 조각에서 나온 노드 집합에 대해 동작한다. 인덱스는 항상 1에서 시작한다.¶
• JSONPath에서는 대괄호가 앞선 쿼리 세그먼트에서 나온 노드 리스트의 각 노드에 대해 동작한다. 배열 인덱스는 항상 0에서 시작한다.¶