Tutoriel Redis (5) : Définir le type de données

1. Présentation :

Dans Redis, nous pouvons considérer le type Set comme une collection de caractères non triés. Comme le type List, nous pouvons également ajouter, supprimer ou supprimer des valeurs de données de ce type. Déterminez si un élément existe et d'autres opérations. Il convient de noter que la complexité temporelle de ces opérations est O(1), c'est-à-dire que les opérations sont réalisées en temps constant. Le nombre maximum d’éléments qu’un Set peut contenir est 4294967295.
Contrairement au type List, les éléments en double ne sont pas autorisés dans la collection Set, qui est exactement la même que le conteneur set de la bibliothèque standard C. Autrement dit, si vous ajoutez plusieurs fois le même élément, une seule copie de l’élément sera conservée dans le Set. Par rapport au type List, le type Set possède également une fonctionnalité fonctionnelle très importante, c'est-à-dire que les opérations de calcul d'agrégation entre plusieurs Sets, telles que les unions, les intersections et les différences, sont effectuées côté serveur. Étant donné que ces opérations sont effectuées côté serveur, elles sont extrêmement efficaces et permettent d’économiser beaucoup de frais d’E/S réseau.

2. Liste des commandes associées :

. SINTERSTOREdestination key [key ...] Le N dans la complexité temporelle représente le nombre total de membres dans tous les ensembles. Cette commande renverra l'union de. membres dans les ensembles associés à toutes les clés du paramètre Set Renvoie le nombre de membres du syndicat.

3. Exemples de commandes :

1. SADD/SMEMBERS/SCARD/SISMEMBER :

#在Shell命令行下启动Redis的客户端程序。
    /> redis-cli
    #插入测试数据，由于该键myset之前并不存在，因此参数中的三个成员都被正常插入。
    redis 127.0.0.1:6379> sadd myset a b c
    (integer) 3
    #由于参数中的a在myset中已经存在，因此本次操作仅仅插入了d和e两个新成员。
    redis 127.0.0.1:6379> sadd myset a d e
    (integer) 2
    #判断a是否已经存在，返回值为1表示存在。
    redis 127.0.0.1:6379> sismember myset a
    (integer) 1
    #判断f是否已经存在，返回值为0表示不存在。
    redis 127.0.0.1:6379> sismember myset f
    (integer) 0
    #通过smembers命令查看插入的结果，从结果可以，输出的顺序和插入顺序无关。
    redis 127.0.0.1:6379> smembers myset
    1) "c"
    2) "d"
    3) "a"
    4) "b"
    5) "e"
    #获取Set集合中元素的数量。
    redis 127.0.0.1:6379> scard myset
    (integer) 5

2. SPOP/SREM/SRANDMEMBER/SMOVE :

#删除该键，便于后面的测试。
    redis 127.0.0.1:6379> del myset
    (integer) 1
    #为后面的示例准备测试数据。
    redis 127.0.0.1:6379> sadd myset a b c d
    (integer) 4
    #查看Set中成员的位置。
    redis 127.0.0.1:6379> smembers myset
    1) "c"
    2) "d"
    3) "a"
    4) "b"
    #从结果可以看出，该命令确实是随机的返回了某一成员。
    redis 127.0.0.1:6379> srandmember myset
    "c"
    #Set中尾部的成员b被移出并返回，事实上b并不是之前插入的第一个或最后一个成员。
    redis 127.0.0.1:6379> spop myset
    "b"
    #查看移出后Set的成员信息。
    redis 127.0.0.1:6379> smembers myset
    1) "c"
    2) "d"
    3) "a"
    #从Set中移出a、d和f三个成员，其中f并不存在，因此只有a和d两个成员被移出，返回为2。
    redis 127.0.0.1:6379> srem myset a d f
    (integer) 2
    #查看移出后的输出结果。
    redis 127.0.0.1:6379> smembers myset
    1) "c"
    #为后面的smove命令准备数据。
    redis 127.0.0.1:6379> sadd myset a b
    (integer) 2
    redis 127.0.0.1:6379> sadd myset2 c d
    (integer) 2
    #将a从myset移到myset2，从结果可以看出移动成功。
    redis 127.0.0.1:6379> smove myset myset2 a
    (integer) 1
    #再次将a从myset移到myset2，由于此时a已经不是myset的成员了，因此移动失败并返回0。
    redis 127.0.0.1:6379> smove myset myset2 a
    (integer) 0
    #分别查看myset和myset2的成员，确认移动是否真的成功。
    redis 127.0.0.1:6379> smembers myset
    1) "b"
    redis 127.0.0.1:6379> smembers myset2
    1) "c"
    2) "d"
    3) "a"

