workerman-redis

Introduction

workeman/redis est un composant redis asynchrone basé sur workerman.

Remarque
L'objectif principal de ce projet est de réaliser des souscriptions asynchrones à redis (subscribe, pSubscribe).
Étant donné que redis est suffisamment rapide, il n'est pas nécessaire d'utiliser ce client asynchrone sauf si vous avez besoin de psubscribe ou subscribe pour des abonnements asynchrones. L'utilisation de l'extension redis offrira de meilleures performances.

Installation :

composer require workerman/redis ^v2.0.3

Utilisation avec rappel

use Workerman\Worker;
use Workerman\Redis\Client;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';

$worker = new Worker('http://0.0.0.0:6161');

$worker->onWorkerStart = function() {
    global $redis;
    $redis = new Client('redis://127.0.0.1:6379');
};

$worker->onMessage = function(TcpConnection $connection, $data) {
    global $redis;
    $redis->set('key', 'hello world');    
    $redis->get('key', function ($result) use ($connection) {
        $connection->send($result);
    });  
};

Worker::runAll();

Utilisation avec les coroutines

Remarque
L'utilisation des coroutines nécessite workerman>=5.0, workerman/redis>=2.0.0 et l'installation de composer require revolt/event-loop ^1.0.0.

use Workerman\Worker;
use Workerman\Redis\Client;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';

$worker = new Worker('http://0.0.0.0:6161');

$worker->onWorkerStart = function() {
    global $redis;
    $redis = new Client('redis://127.0.0.1:6379');
};

$worker->onMessage = function(TcpConnection $connection, $data) {
    global $redis;
    $redis->set('key', 'hello world');    
    $result = $redis->get('key');
    $connection->send($result);
};

Worker::runAll();

Lorsque vous ne définissez pas de fonction de rappel, le client renverra le résultat de la requête asynchrone de manière synchrone. Le processus de demande ne bloque pas le processus actuel, ce qui signifie que vous pouvez traiter les requêtes de manière concurrente.

Remarque
psubscribe subscribe ne prend pas en charge l'utilisation des coroutines.

Documentation

Instructions

En mode de rappel, la fonction de rappel prend généralement 2 paramètres ($result, $redis), où $result représente le résultat et $redis est l'instance redis. Par exemple :

use Workerman\Redis\Client;
$redis = new Client('redis://127.0.0.1:6379');
// Définir une fonction de rappel pour vérifier le résultat de l'appel set
$redis->set('key', 'value', function ($result, $redis) {
    var_dump($result); // true
});
// Les fonctions de rappel sont généralement des paramètres optionnels, ici nous avons omis la fonction de rappel
$redis->set('key1', 'value1');
// Les fonctions de rappel peuvent être imbriquées
$redis->get('key', function ($result, $redis){
    $redis->set('key2', 'value2', function ($result) {
        var_dump($result);
    });
});

Connexion

use Workerman\Redis\Client;
// Rappel omis
$redis = new Client('redis://127.0.0.1:6379');
// Avec rappel
$redis = new Client('redis://127.0.0.1:6379', [
    'connect_timeout' => 10 // Définir un délai de connexion de 10 secondes, par défaut 5 secondes
], function ($success, $redis) {
    // Rappel du résultat de connexion
    if (!$success) echo $redis->error();
});

auth

// Authentification par mot de passe
$redis->auth('password', function ($result) {

});
// Authentification par nom d'utilisateur et mot de passe
$redis->auth('username', 'password', function ($result) {

});

pSubscribe

Abonnez-vous à un ou plusieurs canaux correspondant à un motif donné.

Chaque motif utilise comme caractère de correspondance, par exemple it correspond à tous les canaux qui commencent par it ( it.news, it.blog, it.tweets, etc.). news.* correspond à tous les canaux qui commencent par news. ( news.it, news.global.today, etc.), etc.

Notez que la fonction de rappel de pSubscribe a 4 paramètres ($pattern, $channel, $message, $redis)

Lorsque l'instance $redis appelle les interfaces pSubscribe ou subscribe, les autres méthodes ne seront pas prises en compte.

$redis = new Client('redis://127.0.0.1:6379');
$redis2 = new Client('redis://127.0.0.1:6379');
$redis->psubscribe(['news*', 'blog*'], function ($pattern, $channel, $message) {
    echo "$pattern, $channel, $message"; // news*, news.add, news content
});

Timer::add(5, function () use ($redis2){
    $redis2->publish('news.add', 'news content');
});

subscribe

Utilisé pour s'abonner aux informations d'un ou plusieurs canaux donnés.

Notez que la fonction de rappel de subscribe a 3 paramètres ($channel, $message, $redis)

Lorsque l'instance $redis appelle les interfaces pSubscribe ou subscribe, les autres méthodes ne seront pas prises en compte.

$redis = new Client('redis://127.0.0.1:6379');
$redis2 = new Client('redis://127.0.0.1:6379');
$redis->subscribe(['news', 'blog'], function ($channel, $message) {
    echo "$channel, $message"; // news, news content
});

