Redis 安装和数据类型

Redis Created at 2021-07-16 23:23

## Redis 简介
Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

### Redis 与其他 key - value 缓存产品有以下三个特点：
Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。   
Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。  
Redis支持数据的备份，即master-slave模式的数据备份。

### Redis 优势
**性能极高** – Redis能读的速度是110000次/s,写的速度是81000次/s 。  
**丰富的数据类型**– Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。  
**原子** – Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行。  
**丰富的特性** – Redis还支持 publish/subscribe, 通知, key 过期等等特性。

### Redis与其他key-value存储有什么不同？
Redis有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。

Redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。

Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。 在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。  同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。

-----
  
  
## Redis 安装（Ubantu）

### 安装命令
```
sudo apt-get update
sudo apt-get install redis-server
```

### 启动 Redis
```
redis-server
```

### 查看是否启动Redis 
```
redis-cli
```

#### 以上命令将打开以下终端：
```
redis 127.0.0.1:6379>
```

#### 127.0.0.1 是本机 IP ，6379 是 redis 服务端口。现在我们输入 PING 命令。
```
redis 127.0.0.1:6379> ping
PONG
```

## Redis 配置
Redis 的配置文件位于 Redis 安装目录下，文件名为 redis.conf。  
你可以通过 CONFIG 命令查看或设置配置项。

### 编辑配置
可以通过修改 redis.conf 文件或使用 CONFIG set 命令来修改配置。

#### 语法
**CONFIG SET 命令基本语法：**

```
 redis 127.0.0.1:6379> CONFIG SET CONFIG_SETTING_NAME NEW_CONFIG_VALUE
```

**实例**
```
redis 127.0.0.1:6379> CONFIG SET loglevel "notice"
OK
redis 127.0.0.1:6379> CONFIG GET loglevel

1) "loglevel"
2) "notice"
```

## Redis 修改 访问密码

### 通过命令修改
```
# 获取密码
config get requirepass

# 设置密码
config set requirepass password

# 校验密码
auth password
```

------

## Redis 数据类型

### Redis支持五种数据类型：  
**string（字符串）**  
**hash（哈希）**  
**list（列表）**  
**set（集合）**  
**zset(sorted set：有序集合)**

----

#### 获取所有的key
```
keys "*"
```

#### 清空当前数据库
```
flushdb
```

#### 清空全部的数据
```
flushall
```

#### String（字符串）
string是redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。  
string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。  
string类型是Redis最基本的数据类型，一个键最大能存储512MB。

##### 实例

```
redis 127.0.0.1:6379> SET name "runoob"
OK
redis 127.0.0.1:6379> GET name
"runoob"
```

在以上实例中我们使用了 Redis 的**SET** 和 **GET** 命令。  
键为**name**，对应的值为 **runoob**。  
**注意：**一个键最大能存储512MB。

-----

#### Hash（哈希）
Redis hash 是一个键值对集合。  
Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。

##### 实例
```

127.0.0.1:6379> HMSET user:1 username runoob password runoob points 200
OK
127.0.0.1:6379> HGETALL user:1
1) "username"
2) "runoob"
3) "password"
4) "runoob"
5) "points"
6) "200"

```

以上实例中 hash 数据类型存储了包含用户脚本信息的用户对象。 
实例中我们使用了 Redis **HMSET**, **HGETALL** 命令，user:1 为键值。 
每个 hash 可以存储 232 -1 键值对（40多亿)

-----

### List（列表）
Redis 列表是简单的字符串列表，按照插入顺序排序。  
你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

#### 实例

```

redis 127.0.0.1:6379> lpush runoob redis 
(integer) 1

redis 127.0.0.1:6379> lpush runoob mongodb
(integer) 2

redis 127.0.0.1:6379> lpush runoob rabitmq
(integer) 3

redis 127.0.0.1:6379> lrange runoob 0 10

1) "rabitmq"
2) "mongodb"
3) "redis"

redis 127.0.0.1:6379> 
```
实例中我们使用了 Redis **HMSET**, **HGETALL** 命令，user:1 为键值。   
每个 hash 可以存储 232 -1 键值对（40多亿)

