本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 支援的 Valkey 和 Redis OSS 命令
ElastiCache 支援下列 Valkey 和 Redis OSS JSON 命令：
**Topics**
+ [
# JSON.ARRAPPEND
](json-arrappend.md)
+ [
# JSON.ARRINDEX
](json-arrindex.md)
+ [
# JSON.ARRINSERT
](json-arrinsert.md)
+ [
# JSON.ARRLEN
](json-arrlen.md)
+ [
# JSON.ARRPOP
](json-arrpop.md)
+ [
# JSON.ARRTRIM
](json-arrtrim.md)
+ [
# JSON.CLEAR
](json-clear.md)
+ [
# JSON.DEBUG
](json-debug.md)
+ [
# JSON.DEL
](json-del.md)
+ [
# JSON.FORGET
](json-forget.md)
+ [
# JSON.GET
](json-get.md)
+ [
# JSON.MGET
](json-mget.md)
+ [
# JSON.MSET
](json-mset.md)
+ [
# JSON.NUMINCRBY
](json-numincrby.md)
+ [
# JSON.NUMMULTBY
](json-nummultby.md)
+ [
# JSON.OBJLEN
](json-objlen.md)
+ [
# JSON.OBJKEYS
](json-objkeys.md)
+ [
# JSON.RESP
](json-resp.md)
+ [
# JSON.SET
](json-set.md)
+ [
# JSON.STRAPPEND
](json-strappend.md)
+ [
# JSON.STRLEN
](json-strlen.md)
+ [
# JSON.TOGGLE
](json-toggle.md)
+ [
# JSON.TYPE
](json-type.md)
# JSON.ARRAPPEND
將一或多個值附加到路徑中的陣列值。
語法
```
JSON.ARRAPPEND [json ...]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (必要) – JSON 路徑。
+ json (必要) – 要附加至陣列的 JSON 值。
**傳回**
如果路徑是增強型語法：
+ 整數陣列代表每個路徑的新陣列長度。
+ 如果值不是陣列，其相應的傳回值為 null。
+ 如果沒有路徑，會發生 `NONEXISTENT` 錯誤。
如果路徑是受限語法：
+ 整數，新陣列長度。
+ 如果選取多個陣列值，命令會傳回第一個更新陣列的新長度。
+ 如果路徑上的值不是陣列，會發生 `WRONGTYPE` 錯誤。
+ 如果輸入 json 引數之一不是有效的 JSON 字串，會發生 `SYNTAXERR` 錯誤。
+ 如果沒有路徑，會發生 `NONEXISTENT` 錯誤。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRAPPEND k1 $[*] '"c"'
1) (integer) 1
2) (integer) 2
3) (integer) 3
127.0.0.1:6379> JSON.GET k1
"[[\"c\"],[\"a\",\"c\"],[\"a\",\"b\",\"c\"]]"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRAPPEND k1 [-1] '"c"'
(integer) 3
127.0.0.1:6379> JSON.GET k1
"[[],[\"a\"],[\"a\",\"b\",\"c\"]]"
```
# JSON.ARRINDEX
搜尋路徑的陣列中第一個純量 JSON 值。
+ 將索引四捨五入到陣列的開頭和結尾，處理超出範圍的錯誤。
+ 如果開頭 > 結尾，傳回 -1 (找不到)。
語法
```
JSON.ARRINDEX [start [end]]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (必要) – JSON 路徑。
+ json-scalar (必要) – 要搜尋的純量值。JSON 純量是指不是物件或陣列的值。也就是說，字串、數字、布林值和 null 是純量值。
+ start (選用) – 開頭索引，包含。如果未提供，預設為 0。
+ end (選用) - 結束索引，排除。如果未提供，預設為 0，表示包含最後一個元素。0 或 -1 表示包含最後一個元素。
**傳回**
如果路徑是增強型語法：
+ 整數陣列。每個值都是路徑的陣列中相符元素的索引。如果找不到，則值為 -1。
+ 如果值不是陣列，其相應的傳回值為 null。
如果路徑是受限語法：
+ 如果找不到，則為整數、相符元素的索引或 -1。
+ 如果路徑上的值不是陣列，會發生 `WRONGTYPE` 錯誤。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRINDEX k1 $[*] '"b"'
1) (integer) -1
2) (integer) -1
3) (integer) 1
4) (integer) 1
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"children": ["John", "Jack", "Tom", "Bob", "Mike"]}'
OK
127.0.0.1:6379> JSON.ARRINDEX k1 .children '"Tom"'
(integer) 2
```
# JSON.ARRINSERT
將一或多個值插入索引前路徑的陣列值。
語法
```
JSON.ARRINSERT [json ...]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (必要) – JSON 路徑。
+ index (必要) – 插入值之前的陣列索引。
+ json (必要) – 要附加至陣列的 JSON 值。
**傳回**
如果路徑是增強型語法：
+ 整數陣列代表每個路徑的新陣列長度。
+ 如果值是空陣列，其相應的傳回值為 null。
+ 如果值不是陣列，其相應的傳回值為 null。
+ 如果索引引數超出範圍，會發生 `OUTOFBOUNDARIES` 錯誤。
如果路徑是受限語法：
+ 整數，新陣列長度。
+ 如果路徑上的值不是陣列，會發生 `WRONGTYPE` 錯誤。
+ 如果索引引數超出範圍，會發生 `OUTOFBOUNDARIES` 錯誤。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRINSERT k1 $[*] 0 '"c"'
1) (integer) 1
2) (integer) 2
3) (integer) 3
127.0.0.1:6379> JSON.GET k1
"[[\"c\"],[\"c\",\"a\"],[\"c\",\"a\",\"b\"]]"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRINSERT k1 . 0 '"c"'
(integer) 4
127.0.0.1:6379> JSON.GET k1
"[\"c\",[],[\"a\"],[\"a\",\"b\"]]"
```
# JSON.ARRLEN
取得路徑上陣列值的長度。
語法
```
JSON.ARRLEN [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
**傳回**
如果路徑是增強型語法：
+ 整數陣列代表每個路徑的陣列長度。
+ 如果值不是陣列，其相應的傳回值為 null。
+ 如果沒有文件索引鍵，則為 null。
如果路徑是受限語法：
+ 整數，陣列長度。
+ 如果選取多個物件，命令會傳回第一個陣列的長度。
+ 如果路徑上的值不是陣列，會發生 `WRONGTYPE` 錯誤。
+ 如果沒有路徑，會發生 `NONEXISTENT JSON` 錯誤。
+ 如果沒有文件索引鍵，則為 null。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRLEN k1 $[*]
1) (integer) 0
2) (integer) 1
3) (integer) 2
4) (integer) 3
127.0.0.1:6379> JSON.SET k2 . '[[], "a", ["a", "b"], ["a", "b", "c"], 4]'
OK
127.0.0.1:6379> JSON.ARRLEN k2 $[*]
1) (integer) 0
2) (nil)
3) (integer) 2
4) (integer) 3
5) (nil)
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRLEN k1 [*]
(integer) 0
127.0.0.1:6379> JSON.ARRLEN k1 [1]
(integer) 1
127.0.0.1:6379> JSON.ARRLEN k1 [2]
(integer) 2
127.0.0.1:6379> JSON.SET k2 . '[[], "a", ["a", "b"], ["a", "b", "c"], 4]'
OK
127.0.0.1:6379> JSON.ARRLEN k2 [1]
(error) WRONGTYPE JSON element is not an array
127.0.0.1:6379> JSON.ARRLEN k2 [0]
(integer) 0
127.0.0.1:6379> JSON.ARRLEN k2 [6]
(error) OUTOFBOUNDARIES Array index is out of bounds
127.0.0.1:6379> JSON.ARRLEN k2 a.b
(error) NONEXISTENT JSON path does not exist
```
# JSON.ARRPOP
移除並傳回陣列索引的元素。彈出空陣列會傳回 null。
語法
```
JSON.ARRPOP [path [index]]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
+ index (選用) – 開始彈出的陣列位置。
+ 如果未提供，預設為 -1，表示最後一個元素。
+ 負值表示從最後一個元素數起的位置。
+ 超出範圍的索引會四捨五入到各自的陣列範圍。
**傳回**
如果路徑是增強型語法：
+ 大量字串陣列代表每個路徑的彈出值。
+ 如果值是空陣列，其相應的傳回值為 null。
+ 如果值不是陣列，其相應的傳回值為 null。
如果路徑是受限語法：
+ 大量字串，代表彈出的 JSON 值。
+ 如果陣列是空的，則為 null。
+ 如果路徑上的值不是陣列，會發生 `WRONGTYPE` 錯誤。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRPOP k1 $[*]
1) (nil)
2) "\"a\""
3) "\"b\""
127.0.0.1:6379> JSON.GET k1
"[[],[],[\"a\"]]"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRPOP k1
"[\"a\",\"b\"]"
127.0.0.1:6379> JSON.GET k1
"[[],[\"a\"]]"
127.0.0.1:6379> JSON.SET k2 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRPOP k2 . 0
"[]"
127.0.0.1:6379> JSON.GET k2
"[[\"a\"],[\"a\",\"b\"]]"
```
# JSON.ARRTRIM
修剪路徑上的陣列，使其成為子陣列 [start, end]，都包含在內。
+ 如果陣列是空的，不必做任何事，會傳回 0。
+ 如果開頭 <0，則將其視為 0。
+ 如果結尾 >= 大小 (陣列的大小)，則將其視為 size-1。
+ 如果開頭 >= 大小或開頭 > 結尾，清空陣列並傳回 0。
語法
```
JSON.ARRTRIM
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (必要) – JSON 路徑。
+ start (必要) – 開頭索引，包含。
+ end (必要) – 結束索引，包含。
**傳回**
如果路徑是增強型語法：
+ 整數陣列代表每個路徑的新陣列長度。
+ 如果值是空陣列，其相應的傳回值為 null。
+ 如果值不是陣列，其相應的傳回值為 null。
+ 如果索引引數超出範圍，會發生 `OUTOFBOUNDARIES` 錯誤。
如果路徑是受限語法：
+ 整數，新陣列長度。
+ 如果陣列是空的，則為 null。
+ 如果路徑上的值不是陣列，會發生 `WRONGTYPE` 錯誤。
+ 如果索引引數超出範圍，會發生 `OUTOFBOUNDARIES` 錯誤。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRTRIM k1 $[*] 0 1
1) (integer) 0
2) (integer) 1
3) (integer) 2
4) (integer) 2
127.0.0.1:6379> JSON.GET k1
"[[],[\"a\"],[\"a\",\"b\"],[\"a\",\"b\"]]"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"children": ["John", "Jack", "Tom", "Bob", "Mike"]}'
OK
127.0.0.1:6379> JSON.ARRTRIM k1 .children 0 1
(integer) 2
127.0.0.1:6379> JSON.GET k1 .children
"[\"John\",\"Jack\"]"
```
# JSON.CLEAR
清除陣列或路徑上的物件。
語法
```
JSON.CLEAR [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
**傳回**
+ 整數，已清除的容器數目。
+ 清除一個空陣列或物件計為清除 1 個容器。
+ 清除非容器值會傳回 0。
**範例**
```
127.0.0.1:6379> JSON.SET k1 . '[[], [0], [0,1], [0,1,2], 1, true, null, "d"]'
OK
127.0.0.1:6379> JSON.CLEAR k1 $[*]
(integer) 7
127.0.0.1:6379> JSON.CLEAR k1 $[*]
(integer) 4
127.0.0.1:6379> JSON.SET k2 . '{"children": ["John", "Jack", "Tom", "Bob", "Mike"]}'
OK
127.0.0.1:6379> JSON.CLEAR k2 .children
(integer) 1
127.0.0.1:6379> JSON.GET k2 .children
"[]"
```
# JSON.DEBUG
報告資訊。支援的子命令如下：
+ MEMORY [path] – 報告 JSON 值的記憶體使用量 (以位元組為單位)。如果未提供，路徑預設為根。
+ FIELDS [path] – 報告指定文件路徑的欄位數目。如果未提供，路徑預設為根。每個非容器 JSON 值都計為一個欄位。物件和陣列遞迴計為每個內含 JSON 值的一個欄位。除根容器外，每個容器值都計為一個附加欄位。
+ HELP – 列印命令的說明訊息。
語法
```
JSON.DEBUG
```
取決於子命令：
MEMORY
+ 如果路徑是增強型語法：
+ 傳回整數陣列，代表每個路徑上的 JSON 值記憶體大小 (以位元組為單位)。
+ 如果 Valkey 或 Redis OSS 金鑰不存在，則傳回空陣列。
+ 如果路徑是受限語法：
+ 傳回整數、記憶體大小，以及 JSON 值 (以位元組為單位)。
+ 如果 Valkey 或 Redis OSS 金鑰不存在，則傳回 null。
FIELDS
+ 如果路徑是增強型語法：
+ 傳回整數陣列，代表每個路徑上的 JSON 值欄位數量。
+ 如果 Valkey 或 Redis OSS 金鑰不存在，則傳回空陣列。
+ 如果路徑是受限語法：
+ 傳回整數，JSON 值的欄位數量。
+ 如果 Valkey 或 Redis OSS 金鑰不存在，則傳回 null。
HELP – 傳回說明訊息的陣列。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[1, 2.3, "foo", true, null, {}, [], {"a":1, "b":2}, [1,2,3]]'
OK
127.0.0.1:6379> JSON.DEBUG MEMORY k1 $[*]
1) (integer) 16
2) (integer) 16
3) (integer) 19
4) (integer) 16
5) (integer) 16
6) (integer) 16
7) (integer) 16
8) (integer) 50
9) (integer) 64
127.0.0.1:6379> JSON.DEBUG FIELDS k1 $[*]
1) (integer) 1
2) (integer) 1
3) (integer) 1
4) (integer) 1
5) (integer) 1
6) (integer) 0
7) (integer) 0
8) (integer) 2
9) (integer) 3
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.DEBUG MEMORY k1
(integer) 632
127.0.0.1:6379> JSON.DEBUG MEMORY k1 .phoneNumbers
(integer) 166
127.0.0.1:6379> JSON.DEBUG FIELDS k1
(integer) 19
127.0.0.1:6379> JSON.DEBUG FIELDS k1 .address
(integer) 4
127.0.0.1:6379> JSON.DEBUG HELP
1) JSON.DEBUG MEMORY [path] - report memory size (bytes) of the JSON element. Path defaults to root if not provided.
2) JSON.DEBUG FIELDS [path] - report number of fields in the JSON element. Path defaults to root if not provided.
3) JSON.DEBUG HELP - print help message.
```
# JSON.DEL
刪除文件索引鍵中路徑上的 JSON 值。如果路徑是根，則相當於從 Valkey 或 Redis OSS 刪除金鑰。
語法
```
JSON.DEL [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
**傳回**
+ 刪除的元素數目。
+ 如果 Valkey 或 Redis OSS 金鑰不存在，則為 0。
+ 如果 JSON 路徑無效或不存在，則為 0。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}, "e": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.DEL k1 $.d.*
(integer) 3
127.0.0.1:6379> JSOn.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[1,2,3,4,5]}"
127.0.0.1:6379> JSON.DEL k1 $.e[*]
(integer) 5
127.0.0.1:6379> JSOn.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[]}"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}, "e": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.DEL k1 .d.*
(integer) 3
127.0.0.1:6379> JSON.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[1,2,3,4,5]}"
127.0.0.1:6379> JSON.DEL k1 .e[*]
(integer) 5
127.0.0.1:6379> JSON.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[]}"
```
# JSON.FORGET
[JSON.DEL](json-del.md) 的別名。
# JSON.GET
在一或多個路徑傳回序列化 JSON。
語法
```
JSON.GET
[INDENT indentation-string]
[NEWLINE newline-string]
[SPACE space-string]
[NOESCAPE]
[path ...]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ INDENT/NEWLINE/SPACE (選用) – 控制傳回 JSON 字串的格式，即「漂亮列印」。個別預設值為空字串。可在任何組合中覆寫。可以按任何順序指定。
+ NOESCAPE - 選用，允許顯示以相容舊版，且沒有其他效果。
+ path (選用) – 零個或更多 JSON 路徑，如果提供 none，則預設為根。路徑引數必須放在最後。
**傳回**
增強型路徑語法：
如果提供一個路徑：
+ 傳回值陣列的序列化字串。
+ 如果未選取任何值，此命令會傳回空陣列。
如果提供多個路徑：
+ 傳回字串化 JSON 物件，其中每個路徑都是索引鍵。
+ 如果混合增強型和受限路徑語法，結果會按照增強型語法。
+ 如果沒有路徑，則其對應的值會是空陣列。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.GET k1 $.address.*
"[\"21 2nd Street\",\"New York\",\"NY\",\"10021-3100\"]"
127.0.0.1:6379> JSON.GET k1 indent "\t" space " " NEWLINE "\n" $.address.*
"[\n\t\"21 2nd Street\",\n\t\"New York\",\n\t\"NY\",\n\t\"10021-3100\"\n]"
127.0.0.1:6379> JSON.GET k1 $.firstName $.lastName $.age
"{\"$.firstName\":[\"John\"],\"$.lastName\":[\"Smith\"],\"$.age\":[27]}"
127.0.0.1:6379> JSON.SET k2 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}}'
OK
127.0.0.1:6379> json.get k2 $..*
"[{},{\"a\":1},{\"a\":1,\"b\":2},1,1,2]"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.GET k1 .address
"{\"street\":\"21 2nd Street\",\"city\":\"New York\",\"state\":\"NY\",\"zipcode\":\"10021-3100\"}"
127.0.0.1:6379> JSON.GET k1 indent "\t" space " " NEWLINE "\n" .address
"{\n\t\"street\": \"21 2nd Street\",\n\t\"city\": \"New York\",\n\t\"state\": \"NY\",\n\t\"zipcode\": \"10021-3100\"\n}"
127.0.0.1:6379> JSON.GET k1 .firstName .lastName .age
"{\".firstName\":\"John\",\".lastName\":\"Smith\",\".age\":27}"
```
# JSON.MGET
取得多個文件索引鍵的路徑上序列化 JSON。這會針對不存在的索引鍵或 JSON 路徑，傳回 null。
**語法**
```
JSON.MGET [key ...]
```
+ 金鑰 （必要） – 文件類型的一或多個 Valkey 或 Redis OSS 金鑰。
+ path (必要) – JSON 路徑。
**傳回**
+ 大量字串陣列。陣列的大小等於命令中的索引鍵數量。陣列的每個元素都填入 (a) 路徑定位的序列化 JSON，或 (b) 如果沒有索引鍵、文件中沒有路徑，或路徑無效 (語法錯誤)，則為 null。
+ 如果有任何指定的索引鍵，且不是 JSON 索引鍵，命令會傳回 `WRONGTYPE` 錯誤。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021"}}'
OK
127.0.0.1:6379> JSON.SET k2 . '{"address":{"street":"5 main Street","city":"Boston","state":"MA","zipcode":"02101"}}'
OK
127.0.0.1:6379> JSON.SET k3 . '{"address":{"street":"100 Park Ave","city":"Seattle","state":"WA","zipcode":"98102"}}'
OK
127.0.0.1:6379> JSON.MGET k1 k2 k3 $.address.city
1) "[\"New York\"]"
2) "[\"Boston\"]"
3) "[\"Seattle\"]"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021"}}'
OK
127.0.0.1:6379> JSON.SET k2 . '{"address":{"street":"5 main Street","city":"Boston","state":"MA","zipcode":"02101"}}'
OK
127.0.0.1:6379> JSON.SET k3 . '{"address":{"street":"100 Park Ave","city":"Seattle","state":"WA","zipcode":"98102"}}'
OK
127.0.0.1:6379> JSON.MGET k1 k2 k3 .address.city
1) "\"New York\""
2) "\"Seattle\""
3) "\"Seattle\""
```
# JSON.MSET
支援 Valkey 8.1 版和更新版本。
設定多個金鑰的 JSON 值。操作是原子的。已設定所有值或未設定任何值。
**語法**
```
JSON.MSET key path json [ key path json ... ]
```
+ 如果路徑呼叫物件成員：
+ 如果父元素不存在，命令將傳回 NONEXISTENT 錯誤。
+ 如果父元素存在，但不是物件，則命令會傳回 ERROR。
+ 如果有父元素且為物件：
+ 如果沒有成員，只會在父物件是路徑中的最後一個子系時，將新成員附加至父物件。否則，命令將傳回 NONEXISTENT 錯誤。
+ 如果有該成員，其值將以 JSON 值取代。
+ 如果路徑呼叫陣列索引：
+ 如果父元素不存在，命令將傳回 NONEXISTENT 錯誤。
+ 如果父元素存在，但不是陣列，則命令會傳回 ERROR。
+ 如果父元素存在，但索引超出範圍，則命令將傳回 OUTOFBOUNDARIES 錯誤。
+ 如果有父元素且索引有效，該元素將以新的 JSON 值取代。
+ 如果路徑呼叫物件或陣列，該值 (物件或陣列) 將以新的 JSON 值取代。
**傳回**
+ 簡易字串回覆：如果操作成功，則為「OK」。
+ 簡單錯誤回覆：如果操作失敗。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.MSET k1 . '[1,2,3,4,5]' k2 . '{"a":{"a":1, "b":2, "c":3}}' k3 . '{"a": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.GET k1
"[1,2,3,4,5]"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.MSET k2 $.a.* '0' k3 $.a[*] '0'
OK
127.0.0.1:6379> JSON.GET k2
"{\"a\":{\"a\":0,\"b\":0,\"c\":0}}"
127.0.0.1:6379> JSON.GET k3
"{\"a\":[0,0,0,0,0]}"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.MSET k1 . '{"name": "John","address": {"street": "123 Main St","city": "Springfield"},"phones": ["555-1234","555-5678"]}'
OK
127.0.0.1:6379> JSON.MSET k1 .address.street '"21 2nd Street"' k1 .address.city '"New York"'
OK
127.0.0.1:6379> JSON.GET k1 .address.street
"\"21 2nd Street\""
127.0.0.1:6379> JSON.GET k1 .address.city
"\"New York\""
```
# JSON.NUMINCRBY
以指定的數字增加路徑上的數值。
語法
```
JSON.NUMINCRBY
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (必要) – JSON 路徑。
+ number (必要) – 數字。
**傳回**
如果路徑是增強型語法：
+ 大量字串陣列代表每個路徑上產生的值。
+ 如果值不是數字，則其對應的傳回值為 null。
+ 如果無法剖析數字，會發生 `WRONGTYPE` 錯誤。
+ 如果結果超出 64 位元 IEEE 雙精確度的範圍，會發生 `OVERFLOW` 錯誤。
+ 如果沒有文件索引鍵，則為 `NONEXISTENT`。
如果路徑是受限語法：
+ 大量字串代表結果值。
+ 如果選取多個值，命令會傳回上次所更新值的結果。
+ 如果路徑上的值不是數字，會發生 `WRONGTYPE` 錯誤。
+ 如果無法剖析數字，會發生 `WRONGTYPE` 錯誤。
+ 如果結果超出 64 位元 IEEE 雙精確度的範圍，會發生 `OVERFLOW` 錯誤。
+ 如果沒有文件索引鍵，則為 `NONEXISTENT`。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 $.d[*] 10
"[11,12,13]"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[11,12,13]}"
127.0.0.1:6379> JSON.SET k1 $ '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 $.a[*] 1
"[]"
127.0.0.1:6379> JSON.NUMINCRBY k1 $.b[*] 1
"[2]"
127.0.0.1:6379> JSON.NUMINCRBY k1 $.c[*] 1
"[2,3]"
127.0.0.1:6379> JSON.NUMINCRBY k1 $.d[*] 1
"[2,3,4]"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,3],\"d\":[2,3,4]}"
127.0.0.1:6379> JSON.SET k2 $ '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k2 $.a.* 1
"[]"
127.0.0.1:6379> JSON.NUMINCRBY k2 $.b.* 1
"[2]"
127.0.0.1:6379> JSON.NUMINCRBY k2 $.c.* 1
"[2,3]"
127.0.0.1:6379> JSON.NUMINCRBY k2 $.d.* 1
"[2,3,4]"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":3},\"d\":{\"a\":2,\"b\":3,\"c\":4}}"
127.0.0.1:6379> JSON.SET k3 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k3 $.a.* 1
"[null]"
127.0.0.1:6379> JSON.NUMINCRBY k3 $.b.* 1
"[null,2]"
127.0.0.1:6379> JSON.NUMINCRBY k3 $.c.* 1
"[null,null]"
127.0.0.1:6379> JSON.NUMINCRBY k3 $.d.* 1
"[2,null,4]"
127.0.0.1:6379> JSON.GET k3
"{\"a\":{\"a\":\"a\"},\"b\":{\"a\":\"a\",\"b\":2},\"c\":{\"a\":\"a\",\"b\":\"b\"},\"d\":{\"a\":2,\"b\":\"b\",\"c\":4}}"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 .d[1] 10
"12"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[1,12,3]}"
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 .a[*] 1
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMINCRBY k1 .b[*] 1
"2"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[1,2],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMINCRBY k1 .c[*] 1
"3"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,3],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMINCRBY k1 .d[*] 1
"4"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,3],\"d\":[2,3,4]}"
127.0.0.1:6379> JSON.SET k2 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k2 .a.* 1
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMINCRBY k2 .b.* 1
"2"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":1,\"b\":2},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMINCRBY k2 .c.* 1
"3"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":3},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMINCRBY k2 .d.* 1
"4"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":3},\"d\":{\"a\":2,\"b\":3,\"c\":4}}"
127.0.0.1:6379> JSON.SET k3 . '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k3 .a.* 1
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMINCRBY k3 .b.* 1
"2"
127.0.0.1:6379> JSON.NUMINCRBY k3 .c.* 1
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMINCRBY k3 .d.* 1
"4"
```
# JSON.NUMMULTBY
以指定數字乘於路徑上的數值。
語法
```
JSON.NUMMULTBY
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (必要) – JSON 路徑。
+ number (必要) – 數字。
**傳回**
如果路徑是增強型語法：
+ 大量字串陣列代表每個路徑上產生的值。
+ 如果值不是數字，則其對應的傳回值為 null。
+ 如果無法剖析數字，會發生 `WRONGTYPE` 錯誤。
+ 如果結果超出 64 位元 IEEE 雙精確度浮點數範圍，會發生 `OVERFLOW` 錯誤。
+ 如果沒有文件索引鍵，則為 `NONEXISTENT`。
如果路徑是受限語法：
+ 大量字串代表結果值。
+ 如果選取多個值，命令會傳回上次所更新值的結果。
+ 如果路徑上的值不是數字，會發生 `WRONGTYPE` 錯誤。
+ 如果無法剖析數字，會發生 `WRONGTYPE` 錯誤。
+ 如果結果超出 64 位元 IEEE 雙精確度範圍，會發生 `OVERFLOW` 錯誤。
+ 如果沒有文件索引鍵，則為 `NONEXISTENT`。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 $.d[*] 2
"[2,4,6]"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[2,4,6]}"
127.0.0.1:6379> JSON.SET k1 $ '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 $.a[*] 2
"[]"
127.0.0.1:6379> JSON.NUMMULTBY k1 $.b[*] 2
"[2]"
127.0.0.1:6379> JSON.NUMMULTBY k1 $.c[*] 2
"[2,4]"
127.0.0.1:6379> JSON.NUMMULTBY k1 $.d[*] 2
"[2,4,6]"
127.0.0.1:6379> JSON.SET k2 $ '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k2 $.a.* 2
"[]"
127.0.0.1:6379> JSON.NUMMULTBY k2 $.b.* 2
"[2]"
127.0.0.1:6379> JSON.NUMMULTBY k2 $.c.* 2
"[2,4]"
127.0.0.1:6379> JSON.NUMMULTBY k2 $.d.* 2
"[2,4,6]"
127.0.0.1:6379> JSON.SET k3 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k3 $.a.* 2
"[null]"
127.0.0.1:6379> JSON.NUMMULTBY k3 $.b.* 2
"[null,2]"
127.0.0.1:6379> JSON.NUMMULTBY k3 $.c.* 2
"[null,null]"
127.0.0.1:6379> JSON.NUMMULTBY k3 $.d.* 2
"[2,null,6]"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 .d[1] 2
"4"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[1,4,3]}"
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 .a[*] 2
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMMULTBY k1 .b[*] 2
"2"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[1,2],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMMULTBY k1 .c[*] 2
"4"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,4],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMMULTBY k1 .d[*] 2
"6"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,4],\"d\":[2,4,6]}"
127.0.0.1:6379> JSON.SET k2 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k2 .a.* 2
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMMULTBY k2 .b.* 2
"2"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":1,\"b\":2},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMMULTBY k2 .c.* 2
"4"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":4},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMMULTBY k2 .d.* 2
"6"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":4},\"d\":{\"a\":2,\"b\":4,\"c\":6}}"
127.0.0.1:6379> JSON.SET k3 . '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k3 .a.* 2
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMMULTBY k3 .b.* 2
"2"
127.0.0.1:6379> JSON.GET k3
"{\"a\":{\"a\":\"a\"},\"b\":{\"a\":\"a\",\"b\":2},\"c\":{\"a\":\"a\",\"b\":\"b\"},\"d\":{\"a\":1,\"b\":\"b\",\"c\":3}}"
127.0.0.1:6379> JSON.NUMMULTBY k3 .c.* 2
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMMULTBY k3 .d.* 2
"6"
127.0.0.1:6379> JSON.GET k3
"{\"a\":{\"a\":\"a\"},\"b\":{\"a\":\"a\",\"b\":2},\"c\":{\"a\":\"a\",\"b\":\"b\"},\"d\":{\"a\":2,\"b\":\"b\",\"c\":6}}"
```
# JSON.OBJLEN
取得路徑上物件值中的索引鍵數目。
語法
```
JSON.OBJLEN [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
**傳回**
如果路徑是增強型語法：
+ 整數陣列代表每個路徑的物件長度。
+ 如果值不是物件，其相應的傳回值為 null。
+ 如果沒有文件索引鍵，則為 null。
如果路徑是受限語法：
+ 整數，物件中的索引鍵數目。
+ 如果選取多個物件，命令會傳回第一個物件的長度。
+ 如果路徑上的值不是物件，會發生 `WRONGTYPE` 錯誤。
+ 如果沒有路徑，會發生 `NONEXISTENT JSON` 錯誤。
+ 如果沒有文件索引鍵，則為 null。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJLEN k1 $.a
1) (integer) 0
127.0.0.1:6379> JSON.OBJLEN k1 $.a.*
(empty array)
127.0.0.1:6379> JSON.OBJLEN k1 $.b
1) (integer) 1
127.0.0.1:6379> JSON.OBJLEN k1 $.b.*
1) (nil)
127.0.0.1:6379> JSON.OBJLEN k1 $.c
1) (integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 $.c.*
1) (nil)
2) (nil)
127.0.0.1:6379> JSON.OBJLEN k1 $.d
1) (integer) 3
127.0.0.1:6379> JSON.OBJLEN k1 $.d.*
1) (nil)
2) (nil)
3) (integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 $.*
1) (integer) 0
2) (integer) 1
3) (integer) 2
4) (integer) 3
5) (nil)
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJLEN k1 .a
(integer) 0
127.0.0.1:6379> JSON.OBJLEN k1 .a.*
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.OBJLEN k1 .b
(integer) 1
127.0.0.1:6379> JSON.OBJLEN k1 .b.*
(error) WRONGTYPE JSON element is not an object
127.0.0.1:6379> JSON.OBJLEN k1 .c
(integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 .c.*
(error) WRONGTYPE JSON element is not an object
127.0.0.1:6379> JSON.OBJLEN k1 .d
(integer) 3
127.0.0.1:6379> JSON.OBJLEN k1 .d.*
(integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 .*
(integer) 0
```
# JSON.OBJKEYS
取得路徑上物件值中的索引鍵名稱。
語法
```
JSON.OBJKEYS [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
**傳回**
如果路徑是增強型語法：
+ 大量字串陣列。每個元素都是相符物件中的索引鍵陣列。
+ 如果值不是物件，其相應的傳回值是空白值。
+ 如果沒有文件索引鍵，則為 null。
如果路徑是受限語法：
+ 大量字串陣列。每個元素都是物件中的索引鍵名稱。
+ 如果選取多個物件，命令會傳回第一個物件的索引鍵。
+ 如果路徑上的值不是物件，會發生 `WRONGTYPE` 錯誤。
+ 如果沒有文件索引鍵，則為 null。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJKEYS k1 $.*
1) (empty array)
2) 1) "a"
3) 1) "a"
2) "b"
4) 1) "a"
2) "b"
3) "c"
5) (empty array)
127.0.0.1:6379> JSON.OBJKEYS k1 $.d
1) 1) "a"
2) "b"
3) "c"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJKEYS k1 .*
1) "a"
127.0.0.1:6379> JSON.OBJKEYS k1 .d
1) "a"
2) "b"
3) "c"
```
# JSON.RESP
傳回 Valkey 或 Redis OSS 序列化通訊協定 (RESP) 中指定路徑的 JSON 值。如果值是容器，回應為 RESP 陣列或巢狀陣列。
+ JSON null 映射至 RESP null 大量字串。
+ JSON 布林值映射至個別 RESP 簡單字串。
+ 整數映射至 RESP 整數。
+ 64 位 IEEE 雙精確度浮點數映射至 RESP 大量字串。
+ JSON 字串映射至 RESP 大量字串。
+ JSON 陣列表示為 RESP 陣列，其中第一個元素是簡單字串 [，接著字串的元素。
+ JSON 物件表示為 RESP 陣列，其中第一個元素是簡單字串 \$1，接著索引鍵值組，每個都是 RESP 大量字串。
語法
```
JSON.RESP [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
**傳回**
如果路徑是增強型語法：
+ 陣列的陣列。每個陣列元素呈現一個路徑上值的 RESP 形式。
+ 如果沒有文件索引鍵，則為空陣列。
如果路徑是受限語法：
+ 陣列代表路徑上值的 RESP 形式。
+ 如果沒有文件索引鍵，則為 null。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.RESP k1 $.address
1) 1) {
2) 1) "street"
2) "21 2nd Street"
3) 1) "city"
2) "New York"
4) 1) "state"
2) "NY"
5) 1) "zipcode"
2) "10021-3100"
127.0.0.1:6379> JSON.RESP k1 $.address.*
1) "21 2nd Street"
2) "New York"
3) "NY"
4) "10021-3100"
127.0.0.1:6379> JSON.RESP k1 $.phoneNumbers
1) 1) [
2) 1) {
2) 1) "type"
2) "home"
3) 1) "number"
2) "555 555-1234"
3) 1) {
2) 1) "type"
2) "office"
3) 1) "number"
2) "555 555-4567"
127.0.0.1:6379> JSON.RESP k1 $.phoneNumbers[*]
1) 1) {
2) 1) "type"
2) "home"
3) 1) "number"
2) "212 555-1234"
2) 1) {
2) 1) "type"
2) "office"
3) 1) "number"
2) "555 555-4567"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.RESP k1 .address
1) {
2) 1) "street"
2) "21 2nd Street"
3) 1) "city"
2) "New York"
4) 1) "state"
2) "NY"
5) 1) "zipcode"
2) "10021-3100"
127.0.0.1:6379> JSON.RESP k1
1) {
2) 1) "firstName"
2) "John"
3) 1) "lastName"
2) "Smith"
4) 1) "age"
2) (integer) 27
5) 1) "weight"
2) "135.25"
6) 1) "isAlive"
2) true
7) 1) "address"
2) 1) {
2) 1) "street"
2) "21 2nd Street"
3) 1) "city"
2) "New York"
4) 1) "state"
2) "NY"
5) 1) "zipcode"
2) "10021-3100"
8) 1) "phoneNumbers"
2) 1) [
2) 1) {
2) 1) "type"
2) "home"
3) 1) "number"
2) "212 555-1234"
3) 1) {
2) 1) "type"
2) "office"
3) 1) "number"
2) "555 555-4567"
9) 1) "children"
2) 1) [
10) 1) "spouse"
2) (nil)
```
# JSON.SET
設定路徑上的 JSON 值。
如果路徑呼叫物件成員：
+ 如果沒有父元素，該命令會傳回 NONEXISTENT 錯誤。
+ 如果有父元素但不是物件，該命令會傳回 ERROR。
+ 如果有父元素且為物件：
+ 如果沒有成員，只會在父物件是路徑中的最後一個子系時，將新成員附加至父物件。否則命令會傳回 NONEXISTENT 錯誤。
+ 如果有該成員，其值將以 JSON 值取代。
如果路徑呼叫陣列索引：
+ 如果沒有父元素，該命令會傳回 NONEXISTENT 錯誤。
+ 如果有父元素但不是陣列，該命令會傳回 ERROR。
+ 如果有父元素但索引超出範圍，該命令會傳回 OUTOFBOUNDARIES 錯誤。
+ 如果有父元素且索引有效，該元素將以新的 JSON 值取代。
如果路徑呼叫物件或陣列，該值 (物件或陣列) 將以新的 JSON 值取代。
語法
```
JSON.SET [NX | XX]
```
[NX \$1 XX] 您可以在其中有 0 或 1 個 [NX \$1 XX] 識別碼。
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (必要) – JSON 路徑。對於新金鑰，JSON 路徑必須是根 "."。
+ NX （選用） – 如果路徑是根，則只有在金鑰不存在時才設定值。也就是插入新文件。如果路徑不是根，請只在沒有路徑時才設定值。也就是將值插入文件中。
+ XX （選用） – 如果路徑是根，則只有在金鑰存在時才設定值。也就是取代現有文件。如果路徑不是根，請只在有路徑時才設定值。也就是更新現有值。
**傳回**
+ 成功時有簡單字串 'OK'。
+ 如果不符合 NX 或 XX 條件，即為 null。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.SET k1 $.a.* '0'
OK
127.0.0.1:6379> JSON.GET k1
"{\"a\":{\"a\":0,\"b\":0,\"c\":0}}"
127.0.0.1:6379> JSON.SET k2 . '{"a": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.SET k2 $.a[*] '0'
OK
127.0.0.1:6379> JSON.GET k2
"{\"a\":[0,0,0,0,0]}"
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"c":{"a":1, "b":2}, "e": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.SET k1 .c.a '0'
OK
127.0.0.1:6379> JSON.GET k1
"{\"c\":{\"a\":0,\"b\":2},\"e\":[1,2,3,4,5]}"
127.0.0.1:6379> JSON.SET k1 .e[-1] '0'
OK
127.0.0.1:6379> JSON.GET k1
"{\"c\":{\"a\":0,\"b\":2},\"e\":[1,2,3,4,0]}"
127.0.0.1:6379> JSON.SET k1 .e[5] '0'
(error) OUTOFBOUNDARIES Array index is out of bounds
```
# JSON.STRAPPEND
將字串附加到路徑上的 JSON 字串。
語法
```
JSON.STRAPPEND [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
+ json\$1string (必要) – 字串的 JSON 表示法。請注意，JSON 字串必須加上英文引號。例如：'"string example"'。
**傳回**
如果路徑是增強型語法：
+ 整數陣列代表字串在每個路徑的新長度。
+ 如果路徑上的值不是字符串，則其對應的傳回值為 null。
+ 如果輸入 json 引數不是有效 JSON 字串，會發生 `SYNTAXERR` 錯誤。
+ 如果沒有路徑，會發生 `NONEXISTENT` 錯誤。
如果路徑是受限語法：
+ 整數，字串的新長度。
+ 如果選取多個字串值，該命令會傳回上次所更新字串的新長度。
+ 如果路徑上的值不是字串，會發生 `WRONGTYPE` 錯誤。
+ 如果輸入 json 引數不是有效 JSON 字串，會發生 `WRONGTYPE` 錯誤。
+ 如果沒有路徑，會發生 `NONEXISTENT` 錯誤。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRAPPEND k1 $.a.a '"a"'
1) (integer) 2
127.0.0.1:6379> JSON.STRAPPEND k1 $.a.* '"a"'
1) (integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 $.b.* '"a"'
1) (integer) 2
2) (nil)
127.0.0.1:6379> JSON.STRAPPEND k1 $.c.* '"a"'
1) (integer) 2
2) (integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 $.c.b '"a"'
1) (integer) 4
127.0.0.1:6379> JSON.STRAPPEND k1 $.d.* '"a"'
1) (nil)
2) (integer) 2
3) (nil)
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRAPPEND k1 .a.a '"a"'
(integer) 2
127.0.0.1:6379> JSON.STRAPPEND k1 .a.* '"a"'
(integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 .b.* '"a"'
(integer) 2
127.0.0.1:6379> JSON.STRAPPEND k1 .c.* '"a"'
(integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 .c.b '"a"'
(integer) 4
127.0.0.1:6379> JSON.STRAPPEND k1 .d.* '"a"'
(integer) 2
```
# JSON.STRLEN
取得路徑上 JSON 字串值的長度。
語法
```
JSON.STRLEN [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
**傳回**
如果路徑是增強型語法：
+ 整數陣列代表每個路徑上的字串值長度。
+ 如果值不是字串，其對應的傳回值為 null。
+ 如果沒有文件索引鍵，則為 null。
如果路徑是受限語法：
+ 整數，字串的長度。
+ 如果選取多個字串值，該命令會傳回第一個字串的長度。
+ 如果路徑上的值不是字串，會發生 `WRONGTYPE` 錯誤。
+ 如果沒有路徑，會發生 `NONEXISTENT` 錯誤。
+ 如果沒有文件索引鍵，則為 null。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRLEN k1 $.a.a
1) (integer) 1
127.0.0.1:6379> JSON.STRLEN k1 $.a.*
1) (integer) 1
127.0.0.1:6379> JSON.STRLEN k1 $.c.*
1) (integer) 1
2) (integer) 2
127.0.0.1:6379> JSON.STRLEN k1 $.c.b
1) (integer) 2
127.0.0.1:6379> JSON.STRLEN k1 $.d.*
1) (nil)
2) (integer) 1
3) (nil)
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRLEN k1 .a.a
(integer) 1
127.0.0.1:6379> JSON.STRLEN k1 .a.*
(integer) 1
127.0.0.1:6379> JSON.STRLEN k1 .c.*
(integer) 1
127.0.0.1:6379> JSON.STRLEN k1 .c.b
(integer) 2
127.0.0.1:6379> JSON.STRLEN k1 .d.*
(integer) 1
```
# JSON.TOGGLE
在路徑上將布林值切換為 true 或 false。
語法
```
JSON.TOGGLE [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
**傳回**
如果路徑是增強型語法：
+ 整數陣列 (0 - false，1 - true)，代表每個路徑上產生的布林值。
+ 如果值不是布林值，其對應的傳回值為 null。
+ 如果沒有文件索引鍵，則為 `NONEXISTENT`。
如果路徑是受限語法：
+ 字串 ("true" / "false")，代表產生的布林值。
+ 如果沒有文件索引鍵，則為 `NONEXISTENT`。
+ 如果路徑上的值不是布林值，會發生 `WRONGTYPE` 錯誤。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"a":true, "b":false, "c":1, "d":null, "e":"foo", "f":[], "g":{}}'
OK
127.0.0.1:6379> JSON.TOGGLE k1 $.*
1) (integer) 0
2) (integer) 1
3) (nil)
4) (nil)
5) (nil)
6) (nil)
7) (nil)
127.0.0.1:6379> JSON.TOGGLE k1 $.*
1) (integer) 1
2) (integer) 0
3) (nil)
4) (nil)
5) (nil)
6) (nil)
7) (nil)
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . true
OK
127.0.0.1:6379> JSON.TOGGLE k1
"false"
127.0.0.1:6379> JSON.TOGGLE k1
"true"
127.0.0.1:6379> JSON.SET k2 . '{"isAvailable": false}'
OK
127.0.0.1:6379> JSON.TOGGLE k2 .isAvailable
"true"
127.0.0.1:6379> JSON.TOGGLE k2 .isAvailable
"false"
```
# JSON.TYPE
報告指定路徑上值的類型。
語法
```
JSON.TYPE [path]
```
+ key （必要） – JSON 文件類型的 Valkey 或 Redis OSS 金鑰。
+ path (選用) – JSON 路徑。如果未提供，則預設為根。
**傳回**
如果路徑是增強型語法：
+ 字串陣列代表每個路徑上值的類型。該類型是 \$1"null", "boolean", "string", "number", "integer", "object" and "array"\$1 之一。
+ 如果沒有路徑，其對應的傳回值為 null。
+ 如果沒有文件索引鍵，則為空陣列。
如果路徑是受限語法：
+ 字串，值的類型
+ 如果沒有文件索引鍵，則為 null。
+ 如果 JSON 路徑無效或不存在，則為 null。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[1, 2.3, "foo", true, null, {}, []]'
OK
127.0.0.1:6379> JSON.TYPE k1 $[*]
1) integer
2) number
3) string
4) boolean
5) null
6) object
7) array
```
受限路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.TYPE k1
object
127.0.0.1:6379> JSON.TYPE k1 .children
array
127.0.0.1:6379> JSON.TYPE k1 .firstName
string
127.0.0.1:6379> JSON.TYPE k1 .age
integer
127.0.0.1:6379> JSON.TYPE k1 .weight
number
127.0.0.1:6379> JSON.TYPE k1 .isAlive
boolean
127.0.0.1:6379> JSON.TYPE k1 .spouse
null
```