Timer::add(5, function () use ($redis2){
    $redis2->publish('news', 'news content');
});

publish

Utilisé pour envoyer des informations au canal spécifié.

Retourne le nombre de souscripteurs ayant reçu l'information.

$redis2->publish('news', 'news content');

select

// Rappel omis
$redis->select(2);
$redis->select('test', function ($result, $redis) {
    // Le paramètre select doit être un nombre, donc ici $result est false
    var_dump($result, $redis->error());
});

get

La commande est utilisée pour obtenir la valeur de la clé spécifiée. Si la clé n'existe pas, retourne NULL. Si la valeur stockée dans la clé n'est pas de type chaîne, retourne false.

$redis->get('key', function($result) {
     // Si la clé n'existe pas, retourne NULL; en cas d'erreur, retourne false
    var_dump($result);
});

set

Utilisé pour définir la valeur d'une clé donnée. Si la clé contient déjà d'autres valeurs, SET écrase la ancienne valeur et ignore le type.

$redis->set('key', 'value');
$redis->set('key', 'value', function($result){});
// Le troisième paramètre peut être utilisé pour définir une durée d'expiration, expire après 10 secondes
$redis->set('key','value', 10);
$redis->set('key','value', 10, function($result){});

setEx, pSetEx

Définit la valeur et sa durée d'expiration pour la clé spécifiée. Si la clé existe déjà, la commande SETEX remplacera la valeur ancienne.

// Notez que le second paramètre définit la durée d'expiration, en secondes
$redis->setEx('key', 3600, 'value'); 
// pSetEx utilise les millisecondes
$redis->pSetEx('key', 3600, 'value'); 

del

Utilisé pour supprimer des clés existantes; le résultat retourné est un nombre, représentant combien de clés ont été supprimées (les clés inexistantes ne sont pas comptées).

// Supprimer une clé
$redis->del('key');
// Supprimer plusieurs clés
$redis->del(['key', 'key1', 'key2']);

setNx

(SETifNot eXists) La commande définit une valeur pour une clé spécifiée si la clé n'existe pas.

$redis->del('key');
$redis->setNx('key', 'value', function($result){
    var_dump($result); // 1
});
$redis->setNx('key', 'value', function($result){
    var_dump($result); // 0
});

exists

La commande est utilisée pour vérifier si une clé donnée existe. Le résultat retourné est un nombre, représentant le nombre de clés existantes.

$redis->set('key', 'value');
$redis->exists('key', function ($result) {
    var_dump($result); // 1
}); 
$redis->exists('NonExistingKey', function ($result) {
    var_dump($result); // 0
}); 

$redis->mset(['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz']);
$redis->exists(['foo', 'bar', 'baz'], function ($result) {
    var_dump($result); // 3
}); 

incr, incrBy

Incrémente la valeur numérique stockée dans la clé d'un / d'un montant spécifié. Si la clé n'existe pas, sa valeur est initialisée à 0, puis l'opération incr/incrBy est exécutée. Si la valeur est de type incorrect, ou si une valeur de type chaîne ne peut pas être représentée comme un nombre, alors retourne false. En cas de succès, retourne la valeur après l'incrémentation.

$redis->incr('key1', function ($result) {
    var_dump($result);
}); 
$redis->incrBy('key1', 10, function ($result) {
    var_dump($result);
}); 

incrByFloat

Ajoute une valeur flottante spécifiée au champ stocké dans la clé.
Si la clé n'existe pas, INCRBYFLOAT l'initialise à 0 avant d'exécuter l'opération d'addition.
Si la valeur est de type incorrect, ou si une valeur de type chaîne ne peut pas être représentée comme un nombre, alors retourne false.
En cas de succès, retourne la valeur après l'incrémentation.

$redis->incrByFloat('key1', 1.5, function ($result) {
    var_dump($result);
}); 

decr, decrBy

La commande décremente la valeur stockée dans la clé d'un / d'un montant spécifié.
Si la clé n'existe pas, sa valeur est initialisée à 0 avant d'exécuter decr/decrBy.
Si la valeur est de type incorrect, ou si une valeur de type chaîne ne peut pas être représentée comme un nombre, alors retourne false.
En cas de succès, retourne la valeur après la décrémentation.

$redis->decr('key1', function ($result) {
    var_dump($result);
}); 
$redis->decrBy('key1', 10, function ($result) {
    var_dump($result);
}); 

mGet

Retourne toutes les valeurs d'une ou plusieurs clés données. Si l'une des clés n'existe pas, cette clé retourne NULL.

$redis->set('key1', 'value1');
$redis->set('key2', 'value2');
$redis->set('key3', 'value3');
$redis->mGet(['key0', 'key1', 'key5'], function ($result) {
    var_dump($result); // [null, 'value1', null];
}); 

getSet

Utilisé pour définir la valeur d'une clé donnée et retourne la valeur ancienne de la clé.

$redis->set('x', '42');
$redis->getSet('x', 'lol', function ($result) {
    var_dump($result); // '42'
}) ;
$redis->get('x', function ($result) {
    var_dump($result); // 'lol'
}) ;

randomKey