----

#### Set（集合）
Redis的Set是string类型的无序集合。   
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。

##### sadd 命令
添加一个string元素到,key对应的set集合中，成功返回1,如果元素已经在集合中返回0,key对应的set不存在返回错误。
```
sadd key member
```

#### 实例
```
redis 127.0.0.1:6379> sadd runoob redis
(integer) 1

redis 127.0.0.1:6379> sadd runoob mongodb
(integer) 1

redis 127.0.0.1:6379> sadd runoob rabitmq
(integer) 1

redis 127.0.0.1:6379> sadd runoob rabitmq
(integer) 0

redis 127.0.0.1:6379> smembers runoob

1) "rabitmq"
2) "mongodb"
3) "redis"

redis 127.0.0.1:6379>

```

##### 注意：以上实例中 rabitmq 添加了两次，但根据集合内元素的唯一性，第二次插入的元素将被忽略。 
集合中最大的成员数为 232 - 1(4294967295, 每个集合可存储40多亿个成员)。

----

### zset(sorted set：有序集合)

##### Redis zset 和 set 一样也是string类型元素的集合，且不允许重复的成员。

##### 不同的是每个元素都会关联一个double类型的分数。
##### redis正是通过分数来为集合中的成员进行从小到大的排序。
##### zset的成员是唯一的,但分数(score)却可以重复。

#### zadd 命令
添加元素到集合，元素在集合中存在则更新对应score

```
zadd key score member

```

#### 实例
```

redis 127.0.0.1:6379> zadd runoob 0 redis
(integer) 1

redis 127.0.0.1:6379> zadd runoob 0 mongodb
(integer) 1

redis 127.0.0.1:6379> zadd runoob 0 rabitmq
(integer) 1

redis 127.0.0.1:6379> zadd runoob 0 rabitmq
(integer) 0

redis 127.0.0.1:6379> zadd runoob 1 test_1
(integer) 1

redis 127.0.0.1:6379> zadd runoob 0 test_0
(integer) 1

redis 127.0.0.1:6379> ZRANGEBYSCORE runoob 0 1000

1) "redis"
2) "mongodb"
3) "rabitmq"
4) "test_0"
5) "test_1"

```

-----

## Redis 命令

Redis 命令用于在 redis 服务上执行操作。  
要在 redis 服务上执行命令需要一个 redis 客户端。  
Redis 客户端在我们之前下载的的 redis 的安装包中。

### 语法集合和集合一样也是string类型元素的集合,且不允许重复的成员。 不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。 
有序集合的成员是唯一的,但分数(score)却可以重复。 
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
Redis 客户端的基本语法为：
```
$ redis-cli
```

### 实例
以下实例讲解了如何启动 redis 客户端：  
启动 redis 客户端，打开终端并输入命令 redis-cli。该命令会连接本地的 redis 服务。

```
$redis-cli
redis 127.0.0.1:6379>
redis 127.0.0.1:6379> PING

PONG
```
在以上实例中我们连接到本地的 redis 服务并执行 PING 命令，该命令用于检测 redis 服务是否启动。

### 在远程服务上执行命令
如果需要在远程 redis 服务上执行命令，同样我们使用的也是 redis-cli 命令。

#### 语法
```
$ redis-cli -h host -p port -a password
```

#### 实例
以下实例演示了如何连接到主机为 127.0.0.1，端口为 6379 ，密码为 mypass 的 redis 服务上。
```
$redis-cli -h 127.0.0.1 -p 6379 -a "mypass"
redis 127.0.0.1:6379>
redis 127.0.0.1:6379> PING

PONG
```

----

## Redis 键(key)
Redis 键命令用于管理 redis 的键。

### 语法
Redis 键命令的基本语法如下：
```
redis 127.0.0.1:6379> COMMAND KEY_NAME
```

