1.1. 术语

本文档中的关键词“MUST”、“MUST NOT”、“REQUIRED”、“SHALL”、“SHALL NOT”、“SHOULD”、“SHOULD NOT”、“RECOMMENDED”、“NOT RECOMMENDED”、 “MAY”和“OPTIONAL” 应按照 BCP 14 [RFC2119] [RFC8174] 中的描述进行解释，但仅当它们以全大写形式出现时，如此处所示。¶

本文档中的语法规则应按 ABNF 解释， 如 [RFC5234] 中所述。 本文档中的 ABNF 终端值定义的是 Unicode 标量值，而不是 其 UTF-8 编码。 例如，Unicode PLACE OF INTEREST SIGN（U+2318）在 ABNF 中可定义为 %x2318。¶

函数使用函数名后跟一对括号来引用， 例如 fname()。¶

除非下文另有澄清，采用 [RFC8259] 的术语。 术语“primitive”和“structured”用于按照 [RFC8259] 的 第 1 节 对 不同种类的值进行分组。JSON 对象和数组是 结构化的；所有其他值都是基本的。 “object”、“array”、“number”和“string”的定义保持 不变。 重要的是，尤其是“object”和“array”并不具有 通用含义，例如它们在一般编程语境中可能具有的含义。¶

采用 [RFC9485] 的术语。¶

本文档中使用的其他术语定义如下。¶

值：

按照 [RFC8259]，符合 JSON 通用数据模型的数据项，即 基本数据（数字、文本字符串以及特殊 值 null、true 和 false），或结构化数据（JSON 对象和数组）。 [RFC8259] 侧重于 JSON 值的文本 表示，并且 没有完整定义此处假定的值抽象。¶

成员：

对象中的名称/值对。（成员本身不是 值。）¶

名称：

构成成员的名称/值对中的名称（一个字符串）。 这也在 [RFC8259] 中使用， 但该规范并未 正式定义它。 此处包含该术语是为了完整性。¶

元素：

JSON 数组中的一个值。¶

索引：

标识数组中特定元素的整数。¶

查询：

JSONPath 表达式的简称。¶

查询实参：

JSONPath 表达式所应用到的值的简称。¶

位置：

值在查询实参中的位置。可以将其 看作一系列名称和索引，通过 查询实参中的对象和数组导航到该值，空序列 表示查询实参本身。 位置可以表示为规范化路径（定义如下）。¶

节点：

一个值及其在查询实参中的位置所组成的对。¶

根节点：

其值为整个查询实参的唯一节点。¶

根节点标识符：

表达式 $，它引用查询实参的根节点。¶

当前节点标识符：

表达式 @，它在过滤器表达式求值的 语境中引用当前节点（稍后描述）。¶

子节点（某节点的）：

如果该节点是数组，则为其元素的节点；如果该节点 是对象，则为其成员值的节点。 如果该节点既不是数组也不是对象，则它没有子节点。¶

后代（某节点的）：

该节点的子节点，以及其 子节点的子节点，如此递归。 更形式化地说，节点之间的“后代”关系是“子节点” 关系的传递闭包。¶

深度（值中后代节点的）：

该节点在该值中的祖先数量。该值的根 节点深度为零， 根节点的子节点深度为一，它们的子节点深度为二，依此类推。¶

节点列表：

节点的列表。 虽然节点列表可以用 JSON 表示，例如表示为数组，但本文档 不要求也不假定任何特定表示。¶

形参：

形式参数（函数的），可在函数表达式中 接受函数实参 （实际参数）。¶

规范化路径：

JSONPath 表达式的一种形式，它通过 提供一个查询来标识值中的某个节点，该查询的结果正好是该节点。 查询实参中的每个节点都由恰好一个规范化路径标识 （我们说该规范化路径对该节点是“唯一”的），并且要成为特定查询实参的 规范化路径，该规范化路径需要标识 恰好一个节点。这类似于 JSON Pointer [RFC6901]，但语法上不同。 注：此定义基于第 2.7 节中的语法定义； 能够标识值中某个节点但不符合该语法的 JSONPath 表达式不是规范化路径。¶

Unicode 标量值：

除高代理和 低代理码点之外的任何 Unicode [UNICODE] 码点（换言之，十六进制闭区间 0 到 D7FF 或 E000 到 10FFFF 中的整数）。JSONPath 查询是 Unicode 标量值序列。¶