Retourne une clé aléatoire à partir de la base de données actuelle.

$redis->randomKey(function($key) use ($redis) {
    $redis->get($key, function ($result) {
        var_dump($result); 
    }) ;
})

move

Déplace la clé de la base de données actuelle vers la base de données donnée db.

$redis->select(0);  // changer vers DB 0
$redis->set('x', '42'); // écrire 42 dans x
$redis->move('x', 1, function ($result) {   // déplacer vers DB 1
    var_dump($result); // 1
}) ;  
$redis->select(1);  // changer vers DB 1
$redis->get('x', function ($result) {
    var_dump($result); // '42'
}) ;

rename

Modifie le nom de la clé; si la clé n'existe pas, retourne false.

$redis->set('x', '42');
$redis->rename('x', 'y', function ($result) {
    var_dump($result); // true
}) ;

renameNx

Modifiez le nom de la clé lorsque la nouvelle clé n'existe pas.

$redis->del('y');
$redis->set('x', '42');
$redis->renameNx('x', 'y', function ($result) {
    var_dump($result); // 1
}) ;

expire

Pour définir la durée de vie d'une clé. Après l'expiration de la clé, elle ne sera plus disponible. L'unité est en secondes. Retourne 1 si succès, retourne 0 si la clé n'existe pas ou si la clé n'a pas de durée de vie, retourne false en cas d'erreur.

$redis->set('x', '42');
$redis->expire('x', 3);

keys

La commande est utilisée pour trouver toutes les clés correspondant à un motif donné.

$redis->keys('*', function ($keys) {
    var_dump($keys); 
}) ;
$redis->keys('user*', function ($keys) {
    var_dump($keys); 
}) ;

type

Retourne le type de la valeur stockée dans la clé. Le résultat retourné est une chaîne, qui est l'une des chaînes suivantes : string, set, list, zset, hash, none, où none indique que la clé n'existe pas.

$redis->type('key', function ($result) {
    var_dump($result); // string, set, list, zset, hash, none
}) ;

append

Si la clé existe déjà et qu’il s’agit d’une chaîne, la commande APPEND ajoute la valeur à la fin de la valeur originale de la clé et retourne la longueur de la chaîne.

Si la clé n'existe pas, APPEND définit simplement la clé donnée comme valeur, comme si SET key value était exécuté, et retourne la longueur de la chaîne.

Si la clé existe mais n'est pas une chaîne, elle retourne false.

$redis->set('key', 'value1');
$redis->append('key', 'value2', function ($result) {
    var_dump($result); // 12
}) ; 
$redis->get('key', function ($result) {
    var_dump($result); // 'value1value2'
}) ;

getRange

Obtient le sous-ensemble de chaîne stocké dans la clé spécifiée. La plage de découpage de la chaîne est déterminée par les deux décalages start et end (incluant start et end). Si la clé n'existe pas, retourne une chaîne vide. Si la clé n'est pas de type chaîne, retourne false.

$redis->set('key', 'string value');
$redis->getRange('key', 0, 5, function ($result) {
    var_dump($result); // 'string'
}) ; 
$redis->getRange('key', -5, -1 , function ($result) {
    var_dump($result); // 'value'
}) ;

setRange

Remplace la valeur de la chaîne stockée pour la clé donnée, le remplacement se fait à partir du décalage offset. Si la clé n'existe pas, définissez la clé sur la chaîne spécifiée. Si la clé n'est pas de type chaîne, retourne false.

Le résultat est la longueur de la chaîne après modification.

$redis->set('key', 'Hello world');
$redis->setRange('key', 6, "redis", function ($result) {
    var_dump($result); // 11
}) ; 
$redis->get('key', function ($result) {
    var_dump($result); // 'Hello redis'
}) ; 

strLen

Obtient la longueur de la valeur de chaîne stockée pour la clé spécifiée. Si la clé n'est pas stockée sous forme de chaîne, retourne false.

$redis->set('key', 'value');
$redis->strlen('key', function ($result) {
    var_dump($result); // 5
}) ; 

getBit

Pour la valeur de chaîne stockée dans la clé, obtenir le bit à l'offset spécifié.

$redis->set('key', "\x7f"); // cela est 0111 1111
$redis->getBit('key', 0, function ($result) {
    var_dump($result); // 0
}) ; 

setBit

Pour la valeur de chaîne stockée dans la clé, définir ou effacer le bit à l'offset spécifié.
La valeur de retour est 0 ou 1, qui est la valeur avant la modification.

$redis->set('key', "*");    // ord("*") = 42 = 0x2f = "0010 1010"
$redis->setBit('key', 5, 1, function ($result) {
    var_dump($result); // 0
}) ; 

bitOp

Exécute des opérations bit-à-bit entre plusieurs clés (contenant des valeurs de chaîne) et stocke le résultat dans la clé cible.

La commande BITOP prend en charge quatre opérations bit-à-bit : AND, OR, XOR et NOT.

Le résultat est la taille de la chaîne stockée dans la clé cible, égale à la taille de la plus longue chaîne d'entrée.

