Explication détaillée des types de liste et des commandes associées dans Redis

1. Présentation :

Dans Redis, le type List est une liste chaînée de chaînes triées par ordre d'insertion. Comme une liste chaînée ordinaire dans une structure de données, nous pouvons ajouter de nouveaux éléments à sa tête (à gauche) et à sa queue (à droite). Lors de l'insertion, si la clé n'existe pas, Redis créera une nouvelle liste chaînée pour la clé. (Recommandation : Tutoriel vidéo Redis)

En revanche, si tous les éléments de la liste chaînée sont supprimés, la clé sera également supprimée de la base de données. Le nombre maximum d'éléments pouvant être contenus dans une liste est de 4294967295.

Du point de vue de l'efficacité de l'insertion et de la suppression d'éléments, si nous insérons ou supprimons des éléments aux deux extrémités de la liste chaînée, ce sera une opération très efficace, même si des millions d'enregistrements ont été stockés dans la liste chaînée. Les opérations peuvent également être réalisées en temps constant.

Cependant, il convient de noter que si l'opération d'insertion ou de suppression d'élément est effectuée au milieu de la liste chaînée, elle sera très inefficace. Je pense que ce n’est pas difficile à comprendre pour les développeurs disposant d’une bonne base de structure de données.

2. Liste des commandes associées :