### 实例
```
redis 127.0.0.1:6379> SET runoobkey redis
OK
redis 127.0.0.1:6379> DEL runoobkey
(integer) 1
```
在以上实例中 **DEL** 是一个命令，** runoobkey** 是一个键。   
如果键被删除成功，命令执行后输出 (integer) 1，否则将输出 (integer) 0

----
## Redis keys 命令
下表给出了与 Redis 键相关的基本命令：

|序号|命令|描述|
|--:--|----|----|
|1|[DEL key](/redis/keys-del.html) | 该命令用于在 key 存在时删除  key。|
|2|[DUMP key](/redis/keys-dump.html) | 序列化给定 key ，并返回被序列化的值。|
|3|[EXISTS key](/redis/keys-exists.html) | 检查给定 key 是否存在。|
|4|[EXPIRE key](/redis/keys-expire.html) | seconds 为给定 key 设置过期时间。|
|5|[EXPIREAT key timestamp](/redis/keys-expireat.html) | EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置过期时间。 不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp) 。|
|6|[PEXPIRE key milliseconds](/redis/keys-pexpire.html) | 设置 key 的过期时间以毫秒计。|
|7|[PEXPIREAT key milliseconds-timestamp](/redis/keys-pexpireat.html) | 设置 key 过期时间的时间戳(unix timestamp)以毫秒计|
|8|[KEYS pattern](/redis/keys-keys.html) | 查找所有符合给定模式( pattern)的 key 。 |
|9|[MOVE key db](/redis/keys-move.html) | 将当前数据库的 key 移动到给定的数据库 db 当中。|
|10|[PERSIST key](/redis/keys-persist.html) | 移除 key 的过期时间，key 将持久保持。|
|11|[PTTL key](/redis/keys-pttl.html) | 以毫秒为单位返回 key 的剩余的过期时间。|
|12|[TTL key](/redis/keys-ttl.html) | 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live) 。|
|13|[RANDOMKEY](/redis/keys-randomkey.html) | 从当前数据库中随机返回一个 key 。 |
|14|[RENAME key newkey](/redis/keys-rename.html) | 修改 key 的名称|
|15|[RENAMENX key newkey](/redis/keys-renamenx.html) | 仅当 newkey 不存在时，将 key 改名为 newkey 。|
|16|[TYPE key](/redis/keys-type.html) | 返回 key 所储存的值的类型。|

