13.ReJSON模块的使用

ReJSON的官方文档： https://oss.redis.com/redisjson/commands/#jsonset
注：此文主要用于学习记录，描述并不准确，如有不对的地方请见谅

其中命令以ARR开头的均为数组命令(8、9、10、11、12、13)

1.JSON.SET命令 设置JSON对象

JSON.SET命令用于设置JSON对象，当对象不存在时，会新建一个json对象，当对象存在时，会修改或替换现有的值

语法：JSON.SET <key> <path> <json>

# 清空1库的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 查看1库中的所有数据--显示没空
127.0.0.1:6379[1]> keys *
(empty array)

# 设置新的JSON对象doc并且向json对象doc中存入键值对a:2(由于不存在键a,所以会新建)
127.0.0.1:6379[1]> JSON.set doc . '{"a":2}'
OK

# 获取到json对象doc的所有键值对数据
127.0.0.1:6379[1]> json.get doc
"{\"a\":2}"

# 获取到JSON对象doc中键a所对应的值
127.0.0.1:6379[1]> json.get doc a
"2"

# 由于json对象中已经存在键a，继续设置键a的值，会替换掉a键已有的值
127.0.0.1:6379[1]> json.set doc a '5'
OK

# 获取到json对象doc中a键的值
127.0.0.1:6379[1]> json.get doc a
"5"

# 在JSON对象doc中设置键值对b:10,由于不存在此键值对，因此会新建
127.0.0.1:6379[1]> json.set doc b '10'
OK

# 获取到json对象doc中的所有数据
127.0.0.1:6379[1]> json.get doc
"{\"a\":5,\"b\":10}"

# 获取json对象doc中键b对应的值
127.0.0.1:6379[1]> json.get doc b
"10"

2.JSON.GET命令 获取到JSON对象的数据

JSON.GET命令用于获取到JSON对象中的数据
语法：JSON.GET <key> [INDENT indentation-string] [NEWLINE line-break-string] [SPACE space-string]
其中：

• INDENT设置嵌套级别的缩进字符串-----------格式：INDENT “\t”
• NEWLINE设置在每行末尾打印的字符串------格式：NEWLINE"\n"
• SPACE设置放在键和值之间的字符串---------格式：SPACE " "

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中添加数据(键值对)
# 其中键nested中存储的也是json对象
127.0.0.1:6379[1]> json.set myjson . '{"a":2, "b":3, "nested":{"a":4, "b":null}}'
OK

# 获取到json对象myjson中键a的值
127.0.0.1:6379[1]> json.get myjson a
"2"

# 获取到json对象myjson中键b的值
127.0.0.1:6379[1]> json.get myjson b
"3"

# 获取到json对象myjson中键nested的值
127.0.0.1:6379[1]> json.get myjson nested
"{\"a\":4,\"b\":null}"

# 获取json对象myjson中键nested中json对象a键的值
127.0.0.1:6379[1]> json.get myjson nested.a
"4"
# 获取json对象myjson中键nested中json对象b键的值
127.0.0.1:6379[1]> json.get myjson nested.b
"null"

3.JSON.MGET命令 同时获得多个json对象的值

JSON.MGET命令同时获取到多个json对象的值
语法：JSON.MGET <key> [key ...]

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中写入键值对，其中键nested的值为一个json对象
127.0.0.1:6379[1]> json.set myjson . '{"a":2, "b":3, "nested":{"a":4, "b":null}}'
OK

# 新建json对象myjson1，并向myjson1中写入键值对，其中键nested的值为一个json对象
127.0.0.1:6379[1]> json.set myjson1 . '{"a":1, "b":5, "nested":{"a":6}, "c":null}'
OK

# 查看1库中的所有数据
127.0.0.1:6379[1]> keys *
1) "myjson1"
2) "myjson"

# 同时获取到json对象myjson和myjson1中键a对应的值
127.0.0.1:6379[1]> json.mget myjson myjson1 a
1) "2"
2) "1"