$redis->set('key1', "abc");
$redis->bitOp( 'AND', 'dst', 'key1', 'key2', function ($result) {
    var_dump($result); // 3
}) ;

bitCount

Calcule le nombre de bits définis dans la chaîne (population).

Par défaut, il vérifie tous les octets dans la chaîne. Vous ne pouvez spécifier l'opération de comptage qu'en fournissant des paramètres supplémentaires start et end.

Semblable à la commande GETRANGE, start et end peuvent également inclure des valeurs négatives pour indexer à partir de la fin de la chaîne, où -1 est le dernier octet, -2 le pénultième, etc.

Le résultat retourne le nombre de bits dont la valeur est 1 dans la chaîne.

Les clés inexistantes sont considérées comme des chaînes vides, donc cette commande retournera zéro.

$redis->set('key', 'hello');
$redis->bitCount( 'key', 0, 0, function ($result) {
    var_dump($result); // 3
}) ;
$redis->bitCount( 'key', function ($result) {
    var_dump($result); //21
}) ;

sort

La commande sort peut trier les éléments de liste, d'ensemble et d'ensemble trié.

Prototype : sort($key, $options, $callback);

où les options sont les clés et valeurs suivantes

$options = [
     'by' => 'some_pattern_*',
    'limit' => [0, 1],
    'get' => 'some_other_pattern_*', // ou un tableau de motifs
    'sort' => 'asc', // ou 'desc'
    'alpha' => true,
    'store' => 'external-key'
];

$redis->del('s');
$redis->sAdd('s', 5);
$redis->sAdd('s', 4);
$redis->sAdd('s', 2);
$redis->sAdd('s', 1);
$redis->sAdd('s', 3);
$redis->sort('s', [], function ($result) {
    var_dump($result); // 1,2,3,4,5
}); 
$redis->sort('s', ['sort' => 'desc'], function ($result) {
    var_dump($result); // 5,4,3,2,1
}); 
$redis->sort('s', ['sort' => 'desc', 'store' => 'out'], function ($result) {
    var_dump($result); // (int)5
}); 

ttl, pttl

Retourne le temps restant avant l'expiration de la clé en secondes/millisecondes.

Si la clé n'a pas de ttl, retourne -1. Si la clé n'existe pas, retourne -2.

$redis->set('key', 'value', 10);
// En secondes
$redis->ttl('key', function ($result) {
    var_dump($result); // 10
});
// En millisecondes
$redis->pttl('key', function ($result) {
    var_dump($result); // 9999
});
// La clé n'existe pas
$redis->pttl('key-not-exists', function ($result) {
    var_dump($result); // -2
});

persist

Supprime le temps d'expiration pour la clé donnée, permettant à la clé de ne jamais expirer.

Si la suppression est réussie, retourne 1, si la clé n'existe pas ou n'a pas de temps d'expiration, retourne 0, retourne false en cas d'erreur.

$redis->persist('key');

mSet, mSetNx

Définit plusieurs paires clé-valeur dans une seule commande atomique. mSetNx ne retourne que 1 si toutes les clés ont été définies.

Retourne 1 sur succès, 0 sur échec, false en cas d'erreur.

$redis->mSet(['key0' => 'value0', 'key1' => 'value1']);

hSet

Attribution d'une valeur à un champ dans une table de hachage.

Si le champ est un champ nouvellement créé dans la table de hachage et que la valeur a été définie avec succès, retourne 1. Si le champ de la table de hachage existe déjà et que l'ancienne valeur a été écrasée, retourne 0.

$redis->del('h');
$redis->hSet('h', 'key1', 'hello', function ($r) {
    var_dump($r); // 1
}); 
$redis->hGet('h', 'key1', function ($r) {
    var_dump($r); // hello
}); 
$redis->hSet('h', 'key1', 'plop', function ($r) {
    var_dump($r); // 0
});
$redis->hGet('h', 'key1', function ($r) {
    var_dump($r); // plop
}); 

hSetNx

Attribuer une valeur à un champ qui n'existe pas dans la table de hachage.

Si la table de hachage n'existe pas, une nouvelle table de hachage est créée et l'opération HSET est exécutée.

Si le champ existe déjà dans la table de hachage, l'opération n'est pas valide.

Si la clé n'existe pas, une nouvelle table de hachage est créée et la commande HSETNX est exécutée.

$redis->del('h');
$redis->hSetNx('h', 'key1', 'hello', function ($r) {
    var_dump($r); // 1
});
$redis->hSetNx('h', 'key1', 'world', function ($r) {
    var_dump($r); // 0
});

hGet

Retourne la valeur d'un champ spécifié dans une table de hachage.

Si le champ ou la clé fournie n'existe pas, retourne null.

$redis->hGet('h', 'key1', function ($result) {
    var_dump($result);
});

hLen

Permet d'obtenir le nombre de champs dans une table de hachage.

Lorsque la clé n'existe pas, retourne 0.

$redis->del('h');
$redis->hSet('h', 'key1', 'hello');
$redis->hSet('h', 'key2', 'plop');
$redis->hLen('h', function ($result) {
    var_dump($result); // 2
});

