2.3. Selectors (选择器)

2.3. Selectors (选择器)

Selector 仅出现在 child segment (子片段) (第 2.5.1 节) 与 descendant segment (后代片段) (第 2.5.2 节) 内.

Selector 产生由输入值的零个或多个子节点组成的 nodelist.

存在多种 selector, 可产生对象的子节点, 数组的子节点, 或二者兼可.

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

各类 selector 的语法与语义见下文.

2.3.1. Name Selector (名称选择器)

2.3.1.1. Syntax (语法)

Name selector '' 至多选择一个 object member value (对象成员值).

与 JSON 不同, JSONPath 语法允许字符串使用 single (单) 或 double (双) 引号括起.

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"

说明:

• 双引号字符串遵循 JSON 字符串语法 ([RFC8259] 第 7 节); 单引号字符串遵循类似模式. 未尝试改进该语法, 因此若要转义标量值高于 0xFFFF 的字符, 例如 U+1F041 ("🁁", DOMINO TILE HORIZONTAL-02-02), 需用一对 surrogate escape 表示 (本例为 "\uD83C\uDC41").

• 引号字符串中的字母在 ABNF 中大小写不敏感, 因此 \u 转义内的每个十六进制数字可为大写或小写, 而 \u 中的 u 必须小写 (记为 %x75).

2.3.1.2. Semantics (语义)

Name-selector 字符串必须通过去除外围引号并将每个 escape sequence 替换为其等价 Unicode 字符的方式转换为成员名 M, 如表 4 所示:

Escape Sequence	Unicode Character	Description (描述)
\b	U+0008	BS backspace
\t	U+0009	HT horizontal tab
\n	U+000A	LF line feed
\f	U+000C	FF form feed
\r	U+000D	CR carriage return
"	U+0022	quotation mark
'	U+0027	apostrophe
/	U+002F	slash (solidus)
\	U+005C	backslash (reverse
		solidus)
\uXXXX	see	hexadecimal escape
	Section 2.3.1.1

表 4: Escape Sequence 替换

将 name-selector 应用于 object 节点选择名称等于成员名 M 的成员值; 若无此类成员值则什么也不选. 从非 object 的值中什么也不选.

注意: 处理 name selector 需要将成员名字符串 M 与所应用 JSON 中的成员名字符串比较. 两个字符串当且仅当为相同的 Unicode scalar values 序列时才算相等. 换言之, 在比较之前, 绝对不能对来自 JSONPath 的成员名字符串 M 或 JSON 中的成员名字符串施加 normalization (规范化) 操作.

2.3.1.3. Examples (示例)

JSON:

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

Queries:

表 5 的示例展示 child segment 中的 name selector.

Query	Result	Result Paths	Comment
$.o['j j']	{"k.k":	$['o']['j j']	嵌套
	3}		object
			中的
			具名
			值
$.o['j j']['k.k']	3	$['o']['j j']['k.k']	更深
			层
			嵌套
$.o["j j"]["k.k"]	3	$['o']['j j']['k.k']	查询中
			分隔符
			不同,
			Normalized
			Path
			不变
