本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# JSON 入門
MemoryDB 支援原生 JavaScript 物件標記法 (JSON) 格式，這是一種簡單、無結構描述的方式來編碼 Valkey 或 Redis OSS 叢集內的複雜資料集。您可以在叢集內原生使用 JavaScript 物件標記法 (JSON) 格式存放和存取資料，並更新存放在這些叢集中的 JSON 資料，而不需要管理自訂程式碼來序列化和還原序列化。
除了為透過 JSON 操作的應用程式利用 Valkey 或 Redis OSS APIs 之外，您現在可以有效率地擷取和更新 JSON 文件的特定部分，而無需操作整個物件，從而提高效能並降低成本。您也可以使用 [Goessner 式](https://goessner.net/articles/JsonPath/) `JSONPath` 查詢，搜尋 JSON 文件內容。
使用支援的引擎版本建立叢集後，會自動使用 JSON 資料類型和相關聯的命令。這與 API 相容，且 RDB 相容於 RedisJSON 模組第 2 版，因此您可以輕鬆地將現有的 JSON 型 Valkey 或 Redis OSS 應用程式遷移至 MemoryDB。如需支援命令的詳細資訊，請參閱 [支援的命令](json-list-commands.md)。
JSON 相關指標`JsonBasedCmds`會整合到 CloudWatch 中，以監控此資料類型的使用情況。如需詳細資訊，請參閱 [ MemoryDB 的指標](https://docs.aws.amazon.com/memorydb/latest/devguide/metrics.memorydb.html)。
**注意**
若要使用 JSON，您必須執行 Valkey 7.2 或更新版本，或 Redis OSS 引擎 6.2.6 或更新版本。
**Topics**
+ [JSON 資料類型概觀](json-document-overview.md)
+ [支援的命令](json-list-commands.md)
# JSON 資料類型概觀
MemoryDB 支援許多使用 JSON 資料類型的 Valkey 和 Redis OSS 命令。以下是 JSON 資料類型的概觀，以及支援命令的詳細清單。
## 術語
****
| 術語 | Description |
| --- | --- |
| JSON 文件 | 是指 JSON 金鑰的值 |
| JSON 值 | 是指 JSON 文件的子集，包括代表整個文件的根。值可以是容器或容器中的項目 |
| JSON 元素 | 相當於 JSON 值 |
## 支援的 JSON 標準
JSON 格式符合 [RFC 7159](https://www.ietf.org/rfc/rfc7159.txt) 和 [ECMA-404](https://www.ietf.org/rfc/rfc7159.txt) JSON 資料交換標準。支援 JSON 文字中的 UTF-8 [Unicode](https://www.unicode.org/standard/WhatIsUnicode.html)。
## 根元素
根元素可為任何 JSON 資料類型。請注意，在舊版 RFC 4627 中，只允許將物件或陣列當作根值。由於更新至 RFC 7159，JSON 文件的根可為任何 JSON 資料類型。
## 文件大小限制
JSON 文件會以針對快速存取和修改最佳化的格式儲存在內部。這種格式通常會比相同文件的同等序列化表示法消耗更多記憶體。單一 JSON 文件的記憶體使用量限制為 64MB，即記憶體內資料結構的大小，而非 JSON 字串。您可以使用 `JSON.DEBUG MEMORY`命令來檢查 JSON 文件耗用的記憶體量。
## JSON ACL
+ JSON 資料類型已完全整合至 Valkey 和 Redis OSS [存取控制清單 (ACL)](https://valkey.io/topics/acl/) 功能。與現有的每個資料類型類別 (@string、@hash 等） 類似，會新增新類別 @json，以簡化對 JSON 命令和資料的管理存取。沒有其他現有的 Valkey 或 Redis OSS 命令是 @json 類別的成員。所有 JSON 命令都會強制執行任何索引鍵空間或命令限制和許可。
+ 已更新五個現有的 ACL 類別，以包含新的 JSON 命令：@read、@write、@fast、@slow 和 @admin。下表指出 JSON 命令與適當類別的映射。
**ACL**
| JSON 命令 | @read | @write | @fast | @slow | @admin |
| --- | --- | --- | --- | --- | --- |
| JSON.ARRAPPEND | | y | y | | |
| JSON.ARRINDEX | y | | y | | |
| JSON.ARRINSERT | | y | y | | |
| JSON.ARRLEN | y | | y | | |
| JSON.ARRPOP | | y | y | | |
| JSON.ARRTRIM | | y | y | | |
| JSON.CLEAR | | y | y | | |
| JSON.DEBUG | y | | | y | y |
| JSON.DEL | | y | y | | |
| JSON.FORGET | | y | y | | |
| JSON.GET | y | | y | | |
| JSON.MGET | y | | y | | |
| JSON.NUMINCRBY | | y | y | | |
| JSON.NUMMULTBY | | y | y | | |
| JSON.OBJKEYS | y | | y | | |
| JSON.OBJLEN | y | | y | | |
| JSON.RESP | y | | y | | |
| JSON.SET | | y | | y | |
| JSON.STRAPPEND | | y | y | | |
| JSON.STRLEN | y | | y | | |
| JSON.STRLEN | y | | y | | |
| JSON.TOGGLE | | y | y | | |
| JSON.TYPE | y | | y | | |
| JSON.NUMINCRBY | | y | y | | |
## 巢狀深度限制
JSON 物件或陣列具有本身是另一個 JSON 物件或陣列的元素時，該內部物件或陣列稱之為在外部物件或陣列中「巢狀」。巢狀深度上限為 128。任何建立巢狀深度大於 128 文件的嘗試，都會遭到拒絕，並顯示錯誤。
## 命令語法
大多數命令需要 Valkey 或 Redis OSS 金鑰名稱做為第一個引數。部分命令也有路徑引數。如果路徑引數為選用且未提供，則路徑引數預設為根。
標記法：
+ 必要的引數以角括號括住，例如
+ 選用引數以方括號括住，例如 【path】
+ 其他選用引數會以 ... 表示，例如 【json ...】
## 路徑語法
JSON for Valkey 和 Redis OSS 支援兩種路徑語法：
+ **增強型語法** – 遵循 [Goessner](https://goessner.net/articles/JsonPath/) 所述的 JSONPath 語法，如下表所示。為清楚說明，我們重新排序並修改表格中的描述。
+ **受限語法** – 查詢功能有限。
**注意**
某些命令的結果會區分使用的路徑語法類型。
如果查詢路徑以 '\$1' 開頭，它會使用增強型語法。否則，將使用受限語法。
**增強型語法**
****
| 符號/表達式 | Description |
| --- | --- |
| \$1 | 根元素 |
| . 或 [] | 子運算子 |
| .. | 遞迴下降 |
| \$1 | 萬用字元。物件或陣列中的所有元素。 |
| [] | array subscript 運算子。索引以 0 為基礎。 |
| [,] | 聯集運算子 |
| [start:end:step] | 陣列配量運算子 |
| ?() | 將篩選條件 (script) 表達式套用至目前的陣列或物件 |
| () | 篩選條件表達式 |
| @ | 用於參考正在處理的目前節點的篩選條件表達式 |
| == | 等於，用於篩選條件表達式。 |
| \$1= | 不等於，用於篩選條件表達式。 |
| > | 大於，用於篩選條件表達式。 |
| >= | 大於或等於，用於篩選條件表達式。 |
| < | 小於，用於篩選條件表達式。 |
| <= | 小於或等於，用於篩選條件表達式。 |
| && | 邏輯 AND，用於結合多個篩選條件表達式。 |
| \$1\$1 | 邏輯 OR，用於結合多個篩選條件表達式。 |
**範例**
以下範例是以 [Goessner ](https://goessner.net/articles/JsonPath/)的範例 XML 資料為基礎，我們已透過新增其他欄位來修改這些資料。
```
{ "store": {
"book": [
{ "category": "reference",
"author": "Nigel Rees",
"title": "Sayings of the Century",
"price": 8.95,
"in-stock": true,
"sold": true
},
{ "category": "fiction",
"author": "Evelyn Waugh",
"title": "Sword of Honour",
"price": 12.99,
"in-stock": false,
"sold": true
},
{ "category": "fiction",
"author": "Herman Melville",
"title": "Moby Dick",
"isbn": "0-553-21311-3",
"price": 8.99,
"in-stock": true,
"sold": false
},
{ "category": "fiction",
"author": "J. R. R. Tolkien",
"title": "The Lord of the Rings",
"isbn": "0-395-19395-8",
"price": 22.99,
"in-stock": false,
"sold": false
}
],
"bicycle": {
"color": "red",
"price": 19.95,
"in-stock": true,
"sold": false
}
}
}
```
****
| 路徑 | Description |
| --- | --- |
| \$1.store.book[\$1].author | 商店中所有書籍的作者 |
| \$1..author | 所有作者 |
| \$1.store.\$1 | 存放區的所有成員 |
| \$1["store"].\$1 | 存放區的所有成員 |
| \$1.store..price | 商店中所有項目的價格 |
| \$1..\$1 | JSON 結構的所有遞迴成員 |
| \$1..book[\$1] | 所有書籍 |
| \$1..book[0] | 第一本書 |
| \$1..book[-1] | 最後一本書 |
| \$1..book[0:2] | 前兩本書 |
| \$1..book[0,1] | 前兩本書 |
| \$1..book[0:4] | 從索引 0 到 3 的書籍 （不包含結束索引） |
| \$1..book[0:4:2] | 索引為 0、2 的書籍 |
| \$1..book[?(@.isbn)] | 具有 isbn 編號的所有書籍 |
| \$1..book[?(@.price<10)] | 低於 10 USD 的所有書籍 |
| '\$1..book[?(@.price < 10)]' | 低於 10 USD 的所有書籍。（如果包含空格，則必須引用路徑） |
| '\$1..book[?(@["price"] < 10)]' | 低於 10 USD 的所有書籍 |
| '\$1..book[?(@.["price"] < 10)]' | 低於 10 USD 的所有書籍 |
| \$1..book[?(@.price>=10&&@.price<=100)] | 價格範圍介於 \$110 到 \$1100 的所有書籍，包括 |
| '\$1..book[?(@.price>=10 && @.price<=100)]' | 價格範圍介於 \$110 到 \$1100 的所有書籍，包括在內。（如果包含空格，則必須引用路徑） |
| \$1..book[?(@.sold==true\$1\$1@.in-stock==false)] | 所有已售出或缺貨的書籍 |
| '\$1..book[?(@.sold == true \$1\$1 @.in-stock == false)]' | 所有已售出或缺貨的書籍。（如果包含空格，則必須引用路徑） |
| '\$1.store.book[?(@.["category"] == "fiction")]' | 小說類別中的所有書籍 |
| '\$1.store.book[?(@.["category"] \$1= "fiction")]' | 非小數類別中的所有書籍 |
更多篩選條件表達式範例：
```
127.0.0.1:6379> JSON.SET k1 . '{"books": [{"price":5,"sold":true,"in-stock":true,"title":"foo"}, {"price":15,"sold":false,"title":"abc"}]}'
OK
127.0.0.1:6379> JSON.GET k1 $.books[?(@.price>1&&@.price<20&&@.in-stock)]
"[{\"price\":5,\"sold\":true,\"in-stock\":true,\"title\":\"foo\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?(@.price>1 && @.price<20 && @.in-stock)]'
"[{\"price\":5,\"sold\":true,\"in-stock\":true,\"title\":\"foo\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?((@.price>1 && @.price<20) && (@.sold==false))]'
"[{\"price\":15,\"sold\":false,\"title\":\"abc\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?(@.title == "abc")]'
[{"price":15,"sold":false,"title":"abc"}]
127.0.0.1:6379> JSON.SET k2 . '[1,2,3,4,5]'
127.0.0.1:6379> JSON.GET k2 $.*.[?(@>2)]
"[3,4,5]"
127.0.0.1:6379> JSON.GET k2 '$.*.[?(@ > 2)]'
"[3,4,5]"
127.0.0.1:6379> JSON.SET k3 . '[true,false,true,false,null,1,2,3,4]'
OK
127.0.0.1:6379> JSON.GET k3 $.*.[?(@==true)]
"[true,true]"
127.0.0.1:6379> JSON.GET k3 '$.*.[?(@ == true)]'
"[true,true]"
127.0.0.1:6379> JSON.GET k3 $.*.[?(@>1)]
"[2,3,4]"
127.0.0.1:6379> JSON.GET k3 '$.*.[?(@ > 1)]'
"[2,3,4]"
```
**受限語法**
****
| 符號/表達式 | Description |
| --- | --- |
| . 或 [] | 子運算子 |
| [] | array subscript 運算子。索引以 0 為基礎。 |
**範例**
****
| 路徑 | Description |
| --- | --- |
| .store.book[0].author | 第一本書籍的作者 |
| .store.book[-1].author | 最後一本書的作者 |
| .address.city | 城市名稱 |
| ["store"]["book"][0]["title"] | 第一本書的標題 |
| ["store"]["book"][-1]["title"] | 最後一本書的標題 |
**注意**
本文件中引用的所有 [Goessner](https://goessner.net/articles/JsonPath/) 內容均受[創用 CC 授權](https://creativecommons.org/licenses/by/2.5/)規範。
## 常見錯誤字首
每個錯誤訊息都有一個字首。以下是常見錯誤字首的清單：
****
| 字首 | Description |
| --- | --- |
| ERR | 一般錯誤 |
| LIMIT | 超過大小限制錯誤。例如，超過文件大小限制或巢狀深度限制 |
| NONEXISTENT | 金鑰或路徑不存在 |
| OUTOFBOUNDARIES | 陣列索引超出範圍 |
| SYNTAXERR | 語法錯誤 |
| WRONGTYPE | 錯誤的值類型 |
## JSON 相關指標
提供下列 JSON 資訊指標：
****
| 資訊 | Description |
| --- | --- |
| json\$1total\$1memory\$1bytes | 配置給 JSON 物件的記憶體總數 |
| json\$1num\$1documents | Valkey 或 Redis OSS 引擎中的文件總數 |
若要查詢核心指標，請執行 命令：
```
info json_core_metrics
```
## MemoryDB 如何與 JSON 互動
以下說明 MemoryDB 如何與 JSON 資料類型互動。
### 運算子優先順序
評估用於篩選的條件表達式時，&& 優先，然後評估 \$1\$1，就像大多數語言一樣。括號內的操作會先執行。
### 路徑巢狀上限行為
MemoryDB 的路徑巢狀限制上限為 128。`$.a.b.c.d...` 等值只能達到 128 個等級。
### 處理數值
JSON 對於整數和浮點數沒有單獨的資料類型。均稱為數字。
收到 JSON 號碼時，會以兩種格式之一存放。如果數字符合 64 位元帶正負號的整數，則會轉換為該格式；否則會儲存為字串。兩個 JSON 號碼 （例如 JSON.NUMINCRBY 和 JSON.NUMMULTBY) 的算術操作會嘗試盡可能保持精確度。如果兩個運算元和產生的值符合 64 位元帶正負號的整數，則會執行整數算術。否則，輸入運算元會轉換為 64 位元 IEEE 雙精度浮點數、執行算術操作，並將結果轉換回字串。
算術命令 `NUMINCRBY` 和 `NUMMULTBY`：
+ 如果兩個數字都是整數，且結果超出 int64 的範圍，則會自動成為雙精度浮點數。
+ 如果至少一個數字是浮點數，則結果將是雙精度浮點數。
+ 如果結果超過兩倍的範圍，命令將傳回`OVERFLOW`錯誤。
**注意**
在輸入時收到 JSON 號碼時，在 Redis OSS 引擎版本 6.2.6.R2 之前，它會轉換為兩個內部二進位表示式之一：64 位元帶正負號的整數或 64 位元 IEEE 雙精度浮點。不會保留原始字串和全部格式化。因此，數字當作 JSON 回應的一部分輸出時，會從內部二進位表示法，轉換為使用一般格式化規則的可列印字串。這些規則可能導致產生的字串與接收的字串不同。
如果兩個數字都是整數，且結果超出 `int64` 範圍，會自動變成 64 位元 IEEE 雙精確度浮點數。
如果其中至少一個數字是浮點數，結果會是 64 位元 IEEE 雙精確度浮點數。
如果結果超過 64 位元 IEEE 雙精確度範圍，命令會傳回 `OVERFLOW` 錯誤。
如需可用命令的詳細清單，請參閱[支援的命令](json-list-commands.md)。
### 嚴格語法評估
即使路徑的子集包含有效路徑，MemoryDB 也不允許使用無效語法的 JSON 路徑。這是為了我們的客戶保持正確行為。
# 支援的命令
支援下列 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
```