# 同时获取到json对象myjson和myjson1中键nested中JSON对象键a对应的值
127.0.0.1:6379[1]> json.mget myjson myjson1 nested.a
1) "4"
2) "6"

4.JSON.DEL命令 删除json对象的一个值

JSON.DEL命令是删除json对象中的一个值
语法:JSON.DEL <key> [path]

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中添加键值对，其中nested键中存在的值为一个json对象
127.0.0.1:6379[1]> json.set myjson . '{"a":1, "nested":{"a":2, "b":3}}'
OK

# 获取到json对象myjson中的所有数据(键值对)
127.0.0.1:6379[1]> json.get myjson
"{\"a\":1,\"nested\":{\"a\":2,\"b\":3}}"

# 删除json对象myjson中键a所对应的值，删除了整个键值对
127.0.0.1:6379[1]> json.del myjson a
(integer) 1

# 获取到json对象myjson中所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"nested\":{\"a\":2,\"b\":3}}"

# 删除json对象myjson中键nested对应的值(json对象)中键b所对应的值
127.0.0.1:6379[1]> json.del myjson nested.b
(integer) 1

# 获取到json对象myjson中所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"nested\":{\"a\":2}}"

5.JSON.NUMINCRBY命令 将存储的数字值递增、递减

JSON.NUMINCRBY命令用于将json对象中存储的键值对中键对应的值数字递增，只能对键对应的值为数字进行操作，如果键对应的值对象不是数字，会报错；
此适用于数字类型
如果数字是负数，则会进行递减操作

语法：JSON.NUMINCRBY <key> <path> <number>

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中存储键值对，其中键b对应的值为一个列表，列表中存储了3个json对象
127.0.0.1:6379[1]> json.set myjson . '{"a":"b", "b":[{"a":2}, {"a":5}, {"a":"c"}]}'
OK

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":\"b\",\"b\":[{\"a\":2},{\"a\":5},{\"a\":\"c\"}]}"

# 对json对象myjson中键b对应的值列表中位置标号为0的json对象中的键a对应的值进行自增加2
127.0.0.1:6379[1]> json.numincrby myjson b[0].a 2
"4"

# 获取到json对象myjson中所有的键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":\"b\",\"b\":[{\"a\":4},{\"a\":5},{\"a\":\"c\"}]}"

# 对json对象myjson中键b对应的值列表中位置标号为1的json对象中的键a对应的值进行自增加5
127.0.0.1:6379[1]> json.numincrby myjson b[1].a 5
"10"

# 获取到json对象myjson中所有的键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":\"b\",\"b\":[{\"a\":4},{\"a\":10},{\"a\":\"c\"}]}"

6.JSON.STRAPPEND命令 将值追加到键所对应的值后

JSON.STRAPPEND命令用于将附加的字符串追加到json对象键所对应的值后.
此适用于值为字符串类型

语法：JSON.STRAPPEND <key> [path] <json-string>

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中添加键值对，其中键nested和键nested2所对应的值均为json对象
127.0.0.1:6379[1]> json.set myjson . '{"a":"foo", "nested":{"a":"hello"}, "nested2":{"a":31}}'
OK

# 向myjson中的键a所对应的值后面添加字符串aaa，返回键a对应的值的长度
127.0.0.1:6379[1]> json.strappend myjson a '"aaa"'
(integer) 6

# 获取到json对象myjson中键a所对应的值
127.0.0.1:6379[1]> json.get myjson a
"\"fooaaa\""

# 向myjson中的键nested所对应的值json对象中的键a对应的值后添加字符串xxx
127.0.0.1:6379[1]> json.strappend myjson nested.a '"xxx"'
(integer) 8

# 获取到json对象myjson中键nested对应的值的json对象中键a所对应的值
127.0.0.1:6379[1]> json.get myjson nested.a
"\"helloxxx\""

# 获取到json对象myjson的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":\"fooaaa\",\"nested\":{\"a\":\"helloxxx\"},\"nested2\":{\"a\":31}}"