hDel

La commande est utilisée pour supprimer un ou plusieurs champs spécifiés dans la clé de la table de hachage; les champs inexistants sont ignorés.

Retourne le nombre de champs supprimés avec succès, sans compter les champs ignorés. Retourne false si la clé n'est pas une table de hachage.

$redis->hDel('h', 'key1');

hKeys

Obtient tous les champs de la table de hachage sous forme de tableau.

Si la clé n'existe pas, retourne un tableau vide. Si la clé ne correspond pas à une table de hachage, retourne false.

$redis->hKeys('key', function ($result) {
    var_dump($result);
});

hVals

Retourne tous les champs de la table de hachage sous forme de tableau.

Si la clé n'existe pas, retourne un tableau vide. Si la clé ne correspond pas à une table de hachage, retourne false.

$redis->hVals('key', function ($result) {
    var_dump($result);
});

hGetAll

Retourne tous les champs et valeurs de la table de hachage sous forme de tableau associatif.

Si la clé n'existe pas, retourne un tableau vide. Si la clé ne correspond pas au type hash, retourne false.

$redis->del('h');
$redis->hSet('h', 'a', 'x');
$redis->hSet('h', 'b', 'y');
$redis->hSet('h', 'c', 'z');
$redis->hSet('h', 'd', 't');
$redis->hGetAll('h', function ($result) {
    var_export($result); 
});

Retourne

array (
    'a' => 'x',
    'b' => 'y',
    'c' => 'z',
    'd' => 't',
)

hExists

Vérifie si un champ spécifié existe dans la table de hachage. Retourne 1 si le champ existe, 0 si le champ n'existe pas ou si la clé n'existe pas, retourne false en cas d'erreur.

$redis->hExists('h', 'a', function ($result) {
    var_dump($result); //
});

hIncrBy

Utilisé pour incrémenter la valeur d'un champ dans une table de hachage d'un montant spécifié.

L'incrément peut également être négatif, ce qui revient à effectuer une opération de soustraction sur le champ spécifié.

Si la clé de la table de hachage n'existe pas, une nouvelle table de hachage est créée et la commande HINCRBY est exécutée.

Si le champ spécifié n'existe pas, sa valeur est initialisée à 0 avant l'exécution de la commande.

Exécuter la commande HINCRBY sur un champ qui stocke une valeur de chaîne retournera false.

La valeur de cette opération est limitée à un nombre entier signé de 64 bits.

$redis->del('h');
$redis->hIncrBy('h', 'x', 2,  function ($result) {
    var_dump($result);
});

hIncrByFloat

Similaire à hIncrBy, mais l'incrément est de type flottant.

hMSet

Définit simultanément plusieurs paires champ-valeur dans une table de hachage.

Cette commande écrase les champs existants dans la table de hachage.

Si la table de hachage n'existe pas, un tableau de hachage vide est créé et l'opération HMSET est exécutée.

$redis->del('h');
$redis->hMSet('h', ['name' => 'Joe', 'sex' => 1])

hMGet

Retourne les valeurs d'un ou plusieurs champs spécifiés dans une table de hachage sous forme de tableau associatif.

Si un champ spécifié n'existe pas dans la table de hachage, la valeur correspondante sera null. Si la clé n'est pas une table de hachage, retourne false.

$redis->del('h');
$redis->hSet('h', 'field1', 'value1');
$redis->hSet('h', 'field2', 'value2');
$redis->hMGet('h', ['field1', 'field2', 'field3'], function ($r) {
    var_export($r);
});

Sortie

array (
 'field1' => 'value1',
 'field2' => 'value2',
 'field3' => null
)

blPop, brPop

Retire et obtient le premier élément / le dernier élément d'une liste. Si la liste est vide, bloque jusqu'à ce qu'un élément puisse être retiré ou que le temps d'attente expire.

$redis = new Client('redis://127.0.0.1:6379');
$redis2 = new Client('redis://127.0.0.1:6379');

$redis->blPop(['key1', 'key2'], 10, function ($r) {
    var_export($r); // array ( 0 => 'key1',1 => 'a')
});

Timer::add(1, function () use ($redis2) {
    $redis2->lpush('key1', 'a');
});

bRPopLPush

Retire le dernier élément d'une liste et l'insère au début d'une autre liste; si la liste est vide, bloque jusqu'à ce qu'un élément puisse être retiré ou que le temps d'attente expire. Si le temps d'attente expire, retourne null.

$redis = new Client('redis://127.0.0.1:6379');
$redis2 = new Client('redis://127.0.0.1:6379');
$redis->del(['key1', 'key2']);
$redis->bRPopLPush('key1', 'key2', 2, function ($r) {
    var_export($r);
});
Timer::add(2, function () use ($redis2) {
    $redis2->lpush('key1', 'a');
    $redis2->lRange('key2', 0, -1, function ($r) {
        var_dump($r);
    });
}, null, false);

lIndex

Obtient un élément de la liste par indice. Vous pouvez également utiliser des indices négatifs pour désigner le dernier élément de la liste avec -1, le pénultième avec -2, etc.