Prototype de commande	Complexité temporelle	Description de la commande	Valeur de retour
Valeur de la clé LPUSH [valeur ...]	O(1)	Insérez toutes les valeurs données dans les paramètres dans l'en-tête de la valeur de liste associée à la clé spécifiée. Si la clé n'existe pas, cette commande créera une liste chaînée vide associée à la clé avant l'insertion, puis insérera les données de l'en-tête de la liste chaînée. Si la valeur de la clé n'est pas de type liste chaînée, cette commande renverra des informations d'erreur pertinentes.	Le nombre d'éléments dans la liste chaînée après insertion.
Valeur de la clé LPUSHX	O(1)	Uniquement lorsque la Clé spécifiée dans le paramètre existe, la commande lui sera associée La tête de la valeur de liste est inséré dans la valeur donnée dans le paramètre, sinon aucune opération n'aura lieu.	Le nombre d'éléments dans la liste chaînée après insertion.
Touche LRANGE start stop	O(S+N)	S dans la complexité temporelle est le décalage représenté par le paramètre de démarrage, N représente le nombre d'éléments. Les paramètres start et end de cette commande sont tous deux basés sur 0. Autrement dit, 0 représente le premier élément en tête (le plus à gauche) de la liste chaînée. La valeur de start peut également être une valeur négative, -1 représentera le dernier élément de la liste chaînée, c'est-à-dire l'élément tail, -2 représentera l'avant-dernier élément et ainsi de suite. Lorsque cette commande obtient des éléments, les éléments aux positions de début et de fin seront également supprimés. Si la valeur de start est supérieure au nombre d'éléments dans la liste chaînée, une liste chaînée vide sera renvoyée. Si la valeur de end est supérieure au nombre d'éléments, cette commande obtient tous les éléments restants de la liste chaînée à partir du début (y compris le début).	Renvoie une liste d'éléments dans la plage spécifiée.
Clé LPOP	O(1)	Retourne et affiche le premier élément de la liste chaînée associée à la clé spécifiée, c'est-à-dire l'élément de tête, . Si la clé n'existe pas, renvoyez nil.	L'élément en tête de la liste chaînée.
Clé LLEN	O(1)	Renvoie le nombre d'éléments dans la liste chaînée associée à la clé spécifiée si la clé ne le fait pas. existe, renvoie 0 . Si le type de valeur associé à la clé n'est pas une liste chaînée, les informations d'erreur pertinentes sont renvoyées.	Le nombre d'éléments dans la liste chaînée.
Valeur du nombre de clés LREM	O(N)	N en complexité temporelle représente le nombre d'éléments dans la liste chaînée. Dans la liste chaînée associée à la clé spécifiée, supprimez le premier nombre d'éléments dont la valeur est égale à value. Si le nombre est supérieur à 0, parcourez du début à la fin et supprimez. Si le nombre est inférieur à 0, parcourez de la fin au début et supprimez. Si count est égal à 0, supprimez tous les éléments de la liste chaînée qui sont égaux à value. Si la clé spécifiée n'existe pas, 0 est renvoyé directement.	Renvoie le nombre d'éléments supprimés.
Valeur de l'index de clé LSET	O(N)	N en complexité temporelle représente le nombre d'éléments dans la liste chaînée. Mais lors de la définition des éléments de tête ou de queue, la complexité temporelle est O(1). Définissez la valeur de la position spécifiée dans la liste chaînée sur la nouvelle valeur, où 0 représente le premier élément, c'est-à-dire l'élément de tête, et -1 représente l'élément de queue. Si la valeur d'index Index dépasse le nombre d'éléments dans la liste chaînée, cette commande renverra des informations d'erreur pertinentes.
Index de clé LINDEX	O(N)	N en complexité temporelle signifie qu'il doit être parcouru lors de la recherche l'élément le nombre d'éléments. Pour les éléments de tête ou de queue, sa complexité temporelle est O(1). Cette commande renverra l'élément à la position spécifiée (index) dans la liste chaînée. L'index est basé sur 0, ce qui signifie l'élément de tête. Si l'index est -1, cela signifie l'élément de queue. Si la clé n'est pas associée à une liste chaînée, cette commande renverra des informations d'erreur pertinentes.	Renvoie l'élément demandé, ou nul si l'index est hors plage.
Touche LTRIM start stop	O(N)	N représente le nombre d'éléments supprimés. Cette commande ne conservera que les éléments dans la plage spécifiée, gardant ainsi le nombre d'éléments dans le lien relativement constant. Les paramètres de démarrage et d'arrêt sont tous deux basés sur 0, 0 indiquant l'élément d'en-tête. Comme les autres commandes, start et stop peuvent également avoir des valeurs négatives et -1 représente l'élément tail. Si start est supérieur à la fin de la liste chaînée, ou si start est supérieur à stop, cette commande ne signalera pas d'erreur, mais renverra une liste chaînée vide et la clé sera supprimée en même temps. Si stop est supérieur au nombre d'éléments, tous les éléments restants depuis le début sont conservés.
Touche LINSERT AVANT|APRÈS la valeur pivot	O(N)	N dans la complexité temporelle signifie trouver le nombre d'éléments qui doivent être traversés avant que l'élément pivote. Cela signifie que si le pivot est en tête ou en queue de la liste chaînée, la complexité temporelle de cette commande est O(1). La fonction de cette commande est d'insérer la valeur de l'élément dans le paramètre avant ou après l'élément pivot. Si la clé n'existe pas, cette commande ne fera rien. Si le type de valeur associé à Key n’est pas une liste chaînée, les informations d’erreur associées seront renvoyées.	Le nombre d'éléments dans la liste chaînée après une insertion réussie. Si le pivot n'est pas trouvé, -1 est renvoyé. Si la clé n'existe pas, 0 est renvoyé.
Valeur de la clé RPUSH [valeur ...]	O(1)	Insérer les paramètres à la fin de la valeur de liste associée à la valeur spécifiée Clé de toutes les valeurs données. Si la clé n'existe pas, cette commande créera une liste chaînée vide associée à la clé avant l'insertion, puis insérera les données de la fin de la liste chaînée. Si la valeur de la clé n'est pas de type liste chaînée, cette commande renverra des informations d'erreur pertinentes.	Le nombre d'éléments dans la liste chaînée après insertion.
Valeur de la clé RPUSHX	O(1)	Uniquement lorsque la Clé spécifiée dans le paramètre existe, la commande lui sera associée La valeur donnée dans le paramètre est insérée à la fin de la valeur de la liste, sinon aucune opération n'aura lieu.	Le nombre d'éléments dans la liste chaînée après insertion.
Clé RPOP	O(1)	Retourne et affiche le dernier élément de la liste chaînée associée à la clé spécifiée, c'est-à-dire l'élément de queue. Si la clé n'existe pas, renvoyez nil.	L'élément à la fin de la liste chaînée.
RPOPLPUSH source destination	O(1)	Sélectionnez atomiquement un élément de la fin de la liste chaînée associée à la clé source, puis pop it L'élément est inséré en tête de la liste chaînée associée à la clé de destination. Si la clé source n'existe pas, la commande renverra nil et aucune autre opération ne sera effectuée. Si la source et la destination sont la même clé, cela équivaut à déplacer atomiquement l'élément tail dans sa liste chaînée associée vers la tête de la liste chaînée.	Renvoie les éléments sautés et insérés.