3. SDIFF/SDIFFSTORE/SINTER/SINTERSTORE :

 #为后面的命令准备测试数据。
    redis 127.0.0.1:6379> sadd myset a b c d
    (integer) 4
    redis 127.0.0.1:6379> sadd myset2 c
    (integer) 1
    redis 127.0.0.1:6379> sadd myset3 a c e
    (integer) 3
    #myset和myset2相比，a、b和d三个成员是两者之间的差异成员。再用这个结果继续和myset3进行差异比较，b和d是myset3不存在的成员。
    redis 127.0.0.1:6379> sdiff myset myset2 myset3
    1) "d"
    2) "b"
    #将3个集合的差异成员存在在diffkey关联的Set中，并返回插入的成员数量。
    redis 127.0.0.1:6379> sdiffstore diffkey myset myset2 myset3
    (integer) 2
    #查看一下sdiffstore的操作结果。
    redis 127.0.0.1:6379> smembers diffkey
    1) "d"
    2) "b"
    #从之前准备的数据就可以看出，这三个Set的成员交集只有c。
    redis 127.0.0.1:6379> sinter myset myset2 myset3
    1) "c"
    #将3个集合中的交集成员存储到与interkey关联的Set中，并返回交集成员的数量。
    redis 127.0.0.1:6379> sinterstore interkey myset myset2 myset3
    (integer) 1
    #查看一下sinterstore的操作结果。
    redis 127.0.0.1:6379> smembers interkey
    1) "c"
    #获取3个集合中的成员的并集。    
    redis 127.0.0.1:6379> sunion myset myset2 myset3
    1) "b"
    2) "c"
    3) "d"
    4) "e"
    5) "a"
    #将3个集合中成员的并集存储到unionkey关联的set中，并返回并集成员的数量。
    redis 127.0.0.1:6379> sunionstore unionkey myset myset2 myset3
    (integer) 5
    #查看一下suiionstore的操作结果。
    redis 127.0.0.1:6379> smembers unionkey
    1) "b"
    2) "c"
    3) "d"
    4) "e"
    5) "a"

4. Champ d'application :

1). Redis Le type de données Set suit certaines données uniques, telles que les informations d'adresse IP uniques qui visitent un certain blog. Pour ce scénario, il nous suffit de stocker l'adresse IP du visiteur dans Redis à chaque fois que nous visitons le blog, et le type de données Définir garantira automatiquement l'unicité de l'adresse IP.
2). Profitez pleinement des fonctionnalités pratiques et efficaces des opérations d'agrégation côté serveur de type Set, qui peuvent être utilisées pour maintenir l'association entre les objets de données. Par exemple, tous les identifiants client qui achètent un certain appareil électronique sont stockés dans un ensemble spécifié, et les identifiants client qui achètent un autre produit électronique sont stockés dans un autre ensemble. Si à ce moment nous voulons savoir quels clients ont acheté celui-ci en même temps, Lorsqu'il y a deux produits, la commande des intersections de Set peut faire jouer pleinement ses avantages de commodité et d'efficacité.

Ce qui précède est le contenu du didacticiel Redis (5) : Définir le type de données. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !

Prototype de commande	Complexité temporelle	Description de la commande	Valeur de retour
Membre SADDkey [membre ...]	O(N)	Le N dans la complexité temporelle représente le nombre de membres de l'opération. S'ils sont utilisés pendant le processus d'insertion, certains membres des paramètres existent déjà dans l'ensemble, le membre sera ignoré et les autres membres seront toujours insérés normalement. Si la Clé n'existe pas avant d'exécuter cette commande, cette commande créera un nouvel Ensemble, puis insérera les membres dans les paramètres les uns après les autres. Si la valeur de la clé n'est pas de type Set, cette commande renverra des informations d'erreur pertinentes.	Le nombre de membres réellement insérés dans cette opération.
SCARDkey	O(1)	Obtenir le nombre de membres dans l'ensemble.	Renvoie le nombre de membres dans l'ensemble. Si la clé n'existe pas, renvoie 0.
Membre de clé SISMEMBER	O(1)	Déterminez si le membre spécifié dans le paramètre existe déjà dans la collection Set associée à la clé.	1 signifie qu'elle existe déjà, 0 signifie qu'elle n'existe pas ou que la clé elle-même n'existe pas.
Touche SMEMBERS	O(N)	Le N dans la complexité temporelle représente le nombre de membres qui existent déjà dans l'ensemble. Obtenez tous les membres de l’ensemble associé à la clé.	Renvoie tous les membres de l'ensemble.
SPOPkey	O(1)	Supprime et renvoie de manière aléatoire un membre de l'ensemble. Étant donné que la disposition des éléments d'un Set n'est pas contrôlée de l'extérieur, il est impossible de déterminer quel élément se trouve en tête ou en queue du Set comme une Liste.	Renvoie le membre supprimé, ou nul si la clé n'existe pas.
Membre SREMkey [membre ...]	O(N)	Le N dans la complexité temporelle représente le nombre de membres supprimés. Supprimez le membre spécifié dans le paramètre de l’ensemble associé à la clé. Les membres du paramètre qui n’existent pas seront ignorés. Si la clé n’existe pas, elle sera traitée comme un ensemble vide.	Le nombre de membres réellement supprimés de l'ensemble, ou 0 s'il n'y en a aucun.
Clé SRANDMEMBER	O(1)	Identique à SPOP, renvoie aléatoirement un membre de l'ensemble. La différence est que cette commande ne le fait pas. Les membres revenus seront supprimés.	Renvoie le membre à une position aléatoire, ou nulle si la Clé n'existe pas.
Membre de destination SMOVEsource	O(1)	Déplacer atomiquement le membre dans le paramètre de la clé source vers l'ensemble associé à la clé de destination milieu. Ainsi, à un moment donné, le membre apparaît soit dans la source, soit dans la destination. Si le membre n'existe pas dans la source, cette commande n'effectuera aucune autre opération et renverra 0, sinon le membre sera déplacé de la source vers la destination. Si le membre existe déjà dans la destination à ce moment-là, cette commande supprime uniquement le membre de la source.Si la valeur associée à la clé n'est pas un ensemble, les informations d'erreur pertinentes seront renvoyées.	1 signifie un mouvement normal, 0 signifie que la source ne contient pas de membres de paramètre
SDIFFkey [key ...]	O(N)	Le N en complexité temporelle représente le nombre total de membres dans tous les ensembles. Renvoie la différence entre les membres du Set associé à la première Key du paramètre et les Sets associés à toutes les Keys suivantes. Si Key n’existe pas, elle est considérée comme un Set vide.	Une collection de membres de résultat de différence
SDIFFSTOREDestination key [key ...]	O(N	Cette commande et SDIFF Les commandes sont fonctionnellement identiques, la seule différence entre les deux est que SDIFF renvoie le membre résultat de la différence, alors que cette commande stocke le membre de différence dans l'ensemble associé à la destination. Si la clé de destination existe déjà, cette opération l'écrase. membres	Renvoyer le nombre de membres de différence
SINTERkey [clé ...]	O(N*M)	Time. N en complexité représente le nombre d'éléments dans l'ensemble minimum, et M représente le nombre d'ensembles dans le paramètre. Cette commande renverra l'intersection des membres dans les ensembles associés à toutes les clés du paramètre. l'ensemble associé à n'importe quelle clé du paramètre est vide, ou une clé n'existe pas, alors le résultat de cette commande sera un ensemble vide	L'ensemble des membres du résultat de l'intersection
O(N*M)	Cette commande est fonctionnellement identique à la commande SINTER La seule différence entre les deux est que SINTER renvoie les membres résultat de. l'intersection, tandis que cette commande renvoie les membres de l'intersection stockés dans l'ensemble associé à la destination. Si la clé de destination existe déjà, cette opération écrasera ses membres	Renvoie le nombre de membres de l'intersection. 🎜>SUNION key [key] ...]	O(N)
L'ensemble des membres du résultat de l'union	SUNIONSTOREdestination key [key ...]	O(N)	Cette commande est fonctionnellement identique à la commande SUNION. La seule différence entre les deux est que SUNION renvoie le résultat des membres de l'union, tandis que cette commande stocke les membres de l'union dans l'ensemble associé à la destination. La clé de destination existe déjà. L'opération écrasera ses membres