Si l'indice spécifié n'est pas dans la plage de la liste, retourne null. Si la clé correspondante n'est pas de type liste, retourne false.

$redis->del('key1']);
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->lindex('key1', 0, function ($r) {
    var_dump($r); // A
});

lInsert

Insère un élément avant ou après un élément de la liste. Si l’élément spécifié n’existe pas dans la liste, aucune opération ne sera effectuée.

Lorsque la liste n'existe pas, elle est considérée comme une liste vide, aucune opération n'est effectuée.

Si la clé n'est pas de type liste, retourne false.

$redis->del('key1');
$redis->lInsert('key1', 'after', 'A', 'X', function ($r) {
    var_dump($r); // 0
});
$redis->lPush('key1', 'A');
$redis->lPush('key1', 'B');
$redis->lPush('key1', 'C');
$redis->lInsert('key1', 'before', 'C', 'X', function ($r) {
    var_dump($r); // 4
});
$redis->lRange('key1', 0, -1, function ($r) {
    var_dump($r); // ['A', 'B', 'X', 'C']
});

lPop

Retire et retourne le premier élément d'une liste.

Lorsque la clé de la liste n'existe pas, retourne null.

$redis->del('key1');
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->lPop('key1', function ($r) {
    var_dump($r); // A
});

lPush

Insère un ou plusieurs valeurs au début de la liste. Si la clé n'existe pas, une liste vide sera créée et l'opération LPUSH sera exécutée. Lorsque la clé existe mais n'est pas de type liste, retourne false.

Remarque : Dans les versions antérieures à Redis 2.4, la commande LPUSH n'acceptait qu'une seule valeur.

$redis->del('key1');
$redis->lPush('key1', 'A');
$redis->lPush('key1', ['B','C']);
$redis->lRange('key1', 0, -1, function ($r) {
    var_dump($r); // ['C', 'B', 'A']
});

lPushx

Insère une valeur au début d'une liste existante, si la liste n'existe pas, l'opération est ignorée et retourne 0. Si la clé n'est pas de type liste, retourne false.

Le retour est la longueur de la liste après l'exécution de la commande lPushx.

$redis->del('key1');
$redis->lPush('key1', 'A');
$redis->lPushx('key1', ['B','C'], function ($r) {
    var_dump($r); // 3
});
$redis->lRange('key1', 0, -1, function ($r) {
    var_dump($r); // ['C', 'B', 'A']
});

lRange

Retourne les éléments d'une liste dans une plage spécifiée, la plage est déterminée par les décalages START et END. 0 signifie le premier élément de la liste, 1 signifie le deuxième élément de la liste, et ainsi de suite. Vous pouvez également utiliser des indices négatifs pour désigner le dernier élément de la liste avec -1, le pénultième avec -2, etc.

Retourne un tableau contenant les éléments dans la plage spécifiée. Si la clé n'est pas de type liste, retourne false.

$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C');
$redis->lRange('key1', 0, -1, function ($r) {
    var_dump($r); // ['C', 'B', 'A']
});

lRem

Supprime les éléments de la liste qui sont égaux à la valeur spécifiée en fonction de la valeur COUNT.

La valeur COUNT peut avoir les formes suivantes :

• count > 0 : Recherche de la tête de la liste à la queue, et supprime COUNT éléments qui sont égaux à VALUE.
• count < 0 : Recherche de la queue à la tête de la liste, et supprime les éléments qui sont égaux à VALUE, en nombre absolu égal à COUNT.
• count = 0 : Supprime tous les éléments qui sont égaux à VALUE dans la liste.

Retourne le nombre d'éléments supprimés. Retourne 0 lorsque la liste n'existe pas. Retourne false lorsqu'il ne s'agit pas d'une liste.

$redis->lRem('key1', 2, 'A', function ($r) {
    var_dump($r); 
});

lSet

Utilise un index pour définir la valeur d'un élément.

Retourne true lorsque c'est réussi; lorsque le paramètre d'index dépasse la portée, ou que LSET est appelé sur une liste vide, retourne false.

$redis->lSet('key1', 0, 'X');

lTrim

Permet de réduire une liste, c'est-à-dire de conserver uniquement les éléments dans une plage spécifiée, tout élément en dehors de la plage spécifiée sera supprimé.

L'indice 0 signifie le premier élément de la liste, et 1 signifie le deuxième élément de la liste, et ainsi de suite. Vous pouvez également utiliser des indices négatifs pour désigner le dernier élément de la liste, avec -1, le pénultième avec -2, etc.

Retourne true lorsque c'est réussi, retourne false en cas d'échec.

$redis->del('key1');

$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C');
$redis->lRange('key1', 0, -1, function ($r) {
    var_dump($r); // ['A', 'B', 'C']
});
$redis->lTrim('key1', 0, 1);
$redis->lRange('key1', 0, -1, function ($r) {
    var_dump($r); // ['A', 'B']
});

rPop

Utilisé pour retirer le dernier élément d'une liste, le retour est l'élément retiré.

Lorsque la liste est vide, retourne null.