7.JSON.STRLEN命令 用来获取json对象中键所对应值的字符串长度

JSON.STRLEN命令用于获取json对象中键所对应值的字符串长度
此适用于字符串类型

语法：JSON.STRLEN <key> [path]

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中存入键值对，其中键nested和键nested2中的数据类型为json对象
127.0.0.1:6379[1]> json.set myjson . '{"a":"foo", "nested":{"a":"hello"}, "nested2":{"a":31}}'
OK

# 获取json对象myjson中的键a对应值的长度
127.0.0.1:6379[1]> json.strlen myjson a
(integer) 3

# 获取json对象myjson中键nested中的json对象中键a对应值的长度
127.0.0.1:6379[1]> json.strlen myjson nested.a
(integer) 5

8.JSON.ARRAPPEND命令 用于将值添加到json数组中的最后一个元素之后

JSON.ARRAPPEND命令用于将值添加到json对象中数组的最后一个元素之后
此命令适用于数组类型也就是列表类型

语法：JSON.ARRAPPEND <key> <path> <json> [json ...]

# 清空1库中的所有内容
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中存入键值对，其中键nested对应的值为数组列表类型，键nested2对应的值为json类型
127.0.0.1:6379[1]> json.set myjson . '{"a":[1], "nested":{"a":[1, 2]}, "nested2":{"a":42}}'
OK

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[1],\"nested\":{\"a\":[1,2]},\"nested2\":{\"a\":42}}"

# 向json对象myjson中的键a对应的值的数组的最后一位元素后添加元素3,4，返回数组的长度
127.0.0.1:6379[1]> json.arrappend myjson a 3 4
(integer) 3

# 获取到json对象myjson中所有的键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[1,3,4],\"nested\":{\"a\":[1,2]},\"nested2\":{\"a\":42}}"

# 向json对象myjson中键nested对应值的数组的最后一位元素后添加元素5,7，返回数组的长度
127.0.0.1:6379[1]> json.arrappend myjson nested.a 5 7
(integer) 4

# 获取到json对象myjson中所有的键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[1,3,4],\"nested\":{\"a\":[1,2,5,7]},\"nested2\":{\"a\":42}}"

# 向json对象myjson中键nested2对应值的最后一位元素后添加元素8,9--报错，原因是类型错误
# arrappend命令适用于数组列表，而键nested对应的值的数据类型为json对象，所以报错
127.0.0.1:6379[1]> json.arrappend myjson nested2.a 8 9
(error) ERR wrong type of path value - expected array but found integer

9.JSON.ARRINDEX命令用于搜索数组中第一次出现值的位置(切片)

JSON.ARRINDEX命令用于搜索数组中第一次出现值的位置(位置为切片，正数从前到后，负数从后到前，从0开始)

语法：JSON.ARRINDEX <key> <path> <json-scalar> [start [stop]]

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中写入键值对，其中键a对应的值为数组列表，键nested对应的值为json对象，此json对象中键a存入了一个数组
127.0.0.1:6379[1]> json.set myjson . '{"a":[1,2,3,2], "nested":{"a":[3,4,5,7]}}'
OK

# 查看json对象myjson中第一次出现数字1的位置
127.0.0.1:6379[1]> json.arrindex myjson a 1
(integer) 0

# 查看json对象myjson中第一次出现数字2的位置
127.0.0.1:6379[1]> json.arrindex myjson a 2
(integer) 1

# 查看json对象myjson中第一出现数字3的位置
127.0.0.1:6379[1]> json.arrindex myjson a 3
(integer) 2

# 查看json对象myjson中第一出线数字4的位置
127.0.0.1:6379[1]> json.arrindex myjson a 4
(integer) -1

# 查看json对象myjson中第一出线数字5的位置
127.0.0.1:6379[1]> json.arrindex myjson a 5
(integer) -1

10.JSON.ARRINSERT命令将对象插入到数组中指定的位置

