

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# JSON 시작하기
<a name="json-gs"></a>

MemoryDB는 Valkey 또는 Redis OSS 클러스터 내에서 복잡한 데이터세트를 인코딩하는 간단한 스키마리스 방법인 기본 JavaScript Object Notation(JSON) 형식을 지원합니다. 클러스터 내에서 JSON(JavaScript Object Notation) 형식을 사용하여 데이터를 저장하고 액세스하고, 직렬화 및 역직렬화를 위해 사용자 지정 코드를 관리할 필요 없이 해당 클러스터에 저장된 JSON 데이터를 업데이트할 수 있습니다.

JSON을 통해 작동하는 애플리케이션에 Valkey 또는 Redis OSS API를 활용하는 것 외에 전체 객체를 조작할 필요 없이 JSON 문서의 특정 부분을 효율적으로 검색하고 업데이트할 수 있으므로 성능이 향상되고 비용이 절감됩니다. [Goessner 방식](https://goessner.net/articles/JsonPath/)의 `JSONPath` 쿼리를 사용하여 JSON 문서 내용을 검색할 수도 있습니다.

지원되는 엔진 버전으로 클러스터를 생성하면 JSON 데이터 유형 및 관련 명령을 자동으로 사용할 수 있습니다. 이렇게 하면 RedisJSON 모듈의 버전 2와 API 및 RDB가 호환 가능하게 되므로 기존 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 데이터 유형 개요
<a name="json-document-overview"></a>

MemoryDB는 JSON 데이터 유형으로 작업하기 위해 다양한 Valkey 및 Redis OSS 명령을 지원합니다. 다음은 JSON 데이터 유형의 개요 및 지원되는 명령의 세부 목록입니다.

## 용어
<a name="json-terminology"></a>


****  

| Term | 설명 | 
| --- | --- | 
|  JSON 문서 | JSON 키의 값을 참조합니다. | 
|  JSON 값 | 전체 문서를 나타내는 루트를 포함하는 JSON 문서의 하위 집합을 참조합니다. 값은 컨테이너 또는 컨테이너 내의 항목일 수 있습니다. | 
|  JSON 요소 | JSON 값과 같습니다. | 

## 지원되는 JSON 표준
<a name="Supported-JSON-Standard"></a>

JSON 형식은 [RFC 7159](https://www.ietf.org/rfc/rfc7159.txt) 및 [ECMA-404](https://www.ietf.org/rfc/rfc7159.txt) JSON 데이터 교환 표준과 호환됩니다. JSON 형식 텍스트에서 UTF-8 [유니코드](https://www.unicode.org/standard/WhatIsUnicode.html)가 지원됩니다.

## 루트 요소
<a name="json-root-element"></a>

루트 요소는 모든 JSON 데이터 유형일 수 있습니다. 이전 RFC 4627에서는 객체 또는 배열만 루트 값으로 허용되었습니다. RFC 7159로 업데이트한 이후 JSON 문서의 루트는 모든 JSON 데이터 유형이 될 수 있습니다.

## 문서 크기 제한
<a name="json-document-size-limit"></a>

JSON 문서는 내부적으로 신속한 액세스 및 수정을 위해 최적화된 형식으로 저장됩니다. 이 형식은 일반적으로 동일한 문서의 동등하게 직렬화된 표현보다 어느 정도 더 많은 메모리를 소비하게 됩니다. 단일 JSON 문서에 의한 메모리 소비는 64MB로 제한됩니다. 이는 JSON 문자열이 아닌 메모리 내 데이터 구조의 크기입니다. `JSON.DEBUG MEMORY` 명령을 사용하여 JSON 문서가 소비하는 메모리 양을 확인할 수 있습니다.

## JSON ACL
<a name="json-acls"></a>
+ JSON 데이터 유형은 Valkey 및 Redis OSS [액세스 제어 목록(ACL)](https://valkey.io/topics/acl/) 기능에 완전 통합됩니다. 기존의 데이터 유형별 범주(@string, @hash 등)와 유사합니다. JSON 명령 및 데이터에 대한 액세스 권한 관리를 단순화하기 위해 새 범주 @json이 추가되었습니다. 다른 기존 Valkey 또는 Redis OSS 명령은 @json 범주에 속하지 않습니다. 모든 JSON 명령은 모든 키스페이스 또는 명령 제한 및 권한을 적용합니다.
+ @read, @write, @fast, @slow 및 @admin과 같은 새로운 JSON 명령을 포함하기 위해 업데이트된 다섯 가지 기존 ACL 범주가 있습니다. 다음의 표는 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 |  |  | 

## 중첩 깊이 제한
<a name="json-nesting-depth-limit"></a>

JSON 객체 또는 배열에 자체로 또 다른 JSON 객체 또는 배열인 요소가 있는 경우, 해당 내부 객체 또는 배열은 외부 객체 또는 배열 내에 '중첩'된다고 합니다. 최대 중첩 깊이 제한은 128입니다. 중첩 깊이가 128보다 큰 문서를 만들려는 시도는 오류와 함께 거부됩니다.

## 명령 구문
<a name="json-command-syntax"></a>

대부분의 명령에는 첫 번째 인수로 Valkey 또는 Redis OSS 키 이름이 필요합니다. 일부 명령에는 path 인수도 있습니다. path 인수가 선택 사항이며 제공되지 않는 경우, 기본 루트로 설정됩니다.

 표기법:
+ 필수 인수는 각괄호로 묶습니다. 예: <키>
+ 선택적 인수는 대괄호로 묶습니다. 예: [path]
+ 추가 선택적 인수는 ... 로 표시됩니다 예: [json...]

## 경로 구문
<a name="json-path-syntax"></a>

Valkey 및 Redis OSS JSON은 다음과 같은 두 가지 종류의 경로 구문을 지원합니다.
+ **향상된 구문** - 다음의 표에 표시된 대로 [Goessner](https://goessner.net/articles/JsonPath/)에서 설명하는 JSONPath 구문을 따릅니다. 명확하게 하기 위해 표의 설명을 재정렬하고 수정했습니다.
+ **제한된 구문(Restricted syntax)** - 쿼리 기능이 제한되었습니다.

**참고**  
일부 명령의 결과는 사용되는 경로 구문 유형에 민감합니다.

 쿼리 경로가 '\$1'로 시작하는 경우 향상된 구문을 사용합니다. 그렇지 않으면 제한된 구문이 사용됩니다.

**향상된 구문**


****  

| 기호/표현식 | 설명 | 
| --- | --- | 
|  \$1 | 루트 요소 | 
|  . 또는 [] | 하위 연산자 | 
|  .. | 재귀 하강 | 
|  \$1 | 와일드카드 객체 또는 배열의 모든 요소. | 
|  [] | 배열 아래 첨자 연산자 인덱스는 0부터 시작합니다. | 
|  [,] | 조합 연산자 | 
|  [start:end:step] | 배열 조각 연산자 | 
|  ?() | 현재 배열 또는 객체에 필터(스크립트) 표현식을 적용합니다. | 
|  () | 필터 표현식 | 
|  @ | 처리 중인 현재 노드를 참조하는 필터 표현식에 사용됩니다. | 
|  == | 같음, 필터 표현식에 사용됩니다. | 
|  \$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
    }
  }
}
```


****  

| 경로 | 설명 | 
| --- | --- | 
|  \$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달러보다 저렴합니다. | 
|  '\$1..book[?(@.price < 10)]' | 모든 책이 10달러보다 저렴합니다. (경로에 공백이 포함된 경우, 따옴표로 묶어야 합니다.) | 
|  '\$1..book[?(@["price"] < 10)]' | 모든 책이 10달러보다 저렴합니다. | 
|  '\$1..book[?(@.["price"] < 10)]' | 모든 책이 10달러보다 저렴합니다. | 
|  \$1..book[?(@.price>=10&&@.price<=100)] | 가격대가 10달러에서 100달러인 모든 책, 포괄적. | 
|  '\$1..book[?(@.price>=10 && @.price<=100)]' | 가격대가 10달러에서 100달러인 모든 책, 포괄적. (경로에 공백이 포함된 경우, 따옴표로 묶어야 합니다.) | 
|  \$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]"
```

**제한된 구문(Restricted syntax)**


****  

| 기호/표현식 | 설명 | 
| --- | --- | 
|  . 또는 [] | 하위 연산자. | 
|  [] | 배열 아래 첨자 연산자. 인덱스는 0부터 시작합니다. | 

**예시**


****  

| 경로 | 설명 | 
| --- | --- | 
|  .store.book[0].author | 첫 번째 책의 저자. | 
|  .store.book[-1].author | 마지막 책의 저자. | 
|  .address.city | 도시 이름. | 
|  ["store"]["book"][0]["title"] | 첫 번째 책의 제목. | 
|  ["store"]["book"][-1]["title"] | 마지막 책의 제목. | 

**참고**  
이 문서에 인용된 모든 [Goessner](https://goessner.net/articles/JsonPath/) 콘텐츠는 [크리에이티브 커먼즈 라이선스](https://creativecommons.org/licenses/by/2.5/)에 해당합니다.

## 일반적인 오류 접두사
<a name="json-error-prefixes"></a>

각 오류 메시지에는 접두사가 있습니다. 다음은 일반적인 오류 접두사 목록입니다.


****  

| 접두사  | 설명 | 
| --- | --- | 
|  ERR | 일반 오류. | 
|  LIMIT | 크기 제한 초과 오류. 예: 문서 크기 제한 또는 중첩 깊이 제한을 초과했습니다. | 
|  NONEXISTENT | 키 또는 경로가 존재하지 않습니다. | 
|  OUTOFBOUNDARIES | 배열 인덱스가 범위를 벗어났습니다. | 
|  SYNTAXERR | 구문 오류 | 
|  WRONGTYPE | 잘못된 값 유형. | 

## JSON-관련 지표
<a name="json-info-metrics"></a>

다음과 같은 JSON 정보 지표가 제공됩니다.


****  

| 정보 | 설명 | 
| --- | --- | 
|  json\$1total\$1memory\$1bytes | JSON 객체에 할당되는 총 메모리. | 
|  json\$1num\$1documents | Valkey 또는 Redis OSS 엔진의 총 문서 수 | 

핵심 지표를 쿼리하려면 다음과 같은 명령을 실행합니다.

```
info json_core_metrics
```

## 메모리DB가 JSON과 상호작용하는 방식
<a name="json-differences"></a>

다음은 MemoryDB가 JSON 데이터 유형과 상호 작용하는 방식을 보여줍니다.

### 연산자 우선순위
<a name="json-operator-precedence"></a>

필터링에 대한 조건식을 평가하는 경우 &&s가 먼저 평가되고 그 다음 \$1\$1s가 평가되는데, 이는 대부분의 언어에서 일반적으로 사용됩니다. 괄호 안의 작업이 먼저 실행됩니다.

### 최대 경로 중첩 제한 동작
<a name="json-max-path"></a>

MemoryDB의 최대 경로 중첩 제한은 128입니다. 따라서 `$.a.b.c.d...`와 같은 값은 128수준까지만 도달할 수 있습니다.

### 숫자 값 처리
<a name="json-about-numbers"></a>

JSON에는 정수와 부동 소수점 숫자에 대해 별도의 데이터 유형이 없습니다. 모두 숫자라고 부릅니다.

JSON 번호를 수신하면 두 형식 중 하나로 저장됩니다. 숫자가 64비트 부호 있는 정수에 맞으면 해당 형식으로 변환되고 그렇지 않으면 문자열로 저장됩니다. 두 JSON 숫자(예: JSON.NUMINCRBY 및 JSON.NUMULTBY)에 대한 산술 연산은 정밀도를 최대한 유지하려고 합니다. 두 피연산자와 결과 값이 부호 있는 64비트 정수에 맞으면 정수 산술이 수행됩니다. 그렇지 않으면 입력 피연산자가 64비트 IEEE 배정밀도 부동 소수점 숫자로 변환되고 산술 연산이 수행되며 결과가 다시 문자열로 변환됩니다.

산술 명령어 `NUMINCRBY`과 `NUMMULTBY`:
+ 두 숫자가 모두 정수이고 결과가 int64 범위를 벗어나는 경우, 자동으로 배정밀도 부동 소수점 숫자가 됩니다.
+ 숫자 중 하나 이상이 부동 소수점인 경우, 결과는 배정밀도 부동 소수점 숫자가 됩니다.
+ 결과가 두 배의 범위를 초과하면 명령은 `OVERFLOW` 오류를 반환합니다.

**참고**  
Redis OSS 엔진 버전 6.2.6.R2 이전에는 입력으로 JSON 숫자를 받으면 64비트 부호 있는 정수 또는 64비트 IEEE 배정밀도 부동 소수점 중 하나의 내부 이진 표현으로 변환됩니다. 원래 문자열 및 모든해당 서식은 보관되지 않습니다. 따라서 JSON 응답의 일부로 숫자가 출력되면 해당 숫자는 내부 이진 표현에서 일반 서식 규칙을 사용하는 인쇄 가능한 문자열로 변환됩니다. 이러한 규칙은 수신된 문자열과 다른 문자열이 생성될 수 있습니다.  
두 숫자가 모두 정수이고 결과가 `int64`의 범위를 벗어나는 경우 자동으로 64비트 IEEE 배정밀도 부동 소수점 숫자가 됩니다.
숫자 중 하나 이상이 부동 소수점인 경우 결과는 64비트 IEEE 배정밀도 부동 소수점 숫자입니다.
결과가 64비트 IEEE 배정밀도 범위를 초과한 경우 명령은 `OVERFLOW` 오류를 반환합니다.

사용할 수 있는 명령의 자세한 목록은 [지원되는 명령](json-list-commands.md) 섹션을 참조하세요.

### 엄격한 구문 평가
<a name="json-strict-syntax-evaluation"></a>

MemoryDB에서는 경로의 하위 집합에 유효한 경로가 포함되어 있더라도 잘못된 구문으로 JSON 경로를 허용하지 않습니다. 이는 고객에게 올바른 행동을 유지하는 것과 같습니다.

# 지원되는 명령
<a name="json-list-commands"></a>

다음과 같은 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
<a name="json-arrappend"></a>

하나 이상의 값을 경로의 배열 값에 추가합니다.

구문

```
JSON.ARRAPPEND <key> <path> <json> [json ...]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(필수) - 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
<a name="json-arrindex"></a>

경로의 배열에서 처음 나타나는 스칼라 JSON 값을 검색합니다.
+ 범위를 벗어난 오류는 인덱스를 배열의 시작과 끝으로 반올림하여 처리됩니다.
+ 시작 > 끝이면 -1(찾을 수 없음)을 반환합니다.

구문

```
JSON.ARRINDEX <key> <path> <json-scalar> [start [end]]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(필수) - JSON 경로입니다.
+ json-scalar (필수) - 검색할 스칼라 값입니다. JSON 스칼라는 객체나 배열이 아닌 값을 나타냅니다. 즉, 문자열, 숫자, 부울 및 null은 스칼라 값입니다.
+ 시작(선택 사항) - 시작 인덱스는 포괄적입니다. 제공하지 않으면 기본적으로 0으로 설정됩니다.
+ 끝(선택 사항) - 끝 인덱스는 배타적입니다. 제공되지 않은 경우, 기본적으로 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
<a name="json-arrinsert"></a>

경로의 값 배열에서 인덱스 앞에 하나 이상의 값을 삽입합니다.

구문

```
JSON.ARRINSERT <key> <path> <index> <json> [json ...]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(필수) - JSON 경로입니다.
+ 인덱스(필수) - 삽입된 값의 앞에 있는 배열 인덱스입니다.
+ 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
<a name="json-arrlen"></a>

경로에서 배열 값의 길이를 얻습니다.

구문

```
JSON.ARRLEN <key> [path] 
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.

**반환**

경로가 향상된 구문인 경우
+ 각 경로에서 배열 길이를 나타내는 정수 배열입니다.
+ 값이 배열이 아닌 경우 해당 반환 값은 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
<a name="json-arrpop"></a>

배열에서 인덱스의 요소를 제거하고 반환합니다. 빈 배열을 팝하면 null이 반환됩니다.

구문

```
JSON.ARRPOP <key> [path [index]]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.
+ 인덱스(선택 사항) - 팝업을 시작할 배열의 위치입니다.
  + 제공되지 않으면 기본적으로 마지막 요소를 의미하는 -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
<a name="json-arrtrim"></a>

경로의 배열을 자르므로 하위 배열[시작, 끝] 둘 다 포괄적이 됩니다.
+ 배열이 비어 있는 경우 아무 것도 하지 않고 0을 반환합니다.
+ 시작 < 0인 경우 0으로 처리합니다.
+ 끝 >= 크기(배열의 크기)인 경우 크기-1로 처리합니다.
+ 시작 >= 크기 또는 시작 > 끝인 경우 배열을 비우고 0을 반환합니다.

구문

```
JSON.ARRINSERT <key> <path> <start> <end>
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(필수) - JSON 경로입니다.
+ 시작(필수) - 시작 인덱스는 포괄적입니다.
+ 끝(필수) - 끝 인텍스, 포괄적입니다.

**반환**

경로가 향상된 구문인 경우
+ 각 경로에서 배열의 새 길이를 나타내는 정수 배열입니다.
+ 값이 빈 배열인 경우 해당 반환 값은 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
<a name="json-clear"></a>

경로의 배열 또는 객체를 삭제합니다.

구문

```
JSON.CLEAR <key> [path]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.

**반환**
+ 정수, 삭제된 컨테이너의 수입니다.
+ 삭제된 0개의 컨테이너에 대해 빈 배열 또는 객체 계정을 삭제합니다.
**참고**  
Redis OSS 버전 6.2.6.R2에서 삭제된 하나의 컨테이너에 대해 빈 배열 또는 객체 계정을 삭제합니다.
+ 컨테이너가 아닌 값을 삭제하면 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
<a name="json-debug"></a>

Report Information(보고서 정보) 지원되는 하위 명령은 다음과 같습니다.
+ MEMORY <key> [path] - 메모리 사용량(단위: JSON 값 바이트)을 보고합니다. 경로는 제공되지 않으면 기본적으로 root로 설정됩니다.
+ <key>DEPTH [path] - JSON 문서의 최대 경로 깊이를 보고합니다.
**참고**  
이 하위 명령은 Valkey 7.2 이상 또는 Redis OSS 엔진 버전 6.2.6.R2 이상에서만 사용할 수 있습니다.
+ FIELDS <key> [path] - 지정된 문서 경로의 필드 수를 보고합니다. 경로는 제공되지 않으면 기본적으로 root로 설정됩니다. 컨테이너가 아닌 각 JSON 값은 하나의 필드로 계산됩니다. 객체와 배열은 포함하는 JSON 값 각각에 대해 하나의 필드를 재귀적으로 계산합니다. 루트 컨테이너를 제외한 각 컨테이너 값은 하나의 추가 필드로 계산됩니다.
+ HELP - 명령의 도움말 메시지를 출력합니다.

구문

```
JSON.DEBUG <subcommand & arguments>
```

다음의 하위 명령에 따라 다릅니다.

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 <key> [path] - report memory size (bytes) of the JSON element. Path defaults to root if not provided.
2) JSON.DEBUG FIELDS <key> [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
<a name="json-del"></a>

문서 키의 경로에 있는 JSON 값을 삭제합니다. 경로가 루트이면 Valkey 또는 Redis OSS에서 키를 삭제하는 것과 같습니다.

구문

```
JSON.DEL <key> [path]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.

**반환**
+ 삭제된 요소 수입니다.
+ 키가 없으면 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
<a name="json-forget"></a>

[JSON.DEL](json-del.md)의 별칭.

# JSON.GET
<a name="json-get"></a>

하나 또는 여러 경로에서 직렬화된 JSON을 반환합니다.

구문

```
JSON.GET <key>
[INDENT indentation-string]
[NEWLINE newline-string]
[SPACE space-string]
[NOESCAPE]
[path ...]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ INDENT/NEWLINE/SPACE(선택 사항) - 반환된 JSON 문자열(즉, "예쁜 인쇄")의 형식을 제어합니다. 각 문자열의 기본값은 빈 문자열이며, 모든 조합으로 재정의될 수 있습니다. 임의의 순서로 지정할 수 있습니다.
+ NOESCAPE - 선택 사항, 레거시 호환성을 위해 사용할 수 있으며 다른 효과는 없습니다.
+ 경로(선택 사항) - 0개 이상의 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
<a name="json-mget"></a>

여러 문서 키의 경로에서 직렬화된 JSON을 얻습니다. 없는 키 또는 JSON 경로에 대해 null을 반환합니다.

구문

```
JSON.MGET <key> [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
<a name="json-numincrby"></a>

경로의 숫자 값을 지정된 수만큼 증가합니다.

구문

```
JSON.NUMINCRBY <key> <path> <number>
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(필수) - JSON 경로입니다.
+ 숫자(필수) - 숫자입니다.

**반환**

경로가 향상된 구문인 경우
+ 각 경로에서 결과 값을 나타내는 대량 문자열 배열입니다.
+ 값이 숫자가 아닌 경우 해당 반환 값은 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
<a name="json-nummultby"></a>

경로의 숫자 값을 지정된 수만큼 곱합니다.

구문

```
JSON.NUMMULTBY <key> <path> <number>
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(필수) - JSON 경로입니다.
+ 숫자(필수) - 숫자입니다.

**반환**

경로가 향상된 구문인 경우
+ 각 경로에서 결과 값을 나타내는 대량 문자열 배열입니다.
+ 값이 숫자가 아닌 경우 해당 반환 값은 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
<a name="json-objlen"></a>

경로에 있는 객체 값의 키 수를 얻습니다.

구문

```
JSON.OBJLEN <key> [path]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.

**반환**

경로가 향상된 구문인 경우
+ 각 경로에서 객체 길이를 나타내는 정수 배열입니다.
+ 값이 객체가 아닌 경우 해당 반환 값은 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
<a name="json-objkeys"></a>

경로의 객체 값에 있는 키 이름을 얻습니다.

구문

```
JSON.OBJKEYS <key> [path]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.

**반환**

경로가 향상된 구문인 경우
+ 대량 문자열 배열 각 요소는 일치하는 객체의 키 배열입니다.
+ 값이 객체가 아닌 경우 해당 반환 값은 빈 값입니다.
+ 문서 키가 없으면 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
<a name="json-resp"></a>

Valkey 또는 Redis OSS(Redis Serialization Protocol)의 지정된 경로에 JSON 값을 반환합니다. 값이 컨테이너인 경우, 응답은 RESP 배열 또는 중첩 배열입니다.
+ JSON null은 RESP Null 대량 문자열에 매핑됩니다.
+ JSON 부울 값은 각 RESP 단순 문자열에 매핑됩니다.
+ 정수는 RESP 정수에 매핑됩니다.
+ 64비트 IEEE 이중 부동 소수점 숫자는 RESP 대량 문자열에 매핑됩니다.
+ JSON 문자열은 RESP 대량 문자열에 매핑됩니다.
+ JSON 배열은 RESP 배열로 표현됩니다. 여기서 첫 번째 요소는 간단한 문자열 [이고 그 뒤에 배열의 요소가 옵니다.
+ JSON 객체는 RESP 배열로 표현됩니다. 여기서 첫 번째 요소는 간단한 문자열 \$1이고 그 뒤에 각각이 RESP 대량 문자열인 키-값 쌍이 옵니다.

구문

```
JSON.RESP <key> [path]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.

**반환**

경로가 향상된 구문인 경우
+ 배열의 배열입니다. 각 배열 요소는 한 경로에 있는 값의 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
<a name="json-set"></a>

경로에 JSON 값을 설정합니다.

경로가 객체 멤버를 호출하는 경우
+ 상위 요소가 없는 경우, 다음 명령은 NONEXISTENT 오류를 반환합니다.
+ 상위 요소가 있지만 객체가 아닌 경우, 명령은 ERROR를 반환합니다.
+ 상위 요소가 있고 객체인 경우
  +  멤버가 없으면 상위 객체가 경로의 마지막 하위 객체인 경우에만 새 멤버는 상위 객체에 추가됩니다. 그렇지 않으면 명령은 NONEXISTENT 오류를 반환합니다.
  +  멤버가 있으면 해당 값이 JSON 값으로 대체됩니다.

경로가 배열 인덱스를 호출하는 경우
+ 상위 요소가 없는 경우, 다음 명령은 NONEXISTENT 오류를 반환합니다.
+ 상위 요소가 있지만 배열이 아닌 경우, 명령은 ERROR를 반환합니다.
+ 상위 요소가 있지만 인덱스가 범위를 벗어난 경우, 명령은 OUTOFBOUNDARIES 오류를 반환합니다.
+ 상위 요소가 있고 인덱스가 유효하면 요소는 새 JSON 값으로 대체됩니다.

경로가 객체 또는 배열을 호출하는 경우 값(객체 또는 배열)은 새 JSON 값으로 대체됩니다.

구문

```
JSON.SET <key> <path> <json> [NX | XX] 
```

[NX \$1 XX] 여기에 [NX \$1 XX] 식별자 0개 또는 1개가 있을 수 있습니다..
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(필수) - JSON 경로입니다. 새 키의 경우 JSON 경로가 루트 ‘.’여야 합니다.
+ NX(선택 사항) - 경로가 루트이면, 키가 없는 경우에만 값을 설정합니다(예: 새 문서 삽입). 경로가 루트가 아니면 경로가 없는 경우에만 값을 설정합니다.
+ XX(선택 사항) - 경로가 루트이면, Redis 키가 있는 경우에만 값을 설정합니다(예: 기존 문서 대체). 경로가 루트가 아니면 경로가 있는 경우에만 값을 설정합니다.

**반환**
+ 성공 시 단순 문자열 '확인'.
+ 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
<a name="json-strappend"></a>

경로에서 JSON 문자열에 문자열을 추가합니다.

구문

```
JSON.STRAPPEND <key> [path] <json_string>
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.
+ json\$1string(필수) - 문자열의 JSON 표현입니다. JSON 문자열은 따옴표로 묶어야 합니다. 즉, '"foo"'.

**반환**

경로가 향상된 구문인 경우
+ 각 경로에서 문자열의 새 길이를 나타내는 정수 배열입니다.
+ 경로의 값이 문자열이 아닌 경우 해당 반환 값은 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
<a name="json-strlen"></a>

경로에서 JSON 문자열 값의 길이를 얻습니다.

구문

```
JSON.STRLEN <key> [path] 
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.

**반환**

경로가 향상된 구문인 경우
+ 각 경로에서 문자열 값의 길이를 나타내는 정수 배열입니다.
+ 값이 문자열이 아닌 경우 해당 반환 값은 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
<a name="json-toggle"></a>

경로에서 참과 거짓 사이의 부울 값을 토글합니다.

구문

```
JSON.TOGGLE <key> [path] 
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.

**반환**

경로가 향상된 구문인 경우
+ 각 경로에서 결과 부울 값을 나타내는 정수 배열(0 - 거짓, 1 - 참)입니다.
+ 값이 배열이 부울 값이 아닌 경우, 해당 반환 값은 null입니다.
+ 문서 키가 없는 경우 `NONEXISTENT`입니다.

경로가 제한된 구문인 경우
+ 결과 부울 값을 나타내는 문자열('참'/ '거짓')입니다.
+ 문서 키가 없는 경우 `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
<a name="json-type"></a>

지정된 경로의 값 유형을 보고합니다.

구문

```
JSON.TYPE <key> [path]
```
+ 키(필수) - JSON 문서 유형의 키입니다.
+ 경로(선택 사항) - JSON 경로입니다. 제공하지 않으면 기본적으로 root로 설정됩니다.

**반환**

경로가 향상된 구문인 경우
+ 각 경로에서 값 유형을 나타내는 문자열 배열입니다. 유형은 \$1"null', '부울', '문자열', '숫자', '정수', '개체'및 '배열'\$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
```