段：

用于选择输入值的子节点 （[<selectors>]） 或后代（..⁠[<selectors>]）的构造之一。¶

选择器：

段内的单个项，它接受输入值并 产生一个由输入值的子节点组成的节点列表。¶

单一查询：

由在语法上以某种方式 受限的段构建的 JSONPath 表达式（第 2.3.5.1 节），从而无论输入 值为何，该表达式都会产生包含至多一个节点的节点列表。 注：总是产生单一节点列表但不符合 第 2.3.5.1 节中语法的 JSONPath 表达式不是单一查询。¶

1.2. 历史

本文档基于 Stefan Gössner 广受欢迎的 JSONPath 提案（日期为 2007-02-21）[JSONPath-orig]，建立在其实现被广泛 部署所积累的经验之上，并为其提供规范性规范。¶

附录 B 描述了 JSONPath 如何受到 XML 的 XPath [XPath] 启发。¶

JSONPath 原本旨在作为 JSON 在 PHP 和 JavaScript 等编程语言中的 实现的轻量级配套工具， 因此不像 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 文本语法但不属于可互操作使用的 特定情形，因为它们可能导致不可预测的行为。 本文档不试图为这些情形下的 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 节）时，假定这些 字符串是 Unicode 标量值序列；如果不是，则行为会变得不可预测 （[RFC8259] 的 第 8.2 节）。¶

1.4. JSONPath 表达式概述

JSONPath 表达式应用于一个 JSON 值，该值称为查询实参。 输出是节点列表。¶

JSONPath 表达式由一个标识符后跟一系列 零个或多个段组成，每个段包含一个或多个选择器。¶