JSON.ARRINSERT命令用于将对象插入到数组中指定的位置的左侧，且索引必须在数组的范围内，并且按照切片的规则(正数从左到右的顺序，负数从右到左的顺序，位置0为首位，位置-1为最后一位)

语法：JSON.ARRINSERT <key> <path> <index> <json> [json ...]

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中存入键值对，其中键a对应的值为数组，键nested中存入的值为json对象，json对象中键a中存入数组
127.0.0.1:6379[1]> json.set myjson . '{"a":[3], "nested":{"a":[3,4]}}'
OK

# 获取到json对象myjson的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[3],\"nested\":{\"a\":[3,4]}}"

# 向json对象myjson中键a对应值的数组的0位置之前添加元素1,2，并返回数组的长度
127.0.0.1:6379[1]> json.arrinsert myjson a 0 1 2
(integer) 3

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[1,2,3],\"nested\":{\"a\":[3,4]}}"

# 向json对象myjson中键a对应值的数组的-2位置处的左侧添加元素5,6，并返回数组的长度
127.0.0.1:6379[1]> json.arrinsert myjson a -2 5 6
(integer) 5

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[1,5,6,2,3],\"nested\":{\"a\":[3,4]}}"

# 向json对象myjson键nested中json对象的键a中的数组位置-2的左侧添加元素5,6-返回数组的长度
127.0.0.1:6379[1]> json.arrinsert myjson nested.a -2 5 6
(integer) 4

# 回去到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[1,5,6,2,3],\"nested\":{\"a\":[5,6,3,4]}}"

11.JSON.ARRLEN命令 用于返回json对象中数组的长度

JSON.ARRLEN命令用于返回json对象中键所对应值的数组的长度
此命令适用于数组

语法：JSON.ARRLEN <key> [path]

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中存入键值对，其中键a对应的值为数据，键nested对应的值为json对象，并且此json对象中键a对应的值为数组
127.0.0.1:6379[1]> json.set myjson . '{"a":[3], "nested":{"a":[3,4]}}'
OK

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[3],\"nested\":{\"a\":[3,4]}}"

# 获取到json对象myjson中键a对应值中数组的长度，返回的值为数组的长度
127.0.0.1:6379[1]> json.arrlen myjson a
(integer) 1

# 获取到json对象myjson中键nested中键a对应值数组的长度，返回的值为数组的长度
127.0.0.1:6379[1]> json.arrlen myjson nested.a
(integer) 2

12.JSON.ARRPOP命令用于从数组的索引中移除并返回一个元素

JSON.ARRPOP命令用于从数组的索引中移除并返回一个元素，不带索引的情况下默认为移除并返回数组的最后一个元素

语法：JSON.ARRPOP <key> [path [index]]

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中存入键值对，其中键a中存入的值为数组
# 键nested中存入的值为json对象，且JSON对象中键a对应的值也为数组
127.0.0.1:6379[1]> json.set myjson . '{"a":[3,4,5], "nested":{"a":[7,8,9]}}'
OK

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[3,4,5],\"nested\":{\"a\":[7,8,9]}}"

# 移除并返回json对象myjson中键a对应值的数组中的最后一个元素(由于没说明索引，默认为最后一个元素)
127.0.0.1:6379[1]> json.arrpop myjson a
"5"

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[3,4],\"nested\":{\"a\":[7,8,9]}}"

# 移除并返回json对象myjson中键nested中json对象键a对应的值数组中的最后一个元素
127.0.0.1:6379[1]> json.arrpop myjson nested.a 
"9"

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[3,4],\"nested\":{\"a\":[7,8]}}"

# 移除并返回json对象myjson中键a对应值的数组中位置为1的元素
127.0.0.1:6379[1]> json.arrpop myjson nested.a 1 
"8"

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[3,4],\"nested\":{\"a\":[7]}}"

# 移除并返回JSON对象myjson中键nested中的json对象键a对应数组中位置为0的元素
127.0.0.1:6379[1]> json.arrpop myjson a 0 
"3"

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[4],\"nested\":{\"a\":[7]}}"