3. Exemples de commandes :

1. LPUSH/LPUSHX/LRANGE :

 /> redis-cli    #在Shell提示符下启动redis客户端工具。
    redis 127.0.0.1:6379> del mykey
    (integer) 1
    #mykey键并不存在，该命令会创建该键及与其关联的List，之后在将参数中的values从左到右依次插入。
    redis 127.0.0.1:6379> lpush mykey a b c d
    (integer) 4
    #取从位置0开始到位置2结束的3个元素。
    redis 127.0.0.1:6379> lrange mykey 0 2
    1) "d"
    2) "c"
    3) "b"
    #取链表中的全部元素，其中0表示第一个元素，-1表示最后一个元素。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "d"
    2) "c"
    3) "b"
    4) "a"
    #mykey2键此时并不存在，因此该命令将不会进行任何操作，其返回值为0。
    redis 127.0.0.1:6379> lpushx mykey2 e
    (integer) 0
    #可以看到mykey2没有关联任何List Value。
    redis 127.0.0.1:6379> lrange mykey2 0 -1
    (empty list or set)
    #mykey键此时已经存在，所以该命令插入成功，并返回链表中当前元素的数量。
    redis 127.0.0.1:6379> lpushx mykey e
    (integer) 5
    #获取该键的List Value的头部元素。
    redis 127.0.0.1:6379> lrange mykey 0 0
    1) "e"

2.

    redis 127.0.0.1:6379> lpush mykey a b c d
    (integer) 4
    redis 127.0.0.1:6379> lpop mykey
    "d"
    redis 127.0.0.1:6379> lpop mykey
    "c"
    #在执行lpop命令两次后，链表头部的两个元素已经被弹出，此时链表中元素的数量是2
    redis 127.0.0.1:6379> llen mykey
    (integer) 2

3. LREM/LSET/LINDEX/LTRIM :

    #为后面的示例准备测试数据。
    redis 127.0.0.1:6379> lpush mykey a b c d a c
    (integer) 6
    #从头部(left)向尾部(right)变量链表，删除2个值等于a的元素，返回值为实际删除的数量。
    redis 127.0.0.1:6379> lrem mykey 2 a
    (integer) 2
    #看出删除后链表中的全部元素。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "c"
    2) "d"
    3) "c"
    4) "b"
    #获取索引值为1(头部的第二个元素)的元素值。
    redis 127.0.0.1:6379> lindex mykey 1
    "d"
    #将索引值为1(头部的第二个元素)的元素值设置为新值e。
    redis 127.0.0.1:6379> lset mykey 1 e
    OK
    #查看是否设置成功。
    redis 127.0.0.1:6379> lindex mykey 1
    "e"
    #索引值6超过了链表中元素的数量，该命令返回nil。
    redis 127.0.0.1:6379> lindex mykey 6
    (nil)
    #设置的索引值6超过了链表中元素的数量，设置失败，该命令返回错误信息。
    redis 127.0.0.1:6379> lset mykey 6 hh
    (error) ERR index out of range
    #仅保留索引值0到2之间的3个元素，注意第0个和第2个元素均被保留。
    redis 127.0.0.1:6379> ltrim mykey 0 2
    OK
    #查看trim后的结果。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "c"
    2) "e"
    3) "c"