$['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 值 （查询实参）时，它会选择该实参的零个或多个节点，并将 这些节点作为节点列表输出。¶

查询MUST使用 UTF-8 编码。 本文档给出的查询语法假定其 UTF-8 形式首先按照 [RFC3629] 中所述解码为 Unicode 标量值；能够得到等价 结果的实现方法也是可行的。¶

用作 JSONPath 查询的字符串需要是格式良好且 有效的。 如果字符串符合本文档中的 ABNF 语法，则它是格式良好的 JSONPath 查询。 如果格式良好的 JSONPath 查询还满足本文档提出的两个语义 要求，则它是有效的；这些要求如下：¶

1. JSONPath 查询中与 JSONPath 处理相关的 整数（例如索引值和步长）MUST 位于 Internet JSON（I-JSON） 中定义的精确整数值范围内（见 [RFC7493] 的 第 2.2 节 ），即位于区间 [-(2⁵³)+1, (2⁵³)-1] 内。¶
2. 函数扩展的使用MUST是 良类型的， 如第 2.4.3 节所述。¶

JSONPath 实现对于任何不是 格式良好且有效的查询MUST引发错误。 JSONPath 查询的格式良好性和有效性独立于 该查询所应用到的 JSON 值。在将查询应用于值的过程中， 不能再引发与 JSONPath 查询的 格式良好性和有效性相关的错误。 这清楚地把查询中的格式良好性/有效性错误 与可能实际源自数据缺陷的不匹配区分开来。¶

有效查询所期望的结构 与数据中发现的结构之间的不匹配，可能导致空查询结果， 这可能出乎意料，并指示二者之一存在缺陷。 因此，JSONPath 实现可能希望向应用开发者提供诊断信息， 以帮助找出空 结果的原因。¶

显然，实现仍可能在执行 JSONPath 查询时失败，例如由于资源耗尽，但本文档不对此建模。 然而，实现MUST NOT 静默失常。具体而言，如果一个有效的 JSONPath 查询 针对某个结构化值求值，而该值的大小过大，以至于无法 正确处理该查询（例如需要处理超出精确值范围的 数字），则实现 MUST提供溢出指示。¶

（熟悉 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 节）内。¶

选择器会产生一个由输入值的零个或多个子节点组成的节点列表。¶

有多种选择器可产生对象的子节点、 数组的子节点， 或对象和数组二者的子节点。¶

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 节），该名称 可应用于由零个或多个实参组成的序列，并产生一个 结果。每个已注册函数名都是唯一的。¶

函数扩展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 值一样处理， 即它不被视为表示“未定义”或“缺失”。¶

{"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， 但这些字符没有可用的标准 JSON 转义（例如 \n）。¶

3.1. 媒体类型 application/jsonpath 的注册

IANA 已注册以下媒体类型 [RFC6838]：¶

类型名称：

application¶

子类型名称：

jsonpath¶

必需参数：

不适用¶

可选参数：

不适用¶

编码注意事项：

二进制（UTF-8）¶

安全注意事项：

见 RFC 9535 的安全注意事项一节。¶

互操作性注意事项：

不适用¶

已发布规范：

RFC 9535¶

使用此媒体类型的应用：

需要在 JSON 数据中传达查询的应用¶

片段标识符注意事项：

不适用¶

附加信息：

此类型的已弃用别名：

不适用¶

魔数：

不适用¶

文件扩展名：

不适用¶

Macintosh 文件类型代码：

不适用¶

联系人及其电子邮件地址，用于获取更多信息：

iesg@ietf.org¶

预期用途：

COMMON¶

使用限制：

不适用¶

作者：

JSONPath 工作组¶

变更控制方：

IETF¶

3.2. 函数扩展 子注册表

根据本规范，IANA 已在 新的“JSONPath”注册表中创建新的“Function Extensions” 子注册表。“Function Extensions”子注册表采用“专家审查”策略 （[RFC8126] 的 第 4.5 节 ）。¶

子注册表中的每个条目都必须包含以下内容：¶

函数名称：

一个小写 ASCII [RFC0020] 字符串，以字母开头，之后可以 包含字母、数字和下划线字符 （[a-z][_a-z0-9]*）。子注册表中的其他条目不能具有 相同的函数名。¶

简要描述：

简要描述¶

形参：

零个或多个声明类型的逗号分隔列表，每个类型对应 此函数扩展所预期的一个 实参¶

结果：

此函数扩展结果的声明类型¶

变更控制方：

见 [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 节。） 实现者需要意识到，只要攻击者能够选择提交特制的 JSONPath 查询或查询实参，从而触发出人意料地高、甚至可能呈 指数级的 CPU 使用率，或者例如通过对后代段的朴素递归实现导致 栈溢出，那么良好的平均性能就 不足够。实现需要具有适当的资源管理 来缓解这些攻击。¶

4.2. 针对 JSONPath 查询形成方式的攻击向量

JSONPath 查询通常不是静态的，而是由提供索引值、 成员名或过滤器表达式中用于比较的值的变量 形成。 这些变量需要经过验证（例如，仅在给定值允许时才允许形成 .name 之类的特定构造）和转换 （例如，通过转义字符串分隔符）。 未正确执行这些验证和转换，可能导致意外 失败，进而可能导致可用性、机密性和 完整性破坏，尤其是在对手能够控制这些 值时（例如，通过把它们输入到 Web 表单中）。 由此产生的攻击类别，即注入（例如 SQL 注入）， 一直位列应用安全 漏洞的主要原因之中，需要特别关注。¶

4.3. 针对采用 JSONPath 的安全 机制的攻击

当 JSONPath 被用作安全机制的一部分时，攻击者 可以试图诱发意外或不可预测的行为，或 利用 JSONPath 实现之间的行为差异。¶

意外或不可预测的行为可能源自具有 某些由 [RFC8259] 描述为不可预测的构造的查询实参。 对于符合 [RFC7493] 的任何查询实参，除对象排序相关情况外， 可以预期有可预测的行为。¶

其他攻击可以针对底层技术的行为，例如 UTF-8（见 [RFC3629] 的 第 10 节） 和 Unicode 字符集。¶

B.1. JSONPath 和 XPath

JSONPath 表达式作用于 JSON 值的方式， 与 XPath 表达式结合 XML 文档使用的方式相同。 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 扩展了 表 1，提供与类似 XPath 概念的比较。¶

为了进一步说明，表 21 展示了一些 XPath 表达式 及其 JSONPath 等价形式。¶

XPath 拥有比此比较中列出的多得多的功能（未缩写语法中的位置路径、 运算符和函数）。此外，XPath 与 JSONPath 中下标运算符的工作方式存在显著差异：¶

• XPath 表达式中的方括号始终作用于 前一路径片段所产生的节点集。 索引始终从 1 开始。¶
• 使用 JSONPath 时，方括号作用于前一查询段所产生 节点列表中的每个节点。数组索引始终从 0 开始。¶