$["'"]["@"]	2	$[''']['@']	不寻常
			的
			成员名

表 5: Name Selector 示例

2.3.2. Wildcard Selector (通配符选择器)

2.3.2.1. Syntax (语法)

Wildcard selector 由星号组成.

wildcard-selector = "*"

2.3.2.2. Semantics (语义)

Wildcard selector 选择 object 或 array 的所有子节点的节点. 由于 JSON object 无序, 不规定 object 子节点在结果 nodelist 中的顺序. Array 的子节点在结果 nodelist 中按数组顺序出现.

注意 object 的子节点是其 member values, 而非 member names.

Wildcard selector 不从 primitive JSON 值 (即 number, string, true, false, null) 中选择任何内容.

2.3.2.3. Examples (示例)

JSON:

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

Queries:

表 6 的示例展示 child segment 中的 wildcard selector.

Query	Result	Result	Comment
		Paths
$[*]	{"j": 1,	$['o']	Object
	"k": 2}	$['a']	的值
	[5, 3]
$.o[*]	1	$['o']['j']	Object
	2	$['o']['k']	的值
$.o[*]	2	$['o']['k']	另一种
	1	$['o']['j']	结果
$.o[*,	1	$['o']['j']	非确定
*]	2	$['o']['k']	顺序
	2	$['o']['k']
	1	$['o']['j']
$.a[*]	5	$['a'][0]	Array
	3	$['a'][1]	成员

表 6: Wildcard Selector 示例

查询 $.o[*, *] 的示例表明, 当 wildcard selector 在 child segment 中应用于具有两个或更多成员的 object 节点时 (应用于成员少于两个的 object 节点或 array 节点时则否), 每次出现都可能产生不同顺序的 nodelist.

2.3.3. Index Selector (索引选择器)

2.3.3.1. Syntax (语法)

Index selector <index> 至多匹配一个 array element 值.

index-selector = int ; decimal integer

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

对数值 index-selector 的应用选择对应元素. JSONPath 允许其为负数 (见第 2.3.3.2 节).

为 valid, index selector 的值必须落在 I-JSON 可精确表示范围 (见第 2.1 节).

说明:

• Index-selector 为整数 (十进制, 与 JSON number 相同).

• 与 JSON number 相同, 语法不允许带前导零的类八进制整数, 如 01 或 -01.

2.3.3.2. Semantics (语义)

非负 index-selector 应用于 array 时, 使用从零开始的 index 选择 array 元素. 例如, selector 0 选择第一个, selector 4 选择足够长数组的第五个元素. 若 index 超出数组范围, 什么也不选, 且这不是错误. 从非 array 的值中什么也不选.

负 index-selector 从数组末端向前计数, 通过将数组长度加到负 index 上得到等价的非负 index-selector. 例如, selector -1 选择最后一个, selector -2 选择至少有两个元素的数组的倒数第二个. 与非负 index 一样, 若不存在该元素也不是错误; 仅表示未选中元素.

2.3.3.3. Examples (示例)

JSON:

["a","b"]

Queries:

表 7 的示例展示 child segment 中的 index selector.

Query	Result	Result Paths	Comment
$[1]	"b"	$[1]	Array
			元素
$[-2]	"a"	$[0]	Array
			元素,
			从末端

表 7: Index Selector 示例

2.3.4. Array Slice Selector (数组切片选择器)

2.3.4.1. Syntax (语法)

Array slice selector 的形式为 <start>::. 它从数组中匹配从 index <start> 开始, 到 (但不包含) <end> 为止的元素, 步进为 step, 默认 1.

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

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

Slice selector 由三个可选的十进制整数组成, 以冒号分隔. 省略第三个整数时可省略第二个冒号.

所提供的整数为 valid 时, 必须落在 I-JSON 可精确表示范围 (见第 2.1 节).

2.3.4.2. Semantics (语义)

Slice selector 的灵感来自拟议用于 ECMAScript 4 (ES4) 但未发布的 slice 运算符, 以及 Python 的对应物.

2.3.4.2.1. Informal Introduction (非正式介绍)

本节为 informative (资料性).

Array slicing 的行为灵感来自 JavaScript 语言中 Array.prototype.slice 方法, 由 ECMA-262 标准 [ECMA-262] 定义, 并增加受 Python slice 表达式启发的 step 参数.

Array slice 表达式 start:end:step 选择从 start 开始, 按 step 递增, 到 end (本身排除) 为止的 index 上的元素. 例如, 表达式 1:3 (step 默认为 1) 按该顺序选择 index 1 与 2 的元素; 而 1:5:2 选择 index 1 与 3.

Step 为负时, 按相反顺序选择元素. 例如, 5:1:-2 按该顺序选择 index 5 与 3; ::-1 按相反顺序选择数组全部元素.

Step 为 0 时不选择任何元素. (这是与 Python 行为唯一不同的情况, Python 在此情形会报错.)

下一节完整规定行为, 不依赖 JavaScript 或 Python.

2.3.4.2.2. Normative Semantics (规范性语义)

Slice 表达式按与数组相同或相反的顺序 (取决于 step 参数的符号) 选择输入数组元素的子集. 从非 array 的节点选择不到任何节点.

Slice 由两个 slice 参数 start 与 end 以及迭代增量 step 定义. 各参数均可选. 本节余下部分中, len 表示输入数组长度.

Step 的默认值为 1. Start 与 end 的默认值取决于 step 的符号, 如表 8.

Condition	start	end
step >= 0	0	len
step < 0	len - 1	-len - 1

表 8: Array Slice 的 start 与 end 默认值

Slice 表达式参数 start 与 end 不能直接用作 slice 边界, 必须先规范化. 为此目的的规范化定义为:

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

长度为 len 的数组上应用 array index 表达式 i 的结果, 等于 array slicing 表达式 Normalize(i, len):Normalize(i, len)+1:1 的结果.

Slice 表达式参数 start 与 end 用于推导 slice 边界 lower 与 upper. 由 step 符号定义的迭代方向决定哪个参数为下界, 哪个为上界:

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)

Slice 表达式选择 lower 与 upper 边界之间的 index 上的元素. 下列伪代码中, a(i) 为数组 a 的第 i+1 个元素 (即 a(0) 为第一个, a(1) 为第二个, 依此类推).

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

Step = 0 时不选择任何元素, 结果数组为空.

2.3.4.3. Examples (示例)

JSON:

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

Queries:

表 9 的示例展示 child segment 中的 array slice selector.

Query	Result	Result	Comment
		Paths
$[1:3]	"b"	$[1]	默认
	"c"	$[2]	step
			的
			slice
$[5:]	"f"	$[5]	无 end
	"g"	$[6]	index
			的 slice
$[1:5:2]	"b"	$[1]	step
	"d"	$[3]	为 2
			的 slice
$[5:1:-2]	"f"	$[5]	负 step
	"d"	$[3]	的 slice
$[::-1]	"g"	$[6]	逆序
	"f"	$[5]	slice
	"e"	$[4]
	"d"	$[3]
	"c"	$[2]
	"b"	$[1]
	"a"	$[0]

表 9: Array Slice Selector 示例

2.3.5. Filter Selector (过滤器选择器)

Filter selector 用于遍历 structured values (结构化值), 即 JSON array 与 object 的元素或成员. 这些 structured values 由使用 filter selector 的 child 或 descendant segment 所提供的 nodelist 标识.

每次迭代 (element/member) 时, 求值 logical expression (filter expression (过滤器表达式)), 以决定是否选择该 element/member 的节点. (Logical expression 求值结果在数学上是 Boolean 值, 但本规范使用 logical 一词, 以与 JSON 可表示的 Boolean 值区分.)

迭代过程中, filter expression 接收被过滤的 structured value 的每个 array element 或 object member value 的节点; 该 element 或 member value 即称为 current node (当前节点).

Current node 可作为 filter expression 子表达式中一个或多个 JSONPath 查询的起点, 通过 current-node-identifier @ 标记. 每个 JSONPath 查询可用于检测查询结果是否存在, 获取用于比较的特定 JSON 值, 或作为 function argument (函数实参).

Filter selector 可使用 function extensions, 见第 2.4 节. Filter selector 的 logical expression 内, function expression 可对 nodelist 与值运算. 可用函数集可扩展, 若干函数已预定义 (见第 2.4 节), 并可通过 "Function Extensions" subregistry (第 3.2 节) 注册更多函数. 定义函数时赋予唯一名称, 其返回值与每个 parameter 均有 declared type (声明类型). 类型系统范围有限; 目的在于表达无函数时在 filter expression 文法中隐含的约束. 类型系统也指导第 2.4.2 节的转换, 以模仿未使用 function expression 时文法处理不同表达式的方式.

2.3.5.1. Syntax (语法)

Filter selector 的形式为 ?<logical-expr>.

filter-selector = "?" S logical-expr

由于 filter expression 由无副作用的成份组成, 不必 (也未) 定义求值顺序. 类似地, 对合取 (&&) 与析取 (||) (后述), 短路求值与完全求值实现产生相同结果; 两种策略均有效.

Current node 可通过 current node identifier @ 访问. 该标识符指向直接包围该标识符的 filter-selector 的 current node. 注意: 在嵌套 filter-selector 内, 无法通过语法寻址除直接包围者以外的任何 filter-selector 的 current node (即包围直接包围者的那些 filter-selector).

Logical expression 提供通常的 Boolean 运算符 (|| 表示 OR, && 表示 AND, ! 表示 NOT). 它们具有 Boolean algebra (布尔代数) 的通常语义并服从其定律 (例如见 [BOOLEAN-LAWS]). 可以在 logical-expr 内使用括号分组.

不要求 logical-expr 由括号表达式构成 ([JSONPath-orig] 曾要求), 尽管可以如此, 语义与无括号时相同.

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 expression 要么检测 embedded query 所指定节点的存在性 (见第 2.3.5.2.1 节), 要么检测 function expression 的结果 (见第 2.4 节). 后者中, 若函数的声明结果类型为 LogicalType (见第 2.4.1 节), 则检测结果是否为 LogicalTrue; 若为 NodesType, 则检测结果是否非空. 若声明结果类型为 ValueType, 在 test expression 中使用则非 well-typed (见第 2.4.3 节).

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 expression 可用于 primitive values (即 number, string, true, false, null) 之间的比较. 可通过 literal; singular query (每个至多选一个节点, 然后使用该值); 或 ValueType 的 function expression (见第 2.4 节) 获得.

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 "]"

Literal 可按 JSON 的通常方式记法 (扩展为字符串可使用单引号界定).

注意: 引号字符串中的字母在 ABNF 中大小写不敏感, 因此浮点数内 ABNF 表达式 "e" 可为字符 'e' 或 'E'.

true, false, null 仅小写 (大小写敏感).

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

表 10 按优先级从高 (结合最紧) 到低列出 filter expression 运算符.

Precedence	Operator type	Syntax
5	Grouping	(...)
	Function Expressions	name(...)
4	Logical NOT	!
3	Relations	== !=
		< <= > >=
2	Logical AND	&&
1	Logical OR

表 10: Filter Expression 运算符优先级

2.3.5.2. Semantics (语义)

Filter selector 仅处理 array 与 object. 其结果为 (zero, one, multiple, 或 all) 个 array 元素或 member values 的列表, 视情况而定. 应用于 primitive value 时不选择任何内容 (因而不影响 filter selector 的结果).

结果 nodelist 中, array 的子节点按其在该 array 中的位置排序. Object (与 array 相对) 子节点在结果 nodelist 中的顺序不予规定, 因为 JSON object 无序.

2.3.5.2.1. Existence Tests (存在性检测)

单独处于 logical context 中的查询是存在性检测: 若查询至少选择一个节点则为 true, 若未选择任何节点则为 false.

存在性检测与比较的区别在于:

• 适用于任意相对或绝对查询 (不仅 singular query).

• 适用于选择 structured values 的查询.

要检查查询所选节点的值, 需要显式比较. 例如, 要检测查询 @.foo 所选节点是否为 null, 应使用 @.foo == null (见第 2.6 节), 而非否定的存在性检测 [email protected] (若 @.foo 选中节点则为 false, 与节点值无关). 类似地, @.foo == false 仅当 @.foo 选中节点且该节点值为 false 时为 true.

2.3.5.2.2. Comparisons (比较)

先定义比较运算符 == 与 <, 再用其定义 !=, <=, >, >=.

当比较的任一侧产生 empty nodelist 或特殊结果 Nothing (见第 2.4.1 节) 时:

• 使用 == 的比较当且仅当另一侧也产生 empty nodelist 或特殊结果 Nothing 时为 true.

• 使用 < 的比较为 false.

当任一侧的查询或 function expression 产生由单个节点组成的 nodelist 时, 该侧替换为其节点的值, 然后:

• 使用 == 的比较当且仅当比较发生在以下情形之间时为 true:

• 按 I-JSON [RFC7493] 第 2.2 节预期可互操作的 number, 使用通常数学相等性比较相等,

• number, 其中至少一个按 I-JSON 预期不可互操作, 使用实现相关相等性比较相等,

• 相等的非 number primitive values,

• 相等的 array, 即等长且第一个 array 的每个元素与第二个 array 对应元素相等,

• 无 duplicate names 的相等 object, 即:

o 两个 object 具有相同的名称集合 (无重复) 且

o 对这些名称中的每一个, 两个 object 关联的值相等.

• 使用 < 的比较当且仅当比较双方均为 number 或均为 string 且满足比较时为 true:

• 按 I-JSON [RFC7493] 第 2.2 节预期可互操作的 number 必须使用通常数学序比较; 按 I-JSON 预期不可互操作的 number 可以使用实现相关序比较,

• empty string 小于任何非 empty string,

• 非 empty string 小于另一非 empty string 当且仅当第一个 string 以比第二个更低的 Unicode scalar value 开头, 或二者以相同 Unicode scalar value 开头且第一个 string 的剩余部分小于第二个的剩余部分.

!=, <=, >, >= 用其他比较运算符定义. 对任意 a 与 b:

• a != b 当且仅当 a == b 为 false 时为 true.

• a <= b 当且仅当 a < b 为 true 或 a == b 为 true 时为 true.

• a > b 当且仅当 b < a 为 true 时为 true.

• a >= b 当且仅当 b < a 为 true 或 a == b 为 true 时为 true.

2.3.5.3. Examples (示例)

第一组示例展示若干 comparison expression 及给定 JSON 值输入下的结果.

JSON:

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

Comparisons:

Comparison	Result	Comment
$.absent1 == $.absent2	true	Empty nodelists
$.absent1 <= $.absent2	true	== implies <=
$.absent == 'g'	false	Empty nodelist
$.absent1 != $.absent2	false	Empty nodelists
$.absent != 'g'	true	Empty nodelist
1 <= 2	true	数值比较
1 > 2	false	数值比较
13 == '13'	false	类型不匹配
'a' <= 'b'	true	字符串比较
'a' > 'b'	false	字符串比较
$.obj == $.arr	false	类型不匹配
$.obj != $.arr	true	类型不匹配
$.obj == $.obj	true	Object 比较
$.obj != $.obj	false	Object 比较
$.arr == $.arr	true	Array 比较
$.arr != $.arr	false	Array 比较
$.obj == 17	false	类型不匹配
$.obj != 17	true	类型不匹配
$.obj <= $.arr	false	Object 与 array
		不提供 < 比较
$.obj < $.arr	false	Object 与 array
		不提供 < 比较
$.obj <= $.obj	true	== implies <=
$.arr <= $.arr	true	== implies <=
1 <= $.arr	false	Array 不提供 <
		比较
1 >= $.arr	false	Array 不提供 <
		比较
1 > $.arr	false	Array 不提供 <
		比较
1 < $.arr	false	Array 不提供 <
		比较
true <= true	true	== implies <=
true > true	false	Boolean 不提供
		< 比较

表 11: Comparison 示例

第二组示例展示若干使用 filter selector 的完整 JSONPath 查询及在给定 JSON 值输入下求值的结果. (注意: 其中两个查询使用 function extensions; 详见第 2.4.6 与 2.4.7 节.)

JSON:

{
  "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"
}

Queries:

表 12 的示例展示 child segment 中的 filter selector.

Query	Result	Result Paths	Comment
$.a[[email protected] == 'kilo']	{"b": "kilo"}	$['a'][9]	成员值比较
$.a[?(@.b == 'kilo')]	{"b": "kilo"}	$['a'][9]	带外层括号的等价查询
$.a[?@>3.5]	5, 4, 6	$['a'][1], $['a'][4], $['a'][5]	Array 元素值比较
$.a[[email protected]]	{"b": "j"}, {"b": "k"}, {"b": {}}, {"b": "kilo"}	$['a'][6], $['a'][7], $['a'][8], $['a'][9]	Array 元素存在性
$[?@.*]	同 RFC 的 array 与 object	$['a'], $['o']	非 singular 查询的存在性
$[?@[[email protected]]]	同 RFC 的 array	$['a']	嵌套 filter
$.o[?@<3, ?@<3]	1, 2 (顺序可变)	$['o']['p'], $['o']['q']	非确定顺序
$.a[?@<2 || @.b == "k"]	1, {"b": "k"}	$['a'][2], $['a'][7]	Array 元素逻辑 OR
$.a[?match(@.b, "[jk]")]	{"b": "j"}, {"b": "k"}	$['a'][6], $['a'][7]	Array 元素正则全匹配
$.a[?search(@.b, "[jk]")]	{"b": "j"}, {"b": "k"}, {"b": "kilo"}	$['a'][6], $['a'][7], $['a'][9]	Array 元素正则子串搜索
$.o[?@>1 && @<4]	2, 3	$['o']['q'], $['o']['r']	Object 成员值逻辑 AND
$.o[?@>1 && @<4] (alternative)	3, 2	$['o']['r'], $['o']['q']	另一种结果顺序
$.o[[email protected] || @.x]	{"u": 6}	$['o']['t']	Object 成员值逻辑 OR
$.a[[email protected] == $.x]	3, 5, 1, 2, 4, 6	$['a'][0] through $['a'][5]	与无值查询比较
$.a[?@ == @]	同 RFC 的 primitive 与 structured 值	$['a'][0] through $['a'][9]	Primitive 与 structured 值的自比较

表 12: Filter Selector 示例

上述查询 $.o[?@<3, ?@<3] 的示例表明, filter selector 在 child segment 中每次出现都可能产生不同顺序的 nodelist.