更多命令请参考：[http://redis.readthedocs.org/en/latest/index.html](http://redis.readthedocs.org/en/latest/index.html)

-----

## Redis 字符串(String)
Redis 字符串数据类型的相关命令用于管理 redis 字符串值，基本语法如下：

### 语法
```
redis 127.0.0.1:6379> COMMAND KEY_NAME
```

### 实例
```
redis 127.0.0.1:6379> SET runoobkey redis
OK

redis 127.0.0.1:6379> GET runoobkey
"redis"

```

在以上实例中我们使用了 SET 和 GET 命令，键为 runoobkey。

### Redis 字符串命令
下表列出了常用的 redis 字符串命令：

|序号|命令|描述|
|:----|:----:|:----|
|1|[SET key value](/redis/strings-set.) | 设置指定 key 的值|
|2|[GET key](/redis/strings-get.) | 获取指定 key 的值。|
|3|[GETRANGE key start end](/redis/strings-getrange.) | 返回 key 中字符串值的子字符|
|4|[GETSET key value](/redis/strings-getset.) | 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。|
|5|[GETBIT key offset](/redis/strings-getbit.) | 对 key 所储存的字符串值，获取指定偏移量上的位(bit)。|
|6|[MGET key1 [key2..]](/redis/strings-mget.) | 获取所有(一个或多个)给定 key 的值。 |
|7|[SETBIT key offset value](/redis/strings-setbit.) | 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。|
|8|[SETEX key seconds value](/redis/strings-setex.) | 将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。|
|9|[SETNX key value](/redis/strings-setnx.) | 只有在 key 不存在时设置 key 的值。|
|10|[SETRANGE key offset value](/redis/strings-setrange.) | 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始。 |
|11|[STRLEN key](/redis/strings-strlen.) | 返回 key 所储存的字符串值的长度。|
|12|[MSET key value [key value ...]](/redis/strings-mset.) | 同时设置一个或多个 key-value 对。|
|13|[MSETNX key value [key value ...]](/redis/strings-msetnx.) | 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。|
|14|[PSETEX key milliseconds value](/redis/strings-psetex.) | 这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。|
|15|[INCR key](/redis/strings-incr.) | 将 key 中储存的数字值增一。|
|16|[INCRBY key increment](/redis/strings-incrby.) | 将 key 所储存的值加上给定的增量值（increment） 。|
|17|[INCRBYFLOAT key increment](/redis/strings-incrbyfloat.) | 将 key 所储存的值加上给定的浮点增量值（increment） 。 |
|18|[DECR key](/redis/strings-decr.) | 将 key 中储存的数字值减一。|
|19|[DECRBY key decrement](/redis/strings-decrby.) | key 所储存的值减去给定的减量值（decrement） 。 |
|20|[APPEND key value](/redis/strings-append.) | 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。 |

更多命令请参考：[http://redis.readthedocs.org/en/latest/index.html](http://redis.readthedocs.org/en/latest/index.html)

-----

### Redis 哈希(Hash)
Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。  
Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）。  
#### 实例
```
127.0.0.1:6379>  HMSET runoobkey name "redis tutorial" description "redis basic commands for caching" likes 20 visitors 23000
OK

127.0.0.1:6379>  HGETALL runoobkey

1) "name"
2) "redis tutorial"
3) "description"
4) "redis basic commands for caching"
5) "likes"
6) "20"
7) "visitors"
8) "23000"
```
在以上实例中，我们设置了 redis 的一些描述信息(name, description, likes, visitors) 到哈希表的 runoobkey 中。

### Redis hash 命令
下表列出了 redis hash 基本的相关命令：

|序号|命令|描述|
|---|---|---|
|1|[HDEL key field2 [field2]](http://www.runoob.com/redis/hashes-hdel.html) |删除一个或多个哈希表字段|
|2|[HEXISTS key field](http://www.runoob.com/redis/hashes-hexists.html) |查看哈希表 key 中，指定的字段是否存在。|
|3|[HGET key field](http://www.runoob.com/redis/hashes-hget.html) |获取存储在哈希表中指定字段的值。|
|4|[HGETALL key](http://www.runoob.com/redis/hashes-hgetall.html) |获取在哈希表中指定 key 的所有字段和值|
|5|[HINCRBY key field increment](http://www.runoob.com/redis/hashes-hincrby.html) |为哈希表 key 中的指定字段的整数值加上增量 increment 。|
|6|[HINCRBYFLOAT key field increment](http://www.runoob.com/redis/hashes-hincrbyfloat.html) |为哈希表 key 中的指定字段的浮点数值加上增量 increment 。|
|7|[HKEYS key](http://www.runoob.com/redis/hashes-hkeys.html) |获取所有哈希表中的字段|
|8|[HLEN key](http://www.runoob.com/redis/hashes-hlen.html) |获取哈希表中字段的数量|
|9|[HMGET key field1 [field2]](http://www.runoob.com/redis/hashes-hmget.html) |获取所有给定字段的值|
|10|[HMSET key field1 value1 [field2 value2 ]](http://www.runoob.com/redis/hashes-hmset.html) |同时将多个 field-value (域-值)对设置到哈希表 key 中。|
|11|[HSET key field value](http://www.runoob.com/redis/hashes-hset.html) |将哈希表 key 中的字段 field 的值设为 value 。|
|12|[HSETNX key field value](http://www.runoob.com/redis/hashes-hsetnx.html) |只有在字段 field 不存在时，设置哈希表字段的值。|
|13|[HVALS key](http://www.runoob.com/redis/hashes-hvals.html) |获取哈希表中所有值|
|14|HSCAN key cursor [MATCH pattern] [COUNT count] | 迭代哈希表中的键值对。|

更多命令请参考：[http://redis.readthedocs.org/en/latest/index.html](http://redis.readthedocs.org/en/latest/index.html)

----

## Redis 列表(List) 
Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）   
一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。

### 实例
```
redis 127.0.0.1:6379> LPUSH runoobkey redis
(integer) 1
redis 127.0.0.1:6379> LPUSH runoobkey mongodb
(integer) 2
redis 127.0.0.1:6379> LPUSH runoobkey mysql
(integer) 3
redis 127.0.0.1:6379> LRANGE runoobkey 0 10

1) "mysql"
2) "mongodb"
3) "redis"
```

在以上实例中我们使用了** LPUSH** 将三个值插入了名为 runoobkey 的列表当中。

### Redis 列表命令
下表列出了列表相关的基本命令：

|序号|命令|描述|
|---|---|---|
|1|[BLPOP key1 [key2 ] timeout](http://www.runoob.com/redis/lists-blpop.html) |移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。|
|2|[BRPOP key1 [key2 ] timeout](http://www.runoob.com/redis/lists-brpop.html) |移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。|
|3|[BRPOPLPUSH source destination timeout](http://www.runoob.com/redis/lists-brpoplpush.html) |从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。|
|4|[LINDEX key index](http://www.runoob.com/redis/lists-lindex.html) |通过索引获取列表中的元素|
|5|[LINSERT key BEFORE or AFTER pivot value](http://www.runoob.com/redis/lists-linsert.html) |在列表的元素前或者后插入元素|
|6|[LLEN key](http://www.runoob.com/redis/lists-llen.html) |获取列表长度|
|7|[LPOP key](http://www.runoob.com/redis/lists-lpop.html) |移出并获取列表的第一个元素|
|8|[LPUSH key value1 [value2]](http://www.runoob.com/redis/lists-lpush.html) |将一个或多个值插入到列表头部|
|9|[LPUSHX key value](http://www.runoob.com/redis/lists-lpushx.html) |将一个或多个值插入到已存在的列表头部|
|10|[LRANGE key start stop](http://www.runoob.com/redis/lists-lrange.html) |获取列表指定范围内的元素|
|11|[LREM key count value](http://www.runoob.com/redis/lists-lrem.html) |移除列表元素|
|12|[LSET key index value](http://www.runoob.com/redis/lists-lset.html) |通过索引设置列表元素的值|
|13|[LTRIM key start stop](http://www.runoob.com/redis/lists-ltrim.html) |对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。|
|14|[RPOP key](http://www.runoob.com/redis/lists-rpop.html) |移除并获取列表最后一个元素|
|15|[RPOPLPUSH source destination](http://www.runoob.com/redis/lists-rpoplpush.html) |移除列表的最后一个元素，并将该元素添加到另一个列表并返回|
|16|[RPUSH key value1 [value2]](http://www.runoob.com/redis/lists-rpush.html) |在列表中添加一个或多个值|
|17|[RPUSHX key value](http://www.runoob.com/redis/lists-rpushx.html) |为已存在的列表添加值|

-----

## Redis 集合(Set)

Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。   
Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。  
集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。  
 
### 实例
```

redis 127.0.0.1:6379> SADD runoobkey redis
(integer) 1

redis 127.0.0.1:6379> SADD runoobkey mongodb
(integer) 1

redis 127.0.0.1:6379> SADD runoobkey mysql
(integer) 1

redis 127.0.0.1:6379> SADD runoobkey mysql
(integer) 0

redis 127.0.0.1:6379> SMEMBERS runoobkey

1) "mysql"
2) "mongodb"
3) "redis"

```

在以上实例中我们通过 **SADD** 命令向名为 runoobkey 的集合插入的三个元素。   
 
### Redis 集合命令
|序号|命令|描述|
|---|---|---|
|1|[SADD key member1 [member2]](http://www.runoob.com/redis/sets-sadd.html)  |向集合添加一个或多个成员 |
|2|[SCARD key](http://www.runoob.com/redis/sets-scard.html)  |获取集合的成员数 |
|3|[SDIFF key1 [key2]](http://www.runoob.com/redis/sets-sdiff.html)  |返回给定所有集合的差集 |
|4|[SDIFFSTORE destination key1 [key2]](http://www.runoob.com/redis/sets-sdiffstore.html)  |返回给定所有集合的差集并存储在 destination 中 |
|5|[SINTER key1 [key2]](http://www.runoob.com/redis/sets-sinter.html)  |返回给定所有集合的交集 |
|6|[SINTERSTORE destination key1 [key2]](http://www.runoob.com/redis/sets-sinterstore.html)  |返回给定所有集合的交集并存储在 destination 中 |
|7|[SISMEMBER key member](http://www.runoob.com/redis/sets-sismember.html)  |判断 member 元素是否是集合 key 的成员 |
|8|[SMEMBERS key](http://www.runoob.com/redis/sets-smembers.html)  |返回集合中的所有成员 |
|9|[SMOVE source destination member](http://www.runoob.com/redis/sets-smove.html)  |将 member 元素从 source 集合移动到 destination 集合 |
|10|[SPOP key](http://www.runoob.com/redis/sets-spop.html)  |移除并返回集合中的一个随机元素 |
|11|[SRANDMEMBER key [count]](http://www.runoob.com/redis/sets-srandmember.html)  |返回集合中一个或多个随机数 |
|12|[SREM key member1 [member2]](http://www.runoob.com/redis/sets-srem.html)  |移除集合中一个或多个成员 |
|13|[SUNION key1 [key2]](http://www.runoob.com/redis/sets-sunion.html)  |返回所有给定集合的并集 |
|14|[SUNIONSTORE destination key1 [key2]](http://www.runoob.com/redis/sets-sunionstore.html)  |所有给定集合的并集存储在 destination 集合中 |
|15|[SSCAN key cursor [MATCH pattern] [COUNT count]](http://www.runoob.com/redis/sets-sscan.html)  |迭代集合中的元素 |

## Redis 有序集合(sorted set)
Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。 
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。 
有序集合的成员是唯一的,但分数(score)却可以重复。 
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

### 实例
```
redis 127.0.0.1:6379> ZADD runoobkey 1 redis
(integer) 1

redis 127.0.0.1:6379> ZADD runoobkey 2 mongodb
(integer) 1

redis 127.0.0.1:6379> ZADD runoobkey 3 mysql
(integer) 1

redis 127.0.0.1:6379> ZADD runoobkey 3 mysql
(integer) 0

redis 127.0.0.1:6379> ZADD runoobkey 4 mysql
(integer) 0

redis 127.0.0.1:6379> ZRANGE runoobkey 0 10 WITHSCORES

1) "redis"
2) "1"
3) "mongodb"
4) "2"
5) "mysql"
6) "4"

```

在以上实例中我们通过命令 **ZADD** 向 redis 的有序集合中添加了三个值并关联上分数。

### Redis 有序集合命令
下表列出了 redis 有序集合的基本命令:

|序号|命令|描述|
|---|---|---|
|1|[ZADD key score1 member1 [score2 member2]](http://www.runoob.com/redis/sorted-sets-zadd.html) |向有序集合添加一个或多个成员，或者更新已存在成员的分数|
|2|[ZCARD key](http://www.runoob.com/redis/sorted-sets-zcard.html) |获取有序集合的成员数|
|3|[ZCOUNT key min max](http://www.runoob.com/redis/sorted-sets-zcount.html) |计算在有序集合中指定区间分数的成员数|
|4|[ZINCRBY key increment member](http://www.runoob.com/redis/sorted-sets-zincrby.html) |有序集合中对指定成员的分数加上增量 increment|
|5|[ZINTERSTORE destination numkeys key [key ...]](http://www.runoob.com/redis/sorted-sets-zinterstore.html) |计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中|
|6|[ZLEXCOUNT key min max](http://www.runoob.com/redis/sorted-sets-zlexcount.html) |在有序集合中计算指定字典区间内成员数量|
|7|[ZRANGE key start stop [WITHSCORES]](http://www.runoob.com/redis/sorted-sets-zrange.html) |通过索引区间返回有序集合成指定区间内的成员|
|8|[ZRANGEBYLEX key min max [LIMIT offset count]](http://www.runoob.com/redis/sorted-sets-zrangebylex.html) |通过字典区间返回有序集合的成员|
|9|[ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]](http://www.runoob.com/redis/sorted-sets-zrangebyscore.html) |通过分数返回有序集合指定区间内的成员|
|10|[ZRANK key member](http://www.runoob.com/redis/sorted-sets-zrank.html) |返回有序集合中指定成员的索引|
|11|[ZREM key member [member ...]](http://www.runoob.com/redis/sorted-sets-zrem.html) |移除有序集合中的一个或多个成员|
|12|[ZREMRANGEBYLEX key min max](http://www.runoob.com/redis/sorted-sets-zremrangebylex.html) |移除有序集合中给定的字典区间的所有成员|
|13|[ZREMRANGEBYRANK key start stop](http://www.runoob.com/redis/sorted-sets-zremrangebyrank.html) |移除有序集合中给定的排名区间的所有成员|
|14|[ZREMRANGEBYSCORE key min max](http://www.runoob.com/redis/sorted-sets-zremrangebyscore.html) |移除有序集合中给定的分数区间的所有成员|
|15|[ZREVRANGE key start stop [WITHSCORES]](http://www.runoob.com/redis/sorted-sets-zrevrange.html) |返回有序集中指定区间内的成员，通过索引，分数从高到底|
|16|[ZREVRANGEBYSCORE key max min [WITHSCORES]](http://www.runoob.com/redis/sorted-sets-zrevrangebyscore.html) |返回有序集中指定分数区间内的成员，分数从高到低排序|
|17|[ZREVRANK key member](http://www.runoob.com/redis/sorted-sets-zrevrank.html) |返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序|
|18|[ZSCORE key member](http://www.runoob.com/redis/sorted-sets-zscore.html) |返回有序集中，成员的分数值|
|19|[ZUNIONSTORE destination numkeys key [key ...]](http://www.runoob.com/redis/sorted-sets-zunionstore.html) |计算给定的一个或多个有序集的并集，并存储在新的 key 中|
|20|[ZSCAN key cursor [MATCH pattern] [COUNT count]](http://www.runoob.com/redis/sorted-sets-zscan.html) |迭代有序集合中的元素（包括元素成员和元素分值）|

-----

## Redis HyperLogLog

Redis 在 2.8.9 版本添加了 HyperLogLog 结构。

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定 的、并且是很小的。

在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基 数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。

**但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。**

### 什么是基数?
比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。

### 实例
以下实例演示了 HyperLogLog 的工作过程：
```
redis 127.0.0.1:6379> PFADD runoobkey "redis"

1) (integer) 1

redis 127.0.0.1:6379> PFADD runoobkey "mongodb"

1) (integer) 1

redis 127.0.0.1:6379> PFADD runoobkey "mysql"

1) (integer) 1

redis 127.0.0.1:6379> PFCOUNT runoobkey

(integer) 3

```

## Redis HyperLogLog 命令

下表列出了 redis HyperLogLog 的基本命令：

|序号|命令|描述|
|---|---|---|
|1|[PFADD key element [element ...]](http://www.runoob.com/redis/hyperloglog-pfadd.html) |添加指定元素到 HyperLogLog 中。|
|2|[PFCOUNT key [key ...]](http://www.runoob.com/redis/hyperloglog-pfcount.html) |返回给定 HyperLogLog 的基数估算值。|
|3|[PFMERGE destkey sourcekey [sourcekey ...]](http://www.runoob.com/redis/hyperloglog-pfmerge.html) |将多个 HyperLogLog 合并为一个 HyperLogLog |

-----

Stay before every beautiful thoughts在每一个美好的思想前停留

Redis 安装和数据类型

Stay before every beautiful thoughts
在每一个美好的思想前停留