4. LINSERT :

    #删除该键便于后面的测试。
    redis 127.0.0.1:6379> del mykey
    (integer) 1
    #为后面的示例准备测试数据。
    redis 127.0.0.1:6379> lpush mykey a b c d e
    (integer) 5
    #在a的前面插入新元素a1。
    redis 127.0.0.1:6379> linsert mykey before a a1
    (integer) 6
    #查看是否插入成功，从结果看已经插入。注意lindex的index值是0-based。
    redis 127.0.0.1:6379> lindex mykey 0
    "e"
    #在e的后面插入新元素e2，从返回结果看已经插入成功。
    redis 127.0.0.1:6379> linsert mykey after e e2
    (integer) 7
    #再次查看是否插入成功。
    redis 127.0.0.1:6379> lindex mykey 1
    "e2"
    #在不存在的元素之前或之后插入新元素，该命令操作失败，并返回-1。
    redis 127.0.0.1:6379> linsert mykey after k a
    (integer) -1
    #为不存在的Key插入新元素，该命令操作失败，返回0。
    redis 127.0.0.1:6379> linsert mykey1 after a a2
    (integer) 0
    5. RPUSH/RPUSHX/RPOP/RPOPLPUSH:
    #删除该键，以便于后面的测试。
    redis 127.0.0.1:6379> del mykey
    (integer) 1
    #从链表的尾部插入参数中给出的values，插入顺序是从左到右依次插入。
    redis 127.0.0.1:6379> rpush mykey a b c d
    (integer) 4
    #通过lrange的可以获悉rpush在插入多值时的插入顺序。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    #该键已经存在并且包含4个元素，rpushx命令将执行成功，并将元素e插入到链表的尾部。
    redis 127.0.0.1:6379> rpushx mykey e
    (integer) 5
    #通过lindex命令可以看出之前的rpushx命令确实执行成功，因为索引值为4的元素已经是新元素了。
    redis 127.0.0.1:6379> lindex mykey 4
    "e"
    #由于mykey2键并不存在，因此该命令不会插入数据，其返回值为0。
    redis 127.0.0.1:6379> rpushx mykey2 e
    (integer) 0
    #在执行rpoplpush命令前，先看一下mykey中链表的元素有哪些，注意他们的位置关系。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    5) "e"
    #将mykey的尾部元素e弹出，同时再插入到mykey2的头部(原子性的完成这两步操作)。
    redis 127.0.0.1:6379> rpoplpush mykey mykey2
    "e"
    #通过lrange命令查看mykey在弹出尾部元素后的结果。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    #通过lrange命令查看mykey2在插入元素后的结果。
    redis 127.0.0.1:6379> lrange mykey2 0 -1
    1) "e"
    #将source和destination设为同一键，将mykey中的尾部元素移到其头部。
    redis 127.0.0.1:6379> rpoplpush mykey mykey
    "d"
    #查看移动结果。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "d"
    2) "a"
    3) "b"
    4) "c"

4. 🎜>

Pour la valeur de la structure de liste chaînée, Redis fournit quelques conseils pratiques dans sa documentation officielle, comme la commande RPOPLPUSH. Une explication spécifique est donnée ci-dessous.

Les listes chaînées Redis sont souvent utilisées dans les services de file d'attente de messages pour compléter les échanges de messages entre plusieurs programmes.

Supposons qu'une application effectue une opération LPUSH pour ajouter de nouveaux éléments à la liste chaînée. Nous appelons généralement un tel programme un "Producteur", tandis qu'une autre application effectue une opération RPOP pour ajouter de nouveaux éléments à la liste chaînée. . Pour supprimer des éléments d'un programme, nous appelons un tel programme un "Consommateur".

Si à ce moment, le programme consommateur plante immédiatement après avoir retiré l'élément de message, parce que le message a été supprimé et n'a pas été traité normalement, alors on peut penser que le message a été perdu, ce qui peut provoquer des données commerciales. Un statut commercial perdu ou incohérent se produit.

Cependant, en utilisant la commande RPOPLPUSH, le programme consommateur supprime le message de la file d'attente de messages principale, puis l'insère dans la file d'attente de sauvegarde. Il attend que le programme consommateur termine la logique de traitement normale avant de supprimer le message de. la file d'attente de sauvegarde.

Dans le même temps, nous pouvons également fournir un processus démon lorsqu'un message dans la file d'attente de sauvegarde s'avère avoir expiré, il peut être remis dans la file d'attente des messages principale afin que d'autres programmes consommateurs puissent continuer le traitement. .

Pour plus de connaissances sur Redis, veuillez faire attention à la colonne

Tutoriel d'introduction à Redis

.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!