Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Unterstützte Befehle
Die folgenden JSON-Befehle werden unterstützt:
**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
Hängen Sie einen oder mehrere Werte an die Array-Werte im Pfad an.
Syntax
```
JSON.ARRAPPEND [json ...]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ json (erforderlich) — JSON-Wert, der an das Array angehängt werden soll
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Ganzzahlen, das die neue Länge des Arrays an jedem Pfad darstellt.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
+ `SYNTAXERR`-Fehler, wenn eines der eingegebenen JSON-Argumente keine gültige JSON-Zeichenfolge ist.
+ `NONEXISTENT`-Fehler, wenn der Pfad nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die neue Länge des Arrays.
+ Wenn mehrere Array-Werte ausgewählt wurden, gibt der Befehl die neue Länge des zuletzt aktualisierten Arrays zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
+ `SYNTAXERR`-Fehler, wenn eines der eingegebenen JSON-Argumente keine gültige JSON-Zeichenfolge ist.
+ `NONEXISTENT`-Fehler, wenn der Pfad nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]]"
```
Eingeschränkte Pfad-Syntax:
```
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
Sucht nach dem ersten Vorkommen eines skalaren JSON-Werts in den Arrays am Pfad.
+ Fehler außerhalb des Bereichs werden behandelt, indem der Index auf den Anfang und das Ende des Arrays gerundet wird.
+ Wenn start > end, return -1 (nicht gefunden).
Syntax
```
JSON.ARRINDEX [start [end]]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ json-scalar (erforderlich) — Skalarwert, nach dem gesucht werden soll; JSON-Skalar bezieht sich auf Werte, die keine Objekte oder Arrays sind. Das heißt, String, Zahl, Boolean und Null sind Skalarwerte.
+ start (optional) — Startindex, einschließlich. Es gilt der Standardwert „0“, falls nicht vorhanden.
+ end (optional) — Endindex, exklusiv. Der Standardwert ist 0, falls nicht angegeben, was bedeutet, dass das letzte Element enthalten ist. 0 oder -1 bedeutet, dass das letzte Element enthalten ist.
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen. Jeder Wert ist der Index des übereinstimmenden Elements im Array am Pfad. Der Wert ist -1, falls nicht gefunden.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, der Index des übereinstimmenden Elements oder -1, falls nicht gefunden.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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
```
Eingeschränkte Pfad-Syntax:
```
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
Fügt einen oder mehrere Werte in die Array-Werte am Pfad vor dem Index ein.
Syntax
```
JSON.ARRINSERT [json ...]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ index (erforderlich) — Array-Index, vor dem Werte eingefügt werden.
+ json (erforderlich) — JSON-Wert, der an das Array angehängt werden soll
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Ganzzahlen, das die neue Länge des Arrays an jedem Pfad darstellt.
+ Wenn ein Wert ein leeres Array ist, ist der entsprechende Rückgabewert Null.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
+ `OUTOFBOUNDARIES`-Fehler, wenn das Index-Argument außerhalb des gültigen Bereichs liegt.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die neue Länge des Arrays.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
+ `OUTOFBOUNDARIES`-Fehler, wenn das Index-Argument außerhalb des gültigen Bereichs liegt.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]]"
```
Eingeschränkte Pfad-Syntax:
```
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
Ermittelt die Länge der Array-Werte im Pfad.
Syntax
```
JSON.ARRLEN [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen, die die Array-Länge an jedem Pfad darstellen.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Array von Bulk-Strings. Jedes Element ist ein Schlüsselname im Objekt.
+ Ganzzahl, Array-Länge.
+ Wenn mehrere Objekte ausgewählt sind, gibt der Befehl die Länge des ersten Arrays zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
+ `WRONGTYPE`-Fehler, wenn der Pfad nicht vorhanden ist.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Entferne das Element am Index aus dem Array und gib es zurück. Das Öffnen eines leeren Arrays gibt null zurück.
Syntax
```
JSON.ARRPOP [path [index]]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
+ index (optional) — Position im Array, von der aus der Pop-up gestartet werden soll.
+ Ist standardmäßig -1, falls nicht angegeben, was auf das letzte Element verweist.
+ Negativer Wert bedeutet Position vom letzten Element.
+ Außerhalb der Grenzen liegende Indizes werden auf ihre jeweiligen Array-Grenzen gerundet.
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Massenzeichenfolgen, die Werte in Popups für jeden Pfad darstellen.
+ Wenn ein Wert ein leeres Array ist, ist der entsprechende Rückgabewert Null.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Massenzeichenfolge, die den JSON-Wert im Popup-Fenster darstellt
+ Null, wenn das Array leer ist.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]]"
```
Eingeschränkte Pfad-Syntax:
```
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
Kürzen Sie die Arrays am Pfad so, dass sie zu einem Subarray [Start, Ende] werden, beides inklusive.
+ Wenn das Array leer ist, tun Sie nichts, und geben Sie 0 zurück.
+ Wenn start <0 ist, behandeln Sie es als 0.
+ Wenn end >= size (Größe des Arrays), behandeln Sie es als size-1.
+ Wenn start >= size oder start > end, leeren Sie das Array und geben 0 zurück.
Syntax
```
JSON.ARRINSERT
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ start (erforderlich) — Startindex, einschließlich.
+ end (erforderlich) — Endindex, einschließlich.
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen, die die neue Länge des Arrays an jedem Pfad darstellen.
+ Wenn ein Wert ein leeres Array ist, ist der entsprechende Rückgabewert Null.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
+ `OUTOFBOUNDARIES`-Fehler, wenn ein Indexargument außerhalb des gültigen Bereichs liegt.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die neue Länge des Arrays.
+ Null, wenn das Array leer ist.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
+ `OUTOFBOUNDARIES`-Fehler, wenn ein Indexargument außerhalb des gültigen Bereichs liegt.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]]"
```
Eingeschränkte Pfad-Syntax:
```
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
Löscht die Arrays oder Objekte im Pfad.
Syntax
```
JSON.CLEAR [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
+ Ganzzahl, die Anzahl der entfernten Container.
+ Beim Löschen eines leeren Arrays oder Objekts wurde der Container 0 gelöscht.
**Anmerkung**
Vor Redis OSS Version 6.2.6.R2 wurde das Löschen eines leeren Arrays oder Objekts für einen Container gelöscht.
+ Das Löschen eines Nicht-Container-Werts gibt 0 zurück.
+ Wenn sich neben dem Pfad kein Array- oder Objektwert befindet, gibt der Befehl 0 zurück.
**Beispiele**
```
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
Informationen melden. Unterstützte Unterbefehle sind:
+ MEMORY [Pfad] — meldet die Speichernutzung eines JSON-Werts in Byte. Falls nicht angegeben, gilt der Root-Standardwert für den Pfad.
+ DEPTH [Pfad] — Meldet die maximale Pfadtiefe des JSON-Dokuments.
**Anmerkung**
Dieser Unterbefehl ist nur mit Valkey 7.2 oder höher oder der Redis OSS-Engine-Version 6.2.6.R2 oder höher verfügbar.
+ FIELDS [path] — gibt die Anzahl der Felder im angegebenen Dokumentpfad an. Falls nicht angegeben, gilt der Root-Standardwert für den Pfad. Jeder JSON-Wert, der kein Container ist, zählt als ein Feld. Objekte und Arrays zählen rekursiv ein Feld für jeden ihrer JSON-Werte. Jeder Containerwert, mit Ausnahme des Root-Containers, zählt als ein zusätzliches Feld.
+ HELP — gibt Hilfemeldungen zum Befehl aus.
Syntax
```
JSON.DEBUG
```
Hängt vom Unterbefehl ab:
MEMORY
+ Wenn der Pfad eine erweiterte Syntax ist:
+ gibt ein Array von Ganzzahlen zurück, das die Speichergröße (in Byte) des JSON-Werts in jedem Pfad darstellt.
+ gibt ein leeres Array zurück, wenn der Schlüssel nicht existiert.
+ Wenn der Pfad eine eingeschränkte Syntax hat:
+ gibt eine Ganzzahl zurück, Speichergröße den JSON-Wert in Byte.
+ gibt null zurück, wenn der Schlüssel nicht existiert.
DEPTH
+ Gibt eine Ganzzahl zurück, die die maximale Pfadtiefe des JSON-Dokuments darstellt.
+ Gibt Null zurück, wenn der Schlüssel nicht existiert.
FIELDS
+ Wenn der Pfad eine erweiterte Syntax ist:
+ gibt ein Array von Ganzzahlen zurück, das die Anzahl der Felder mit JSON-Werten in jedem Pfad darstellt.
+ gibt ein leeres Array zurück, wenn der Schlüssel nicht existiert.
+ Wenn der Pfad eine eingeschränkte Syntax hat:
+ gibt eine Ganzzahl zurück, die Anzahl der Felder des JSON-Werts.
+ gibt null zurück, wenn der Schlüssel nicht existiert.
HELP — gibt eine Reihe von Hilfemeldungen zurück.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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
```
Eingeschränkte Pfad-Syntax:
```
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
Löscht die JSON-Werte im Pfad in einem Dokumentschlüssel. Wenn der Pfad das Stammverzeichnis ist, entspricht dies dem Löschen des Schlüssels aus Valkey oder Redis OSS.
Syntax
```
JSON.DEL [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
+ Anzahl der gelöschten Elemente.
+ 0, wenn der Schlüssel nicht existiert.
+ 0, wenn der JSON-Pfad ungültig ist oder nicht existiert.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\":[]}"
```
Eingeschränkte Pfad-Syntax:
```
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
Ein Alias von [JSON.DEL](json-del.md)
# JSON.GET
Gibt das serialisierte JSON in einem oder mehreren Pfaden zurück.
Syntax
```
JSON.GET
[INDENT indentation-string]
[NEWLINE newline-string]
[SPACE space-string]
[NOESCAPE]
[path ...]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ INDENT/NEWLINE/SPACE(optional) — steuert das Format der zurückgegebenen JSON-Zeichenfolge, d. h. „pretty print“. Der Standardwert jedes einzelnen ist eine leere Zeichenfolge. Sie können in beliebiger Kombination überschrieben werden. Sie können in beliebiger Reihenfolge angegeben werden.
+ NOESCAPE — optional, darf aus Gründen der Kompatibilität mit älteren Versionen vorhanden sein und hat keine weiteren Auswirkungen.
+ path (optional) — null oder mehr JSON-Pfade, standardmäßig das Stammverzeichnis, falls keiner angegeben ist. Die Pfadargumente müssen am Ende platziert werden.
**Ergebnis**
Erweiterte Pfad-Syntax:
Wenn ein Pfad angegeben ist:
+ Gibt eine serialisierte Zeichenfolge eines Wertearrays zurück.
+ Wenn kein Wert ausgewählt ist, gibt der Befehl ein leeres Array zurück.
Wenn mehrere Pfade angegeben sind:
+ Gibt ein stringifiziertes JSON-Objekt zurück, in dem jeder Pfad ein Schlüssel ist.
+ Wenn es gemischte, erweiterte und eingeschränkte Pfadsyntax gibt, entspricht das Ergebnis der erweiterten Syntax.
+ Wenn ein Pfad nicht existiert, ist der entsprechende Wert ein leeres Array.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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]"
```
Eingeschränkte Pfad-Syntax:
```
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
Lassen Sie sich JSONs am Pfad aus mehreren Dokumentenschlüsseln serialisieren. Gibt Null zurück, wenn der Schlüssel oder der JSON-Pfad nicht existiert.
Syntax
```
JSON.MGET [key ...]
```
+ Schlüssel (erforderlich) — Ein oder mehrere Schlüssel des Dokumenttyps.
+ path (erforderlich) — ein JSON-Pfad
**Ergebnis**
+ Array von Massenzeichenfolgen. Die Größe des Arrays entspricht der Anzahl der Schlüssel im Befehl. Jedes Element des Arrays wird entweder mit (a) dem serialisierten JSON gefüllt, wie es im Pfad gefunden wird, oder (b) Null, wenn der Schlüssel nicht existiert oder der Pfad nicht im Dokument existiert oder der Pfad ungültig ist (Syntaxfehler).
+ Wenn einer der angegebenen Schlüssel existiert und kein JSON-Schlüssel ist, gibt der Befehl den Fehler `WRONGTYPE` zurück.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]"
```
Eingeschränkte Pfad-Syntax:
```
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
Erhöhen Sie die Zahlenwerte im Pfad um eine bestimmte Zahl.
Syntax
```
JSON.NUMINCRBY
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ Zahl (erforderlich) — eine Zahl
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Massenzeichenfolgen, die den resultierenden Wert für jeden Pfad darstellen.
+ Wenn ein Wert keine Zahl ist, ist der entsprechende Rückgabewert Null.
+ `WRONGTYPE`-Fehler, wenn die Zahl nicht analysiert werden kann.
+ `OVERFLOW`-Fehler, wenn das Ergebnis außerhalb des Bereichs der doppelt genauen 64-Bit-Gleitkommazahl liegt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Massenzeichenfolge, die den resultierenden Wert darstellt.
+ Wenn mehrere Werte ausgewählt wurden, gibt der Befehl das Ergebnis des zuletzt aktualisierten Arrays zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad keine Zahl ist.
+ `WRONGTYPE`-Fehler, wenn die Zahl nicht analysiert werden kann.
+ `OVERFLOW`-Fehler, wenn das Ergebnis außerhalb des Bereichs der doppelt genauen 64-Bit-Gleitkommazahl liegt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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}}"
```
Eingeschränkte Pfad-Syntax:
```
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
Multipliziert die Zahlenwerte im Pfad mit einer bestimmten Zahl.
Syntax
```
JSON.NUMMULTBY
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ Zahl (erforderlich) — eine Zahl
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Massenzeichenfolgen, die den resultierenden Wert für jeden Pfad darstellen.
+ Wenn ein Wert keine Zahl ist, ist der entsprechende Rückgabewert Null.
+ `WRONGTYPE`-Fehler, wenn die Zahl nicht analysiert werden kann.
+ `OVERFLOW`-Fehler, wenn das Ergebnis außerhalb des Bereichs der doppelt genauen 64-Bit-Gleitkommazahl liegt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Massenzeichenfolge, die den resultierenden Wert darstellt.
+ Wenn mehrere Werte ausgewählt wurden, gibt der Befehl das Ergebnis des zuletzt aktualisierten Arrays zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad keine Zahl ist.
+ `WRONGTYPE`-Fehler, wenn die Zahl nicht analysiert werden kann.
+ `OVERFLOW`-Fehler, wenn das Ergebnis außerhalb des Bereichs der doppelt genauen 64-Bit-Gleitkommazahl liegt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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]"
```
Eingeschränkte Pfad-Syntax:
```
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
Ruft die Anzahl der Schlüssel in den Objektwerten im Pfad ab.
Syntax
```
JSON.OBJLEN [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen, die die Objektlänge an jedem Pfad darstellen.
+ Wenn ein Wert kein Objekt ist, ist der entsprechende Rückgabewert null.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, Anzahl der Schlüssel im Objekt.
+ Wenn mehrere Objekte ausgewählt sind, gibt der Befehl die Länge des ersten Objekts zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Objekt ist.
+ `WRONGTYPE`-Fehler, wenn der Pfad nicht vorhanden ist.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Ruft Schlüsselnamen in den Objektwerten im Pfad ab.
Syntax
```
JSON.OBJKEYS [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Arrays von Bulk-Strings. Jedes Element ist ein Array von Schlüsseln in einem übereinstimmenden Objekt.
+ Wenn ein Wert kein Objekt ist, ist der entsprechende Rückgabewert leer.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Array von Bulk-Strings. Jedes Element ist ein Schlüsselname im Objekt.
+ Wenn mehrere Objekte ausgewählt sind, gibt der Befehl die Schlüssel des ersten Objekts zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Objekt ist.
+ `WRONGTYPE`-Fehler, wenn der Pfad nicht vorhanden ist.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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"
```
Eingeschränkte Pfad-Syntax:
```
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
Gibt den JSON-Wert im angegebenen Pfad im Valkey- oder Redis OSS Serialization Protocol (RESP) zurück. Wenn der Wert Container ist, ist die Antwort ein RESP-Array oder ein verschachteltes Array.
+ JSON null wird dem RESP Null Bulk String zugeordnet.
+ Boolesche JSON-Werte werden den jeweiligen RESP-Simple-Strings zugeordnet.
+ Ganzzahlen werden RESP-Ganzzahlen zugeordnet.
+ Doppelt genaue 64-Bit-Gleitkommazahlen werden RESP-Bulk-Strings zugeordnet.
+ JSON-Zeichenfolgen werden RESP-Bulk-Strings zugeordnet.
+ JSON-Arrays werden als RESP-Arrays dargestellt, wobei das erste Element die einfache Zeichenfolge [ist, gefolgt von den Elementen des Arrays.
+ JSON-Objekte werden als RESP-Arrays dargestellt, wobei das erste Element die einfache Zeichenfolge \$1ist, gefolgt von Schlüssel-Wert-Paaren, von denen jedes eine RESP-Bulk-String ist.
Syntax
```
JSON.RESP [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Arrays. Jedes Array-Element repräsentiert die RESP-Form des Werts in einem Pfad.
+ Leeres Array wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Array, das die RESP-Form des Werts im Pfad darstellt.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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"
```
Eingeschränkte Pfad-Syntax:
```
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
Legt JSON-Werte für den Pfad fest.
Wenn der Pfad ein Objektmitglied aufruft:
+ Wenn das übergeordnete Element nicht existiert, gibt der Befehl den Fehler NONEXISTENT zurück.
+ Wenn das übergeordnete Element existiert, aber kein Objekt ist, gibt der Befehl ERROR zurück.
+ Wenn das übergeordnete Element existiert und ein Objekt ist:
+ Wenn das Mitglied nicht existiert, wird ein neues Mitglied an das übergeordnete Objekt angehängt, wenn das übergeordnete Objekt das letzte untergeordnete Objekt im Pfad ist. Andernfalls gibt der Befehl den Fehler NONEXISTENT zurück.
+ Wenn das Mitglied existiert, wird sein Wert durch den JSON-Wert ersetzt.
Wenn der Pfad einen Array-Index aufruft:
+ Wenn das übergeordnete Element nicht existiert, gibt der Befehl den Fehler NONEXISTENT zurück.
+ Wenn das übergeordnete Element existiert, aber kein Array ist, gibt der Befehl ERROR zurück.
+ Wenn das übergeordnete Element existiert, der Index jedoch außerhalb der Grenzen liegt, gibt der Befehl den Fehler OUTOFBOUNDARIES zurück.
+ Wenn das übergeordnete Element existiert und der Index gültig ist, wird das Element durch den neuen JSON-Wert ersetzt.
Wenn der Pfad ein Objekt oder Array aufruft, wird der Wert (Objekt oder Array) durch den neuen JSON-Wert ersetzt.
Syntax
```
JSON.SET [NX | XX]
```
[NX \$1 XX] Dabei können Sie 0 oder 1 von [NX \$1 XX] -Bezeichnern haben
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — JSON-Pfad. Für einen neuen Schlüssel muss der JSON-Pfad der Stamm „.“ sein.
+ NX (optional) — Wenn es sich bei dem Pfad um das Stammverzeichnis handelt, legen Sie den Wert nur fest, wenn der Schlüssel nicht existiert, d. h. fügen Sie ein neues Dokument ein. Wenn der Pfad nicht das Stammverzeichnis ist, legen Sie den Wert nur fest, wenn der Pfad nicht existiert, d. h. fügen Sie einen Wert in das Dokument ein.
+ XX (optional) — Wenn es sich bei dem Pfad um das Stammverzeichnis handelt, legen Sie den Wert nur fest, wenn der Schlüssel vorhanden ist, d. h. ersetzen Sie das vorhandene Dokument. Wenn es sich bei dem Pfad nicht um das Stammverzeichnis handelt, legen Sie den Wert nur fest, wenn der Pfad existiert, d. h. aktualisieren Sie den vorhandenen Wert.
**Ergebnis**
+ Einfache Zeichenfolge 'OK' bei Erfolg.
+ Null, wenn die NX- oder XX-Bedingungen nicht erfüllt sind.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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]}"
```
Eingeschränkte Pfad-Syntax:
```
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
Hängt eine Zeichenfolge an die JSON-Zeichenketten im Pfad an.
Syntax
```
JSON.STRAPPEND [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
+ json\$1string (erforderlich) — JSON-Darstellung einer Zeichenfolge. Beachten Sie, dass eine JSON-Zeichenfolge in Anführungszeichen gesetzt werden muss, d. h. '"foo"'.
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Ganzzahlen, das die neue Länge der Zeichenfolge an jedem Pfad darstellt.
+ Wenn ein Wert im Pfad keine Zeichenfolge ist, ist der entsprechende Rückgabewert Null.
+ `SYNTAXERR `Fehler, wenn das Eingabe-JSON-Argument keine gültige JSON-Zeichenfolge ist.
+ `NONEXISTENT `Fehler, wenn der Pfad nicht existiert.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die neue Länge der Zeichenfolge.
+ Wenn mehrere Zeichenfolgenwerte ausgewählt wurden, gibt der Befehl die neue Länge der zuletzt aktualisierten Zeichenfolge zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad keine Zeichenfolge ist.
+ `WRONGTYPE`-Fehler, wenn das angegebene JSON-Argument keine gültige JSON-Zeichenfolge ist.
+ `NONEXISTENT`-Fehler, wenn der Pfad nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Ruft die Längen der JSON-Zeichenkettenwerte im Pfad ab.
Syntax
```
JSON.STRLEN [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Ganzzahlen, das die Länge des Zeichenkettenwerts in jedem Pfad darstellt.
+ Wenn ein Wert keine Zeichenfolge ist, ist der entsprechende Rückgabewert Null.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die Länge der Zeichenfolge.
+ Wenn mehrere Zeichenfolgenwerte ausgewählt wurden, gibt der Befehl die erste Zeichenfolgenlänge zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad keine Zeichenfolge ist.
+ `NONEXISTENT`-Fehler, wenn der Pfad nicht vorhanden ist.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Schaltet boolesche Werte im Pfad zwischen wahr und falsch um.
Syntax
```
JSON.TOGGLE [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen (0 — falsch, 1 — wahr), die den resultierenden booleschen Wert für jeden Pfad darstellen.
+ Wenn ein Wert kein boolescher Wert ist, ist der entsprechende Rückgabewert Null.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Zeichenfolge („true“ /"false“), die den resultierenden booleschen Wert darstellt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
+ `WRONGTYPE`Fehler, wenn der Wert im Pfad kein boolescher Wert ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Berichtstyp der Werte im angegebenen Pfad.
Syntax
```
JSON.TYPE [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Zeichenkettenarray, das den Typ des Werts in jedem Pfad darstellt. Typ \$1„null“, „boolean“, „string“, „number“, „integer“, „object“ und „array"\$1.
+ Wenn ein Pfad nicht existiert, ist der entsprechende Ausgabewert null.
+ Leeres Array wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Zeichenfolge, Typ des Werts
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
+ Null, wenn der JSON-Pfad ungültig ist oder nicht existiert.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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
```
Eingeschränkte Pfad-Syntax:
```
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
```