$redis->rPop('key1', function ($r) {
    var_dump($r);
});

rPopLPush

Utilisé pour retirer le dernier élément d'une liste et l'ajouter à une autre liste, en le retournant.

$redis->del('x', 'y');
$redis->lPush('x', 'abc');
$redis->lPush('x', 'def');
$redis->lPush('y', '123');
$redis->lPush('y', '456');
$redis->rPopLPush('x', 'y', function ($r) {
    var_dump($r); // abc
});
$redis->lRange('x', 0, -1, function ($r) {
    var_dump($r); // ['def']
});
$redis->lRange('y', 0, -1, function ($r) {
    var_dump($r); // ['abc', '456', '123']
});

rPush

Insère un ou plusieurs valeurs à la fin de la liste (à droite), et retourne la longueur de la liste après l'insertion.

Si la liste n'existe pas, une liste vide sera créée et l'opération RPUSH sera exécutée. Lorsque la liste existe mais n'est pas de type liste, retourne false.

Remarque : Dans les versions antérieures à Redis 2.4, la commande RPUSH n'acceptait qu'une seule valeur.

$redis->del('key1');
$redis->rPush('key1', 'A', function ($r) {
    var_dump($r); // 1
});

rPushX

Insère une valeur à la fin d'une liste existante (à droite) et retourne la longueur de la liste. Si la liste n'existe pas, l'opération est inapplicable et retourne 0. Si la liste existe mais n'est pas de type liste, retourne false.

$redis->del('key1');
$redis->rPushX('key1', 'A', function ($r) {
    var_dump($r); // 0
});

lLen

Retourne la longueur de la liste. Si la clé de la liste n'existe pas, la clé est considérée comme une liste vide, et retourne 0. Si la clé n'est pas de type liste, retourne false.

$redis->del('key1');
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C');
$redis->lLen('key1', function ($r) {
    var_dump($r); // 3
});

sAdd

Ajoute un ou plusieurs membres dans un ensemble, les membres existants dans l'ensemble seront ignorés.

Si la clé de l'ensemble n'existe pas, un ensemble contenant uniquement les éléments ajoutés sera créé.

Lorsque la clé de l'ensemble n'est pas de type ensemble, retourne false.

Remarque : Dans les versions antérieures à Redis 2.4, SADD n'acceptait qu'une seule valeur membre.

$redis->del('key1');
$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , ['member2', 'member3'], function ($r) {
    var_dump($r); // 2
});
$redis->sAdd('key1' , 'member2', function ($r) {
    var_dump($r); // 0
});

sCard

Retourne le nombre d'éléments dans l'ensemble. Lorsque la clé de l'ensemble n'existe pas, retourne 0.

$redis->del('key1');
$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3');
$redis->sCard('key1', function ($r) {
    var_dump($r); // 3
});
$redis->sCard('keyX', function ($r) {
    var_dump($r); // 0
});

sDiff

Retourne la différence entre le premier ensemble et les autres ensembles, c'est-à-dire les éléments qui sont uniques au premier ensemble. Les clés d'ensemble inexistantes sont considérées comme des ensembles vides.

$redis->del('s0', 's1', 's2');

$redis->sAdd('s0', '1');
$redis->sAdd('s0', '2');
$redis->sAdd('s0', '3');
$redis->sAdd('s0', '4');
$redis->sAdd('s1', '1');
$redis->sAdd('s2', '3');
$redis->sDiff(['s0', 's1', 's2'], function ($r) {
    var_dump($r); // ['2', '4']
});

sDiffStore

Stocke la différence entre les ensembles donnés dans l'ensemble spécifié. Si l'ensemble spécifié existe déjà, il sera écrasé.

$redis->del('s0', 's1', 's2');
$redis->sAdd('s0', '1');
$redis->sAdd('s0', '2');
$redis->sAdd('s0', '3');
$redis->sAdd('s0', '4');
$redis->sAdd('s1', '1');
$redis->sAdd('s2', '3');
$redis->sDiffStore('dst', ['s0', 's1', 's2'], function ($r) {
    var_dump($r); // 2
});
$redis->sMembers('dst', function ($r) {
    var_dump($r); // ['2', '4']
});

sInter

Retourne l'intersection de tous les ensembles donnés. Les clés d'ensemble inexistantes sont considérées comme des ensembles vides. Si un ensemble donné est vide, le résultat sera également une intersection vide.

$redis->del('s0', 's1', 's2');
$redis->sAdd('key1', 'val1');
$redis->sAdd('key1', 'val2');
$redis->sAdd('key1', 'val3');
$redis->sAdd('key1', 'val4');
$redis->sAdd('key2', 'val3');
$redis->sAdd('key2', 'val4');
$redis->sAdd('key3', 'val3');
$redis->sAdd('key3', 'val4');
$redis->sInter(['key1', 'key2', 'key3'], function ($r) {
    var_dump($r); // ['val4', 'val3']
});

sInterStore

Stocke l'intersection entre les ensembles donnés dans l'ensemble spécifié et retourne le nombre d'éléments stockés dans l'intersection de l'ensemble. Si l'ensemble spécifié existe déjà, il sera écrasé.

