本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 支援的命令
支援下列 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.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 文件類型的金鑰
+ path （必要） – JSON 路徑
+ json （必要） – 要附加至陣列的 JSON 值
**傳回**
如果路徑是增強型語法：
+ 整數陣列，代表每個路徑上陣列的新長度。
+ 如果值不是陣列，其相應的傳回值為 null。
+ 如果輸入 json 引數之一不是有效的 JSON 字串，會發生 `SYNTAXERR` 錯誤。
+ 如果沒有路徑，會發生 `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 文件類型的金鑰
+ 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 文件類型的金鑰
+ 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 文件類型的金鑰
+ path （選用） – JSON 路徑。如果未提供，則預設為根
**傳回**
如果路徑是增強型語法：
+ 整數陣列，代表每個路徑的陣列長度。
+ 如果值不是陣列，其相應的傳回值為 null。
+ 如果沒有文件索引鍵，則為 null。
如果路徑是受限語法：
+ 大量字串陣列。每個元素都是物件中的索引鍵名稱。
+ 整數，陣列長度。
+ 如果選取多個物件，命令會傳回第一個陣列的長度。
+ 如果路徑上的值不是陣列，會發生 `WRONGTYPE` 錯誤。
+ 如果沒有路徑，會發生 `WRONGTYPE` 錯誤。
+ 如果沒有文件索引鍵，則為 null。
**範例**
增強型路徑語法：
```
127.0.0.1:6379> JSON.SET k1 . '[[], [\"a\"], [\"a\", \"b\"], [\"a\", \"b\", \"c\"]]'
(error) SYNTAXERR Failed to parse JSON string due to syntax error
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 $[3]
1) (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 [*]
(integer) 0
127.0.0.1:6379> JSON.ARRLEN k2 $[1]
1) (nil)
127.0.0.1:6379> JSON.ARRLEN k2 $[2]
1) (integer) 2
```
# JSON.ARRPOP
從陣列移除並傳回索引的 元素。彈出空陣列會傳回 null。
語法
```
JSON.ARRPOP [path [index]]
```
+ key （必要） – JSON 文件類型的金鑰
+ 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
在路徑上修剪陣列，使其變成子陣列 【開始、結束】，兩者都包含在內。
+ 如果陣列是空的，不必做任何事，會傳回 0。
+ 如果開頭 <0，則將其視為 0。
+ 如果結尾 >= 大小 (陣列的大小)，則將其視為 size-1。
+ 如果開頭 >= 大小或開頭 > 結尾，清空陣列並傳回 0。
語法
```
JSON.ARRINSERT
```
+ key （必要） – JSON 文件類型的金鑰
+ 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 文件類型的金鑰
+ path （選用） – JSON 路徑。如果未提供，則預設為根
**傳回**
+ 整數，已清除的容器數目。
+ 清除 0 個容器的空陣列或物件帳戶已清除。
**注意**
在 Redis OSS 6.2.6.R2 版之前，清除 1 個容器的空陣列或物件帳戶。
+ 清除非容器值會傳回 0。
+ 如果路徑找不到任何陣列或物件值，則命令會傳回 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) 6
127.0.0.1:6379> JSON.CLEAR k1 $[*]
(integer) 0
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 值的位元組為單位報告記憶體用量。如果未提供，路徑預設為根。
+ DEPTH 【path】 – 報告 JSON 文件的最大路徑深度。
**注意**
此子命令僅適用於使用 Valkey 7.2 或更新版本，或 Redis OSS 引擎版本 6.2.6.R2 或更新版本。
+ FIELDS 【path】 – 報告指定文件路徑中的欄位數目。如果未提供，路徑預設為根。每個非容器 JSON 值都計為一個欄位。物件和陣列遞迴計為每個內含 JSON 值的一個欄位。除根容器外，每個容器值都計為一個附加欄位。
+ HELP – 列印 命令的說明訊息。
語法
```
JSON.DEBUG
```
取決於子命令：
MEMORY
+ 如果路徑是增強型語法：
+ 傳回整數陣列，代表每個路徑上 JSON 值的記憶體大小 （以位元組為單位）。
+ 如果金鑰不存在， 會傳回空陣列。
+ 如果路徑是受限語法：
+ 傳回整數，記憶體大小以位元組為單位的 JSON 值。
+ 如果金鑰不存在，則傳回 null。
DEPTH
+ 傳回代表 JSON 文件最大路徑深度的整數。
+ 如果金鑰不存在，則傳回 null。
FIELDS
+ 如果路徑是增強型語法：
+ 傳回整數陣列，代表每個路徑的 JSON 值欄位數。
+ 如果金鑰不存在， 會傳回空陣列。
+ 如果路徑是受限語法：
+ 傳回整數，JSON 值的欄位數目。
+ 如果金鑰不存在，則傳回 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 文件類型的金鑰
+ path （選用） – JSON 路徑。如果未提供，則預設為根
**傳回**
+ 刪除的元素數目。
+ 如果金鑰不存在，則為 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 文件類型的金鑰
+ INDENT/NEWLINE/SPACE （選用） – 控制傳回的 JSON 字串格式，即「 Pretty print」。每個字串的預設值都是空字串。它們可以任意組合覆寫。可以按任何順序指定。
+ NOESCAPE - 選用，允許用於舊版相容性，且沒有其他效果。
+ path （選用） – 零個或多個 JSON 路徑，如果沒有指定，則預設為根。路徑引數必須放在最後。
**傳回**
增強型路徑語法：
如果提供一個路徑：
+ 傳回值陣列的序列化字串。
+ 如果未選取任何值，此命令會傳回空陣列。
如果提供多個路徑：
+ 傳回字串化 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
從多個文件金鑰取得路徑上的序列化 JSONs。對於不存在的金鑰或 JSON 路徑傳回 null。
語法
```
JSON.MGET [key ...]
```
+ 金鑰 （必要） – 文件類型的一或多個金鑰。
+ 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.NUMINCRBY
將路徑的數值遞增給定的數值。
語法
```
JSON.NUMINCRBY
```
+ key （必要） – JSON 文件類型的金鑰
+ 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 文件類型的金鑰
+ 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 文件類型的金鑰
+ path （選用） – JSON 路徑。如果未提供，則預設為根
**傳回**
如果路徑是增強型語法：
+ 整數陣列，代表每個路徑的物件長度。
+ 如果值不是物件，其相應的傳回值為 null。
+ 如果沒有文件索引鍵，則為 null。
如果路徑是受限語法：
+ 整數，物件中的索引鍵數目。
+ 如果選取多個物件，命令會傳回第一個物件的長度。
+ 如果路徑上的值不是物件，會發生 `WRONGTYPE` 錯誤。
+ 如果沒有路徑，會發生 `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.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 文件類型的金鑰
+ path （選用） – JSON 路徑。如果未提供，則預設為根
**傳回**
如果路徑是增強型語法：
+ 大量字串陣列。每個元素都是相符物件中的索引鍵陣列。
+ 如果值不是物件，其相應的傳回值是空白值。
+ 如果沒有文件索引鍵，則為 null。
如果路徑是受限語法：
+ 大量字串陣列。每個元素都是物件中的索引鍵名稱。
+ 如果選取多個物件，命令會傳回第一個物件的索引鍵。
+ 如果路徑上的值不是物件，會發生 `WRONGTYPE` 錯誤。
+ 如果沒有路徑，會發生 `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 Simple Strings。
+ 整數映射至 RESP 整數。
+ 64 位 IEEE 雙精確度浮點數映射至 RESP 大量字串。
+ JSON 字串會映射至 RESP 大量字串。
+ JSON 陣列以 RESP 陣列表示，其中第一個元素是簡單字串 【，後面接著陣列的元素。
+ JSON 物件以 RESP 陣列表示，其中第一個元素是簡單字串 \$1，後面接著索引鍵/值對，每個都是 RESP 大量字串。
語法
```
JSON.RESP [path]
```
+ key （必要） – JSON 文件類型的金鑰
+ path （選用） – JSON 路徑。如果未提供，則預設為根
**傳回**
如果路徑是增強型語法：
+ 陣列的陣列。每個陣列元素呈現一個路徑上值的 RESP 形式。
+ 如果沒有文件索引鍵，則為空陣列。
如果路徑是受限語法：
+ Array，代表路徑中值的 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 文件類型的金鑰
+ 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 文件類型的金鑰
+ path （選用） – JSON 路徑。如果未提供，則預設為根
+ json\$1string （必要） – 字串的 JSON 表示法。請注意，JSON 字串必須加上引號，即 '"foo"'。
**傳回**
如果路徑是增強型語法：
+ 整數陣列，代表每個路徑上字串的新長度。
+ 如果路徑上的值不是字符串，則其對應的傳回值為 null。
+ `SYNTAXERR `如果輸入 json 引數不是有效的 JSON 字串則發生錯誤。
+ `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 文件類型的金鑰
+ 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 文件類型的金鑰
+ 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 文件類型的金鑰
+ 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
```