13.JSON.ARRTRIM命令 用于修剪数组，使其仅包含指定范围内的元素

JSON.ARRTRIM命令用于修剪数组，使其仅仅包含指定的包含范围内的元素

语法：JSON.ARRTRIM <key> <path> <start> <stop>

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中添加键值对，其中键A中存入数组，键nested中存入json对象，此json对象中键a存入数组
127.0.0.1:6379[1]> json.set myjson . '{"A":[2,4,6,8,10], "nested":{"a":[1,3,5]}}'
OK

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"A\":[2,4,6,8,10],\"nested\":{\"a\":[1,3,5]}}"

# 修剪json对象myjson中键A的值，只包含索引值为[1,3]的元素(位置1到位置3)
127.0.0.1:6379[1]> json.arrtrim myjson A 1 3
(integer) 3

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"A\":[4,6,8],\"nested\":{\"a\":[1,3,5]}}"

# 修剪json对象myjson中键nested中JSON对象中的键a的值，使其只包含索引值为[0,-2]的元素
127.0.0.1:6379[1]> json.arrtrim myjson nested.a 0 -2
(integer) 2

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"A\":[4,6,8],\"nested\":{\"a\":[1,3]}}"

14.JSON.OBJKEYS命令返回json对象中的所有键

JSON.OBJKEYS命令用于返回json对象中的所有键

语法：JSON.OBJKEYS <key> [path]

# 清空1库中的所有数据
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中存入键值对
# 其中键a中存入一个数组，键nested中存入json对象，此json对象中键a中也存入一个json对象
127.0.0.1:6379[1]> json.set myjson . '{"a":[3], "nested":{"a":{"b":2, "c":1}}}'
OK

# 获取到json对象myjson中的所有键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":[3],\"nested\":{\"a\":{\"b\":2,\"c\":1}}}"

# 获取到json对象myjson中的所有键
127.0.0.1:6379[1]> json.objkeys myjson 
1) "a"
2) "nested"

# 获取到json对象myjson中键nested中存入json对象的所有键
127.0.0.1:6379[1]> json.objkeys myjson nested
1) "a"

# 获取到json对象myjson中键nested中键a中存入的json对象的所有键
127.0.0.1:6379[1]> json.objkeys myjson nested.a
1) "b"
2) "c"

15.JSON.TYPE命令 用于返回json对象中对应值的类型

JSON.TYPE命令用于返回json对象中对应值的类型

语法：JSON.TYPE <key> [path]

# 清空1库中的所有内容
127.0.0.1:6379[1]> flushdb
OK

# 新建json对象myjson，并向myjson中存入数据，其中键a中存入数字类型，键nested中存入json对象
# 键foo中存入字符串类型，键x中存入数组类型
127.0.0.1:6379[1]> json.set myjson . '{"a":2, "nested":{"a":true}, "foo":"bar", "x":[1,2,3]}'
OK

# 获取到json对象myjson中的所有数据-键值对
127.0.0.1:6379[1]> json.get myjson
"{\"a\":2,\"nested\":{\"a\":true},\"foo\":\"bar\",\"x\":[1,2,3]}"

# 获取到myjson对象的类型，json对象返回object
127.0.0.1:6379[1]> json.type myjson
object

# 获取到myjson对象向中键a中存入的数据类型-integer(整数)
127.0.0.1:6379[1]> json.type myjson a
integer

# 获取到myjson对象中键nested中存入的数据类型-object-json对象
127.0.0.1:6379[1]> json.type myjson nested
object

# 获取到myjson对象中键nested中json对象中键a中存入的数据类型-boolean(布尔类型)
127.0.0.1:6379[1]> json.type myjson nested.a
boolean

# 获取到myjson对象中键foo中存入的数据类型-string(字符串)
127.0.0.1:6379[1]> json.type myjson foo
string

# 获取到myjson对象中键x中存入的数据类型-数组(array)
127.0.0.1:6379[1]> json.type myjson x
array