$redis->sAdd('key1', 'val1');
$redis->sAdd('key1', 'val2');
$redis->sAdd('key1', 'val3');
$redis->sAdd('key1', 'val4');

$redis->sAdd('key2', 'val3');
$redis->sAdd('key2', 'val4');

$redis->sAdd('key3', 'val3');
$redis->sAdd('key3', 'val4');

$redis->sInterStore('output', 'key1', 'key2', 'key3', function ($r) {
    var_dump($r); // 2
});
$redis->sMembers('output', function ($r) {
    var_dump($r); // ['val4', 'val3']
});

sIsMember

Vérifie si un membre est membre de l'ensemble.

Retourne 1 si le membre est dans l'ensemble. Retourne 0 si le membre n'est pas dans l'ensemble ou si la clé n'existe pas. Si la clé n'est pas de type ensemble, retourne false.

$redis->sIsMember('key1', 'member1', function ($r) {
    var_dump($r); 
});

sMembers

Retourne tous les membres de l'ensemble. Les clés d'ensemble inexistantes sont considérées comme des ensembles vides.

$redis->sMembers('s', function ($r) {
    var_dump($r); 
});

sMove

Déplace un membre spécifique du ensemble source au ensemble destination.

SMOVE est une opération atomique.

Si l'ensemble source n'existe pas ou ne contient pas l'élément spécifié, la commande SMOVE n'exécute aucune opération et retourne uniquement 0. Sinon, l'élément est supprimé de l'ensemble source et ajouté à l'ensemble destination.

Lorsque l'ensemble destination contient déjà l'élément, la commande SMOVE ne fait que supprimer l'élément de l'ensemble source.

Lorsque la source ou la destination n'est pas de type ensemble, retourne false.

$redis->sMove('key1', 'key2', 'member13');

sPop

Retire un ou plusieurs éléments aléatoires d'un ensemble spécifié, et retourne les éléments retirés.

Lorsque l'ensemble n'existe pas ou est vide, retourne null.

$redis->del('key1');
$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3');
$redis->sPop('key1', function ($r) {
    var_dump($r); // member3
});
$redis->sAdd('key2', ['member1', 'member2', 'member3']);
$redis->sPop('key2', 3, function ($r) {
    var_dump($r); // ['member1', 'member2', 'member3']
});

sRandMember

La commande Srandmember de Redis est utilisée pour retourner un élément aléatoire de l'ensemble.

À partir de la version 2.6 de Redis, la commande Srandmember accepte un paramètre count facultatif :

• Si count est positif et inférieur à la cardinalité de l'ensemble, la commande retourne un tableau contenant count éléments uniques. Si count est supérieur ou égal à la cardinalité de l'ensemble, retourne l'ensemble entier.
• Si count est négatif, la commande retourne un tableau d'éléments pouvant apparaître plusieurs fois, dont la longueur est la valeur absolue de count.

Cette opération est similaire à SPOP, mais SPOP retire des éléments aléatoires de l'ensemble et les retourne, tandis que Srandmember retourne simplement des éléments aléatoires sans modifier l'ensemble.

$redis->del('key1');
$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); 

$redis->sRandMember('key1', function ($r) {
    var_dump($r); // member1
});

$redis->sRandMember('key1', 2, function ($r) {
    var_dump($r); // ['member1', 'member2']
});
$redis->sRandMember('key1', -100, function ($r) {
    var_dump($r); // ['member1', 'member2', 'member3', 'member3', ...]
});
$redis->sRandMember('empty-set', 100, function ($r) {
    var_dump($r); // []
}); 
$redis->sRandMember('not-a-set', 100, function ($r) {
    var_dump($r); // []
});

sRem

Supprime un ou plusieurs éléments du ensemble, les membres inexistants seront ignorés.

Retourne le nombre d'éléments supprimés avec succès, sans compter les éléments ignorés.

Lorsque la clé n'est pas de type ensemble, retourne false.

Dans les versions antérieures à Redis 2.4, SREM n'acceptait qu'une seule valeur membre.

$redis->sRem('key1', ['member2', 'member3'], function ($r) {
    var_dump($r); 
});

sUnion

Retourne l'union des ensembles donnés. Les clés d'ensemble inexistantes sont considérées comme des ensembles vides.

$redis->sUnion(['s0', 's1', 's2'], function ($r) {
    var_dump($r); // []
});

sUnionStore

Stocke l'union des ensembles donnés dans l'ensemble spécifié destination et retourne le nombre d'éléments. Si la destination existe déjà, elle sera écrasée.

$redis->del('s0', 's1', 's2');
$redis->sAdd('s0', '1');
$redis->sAdd('s0', '2');
$redis->sAdd('s1', '3');
$redis->sAdd('s1', '1');
$redis->sAdd('s2', '3');
$redis->sAdd('s2', '4');
$redis->sUnionStore('dst', 's0', 's1', 's2', function ($r) {
    var_dump($r); // 4
});
$redis->sMembers('dst', function ($r) {
    var_dump($r); // ['1', '2', '3', '4']
});