workerman-redis

Introducción

workeman/redis es un componente asincrónico de redis basado en workerman.

Nota
El objetivo principal de este proyecto es implementar la suscripción asincrónica a redis (subscribe, pSubscribe).
Dado que redis es lo suficientemente rápido, no es necesario utilizar este cliente asincrónico a menos que se requiera psubscribe o subscribe asincrónicamente; utilizar la extensión de redis dará un mejor rendimiento.

Instalación:

composer require workerman/redis ^v2.0.3

Uso de callbacks

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();

Uso de corutinas

Nota
El uso de corutinas requiere workerman>=5.0, workerman/redis>=2.0.0 y debe instalarse con 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();

Cuando no se establece una función de callback, el cliente volverá el resultado de la solicitud asincrónica de manera sincrónica, y el proceso actual no se bloqueará, lo que significa que puede manejar las solicitudes en concurrencia.

Nota
psubscribe subscribe no soporta el uso de corutinas

Documentación

Descripción

En el modo de callback, la función de callback generalmente tiene 2 parámetros ($result, $redis), donde $result es el resultado y $redis es la instancia de redis. Por ejemplo:

use Workerman\Redis\Client;
$redis = new Client('redis://127.0.0.1:6379');
// Establecer una función de callback para determinar el resultado de la llamada set
$redis->set('key', 'value', function ($result, $redis) {
    var_dump($result); // true
});
// Las funciones de callback son parámetros opcionales, aquí se omitió la función de callback
$redis->set('key1', 'value1');
// Las funciones de callback pueden ser anidadas
$redis->get('key', function ($result, $redis){
    $redis->set('key2', 'value2', function ($result) {
        var_dump($result);
    });
});

Conexión

use Workerman\Redis\Client;
// Omitir callback
$redis = new Client('redis://127.0.0.1:6379');
// Con callback
$redis = new Client('redis://127.0.0.1:6379', [
    'connect_timeout' => 10 // Establecer tiempo de espera para la conexión en 10 segundos, por defecto es 5 segundos
], function ($success, $redis) {
    // Callback para el resultado de la conexión
    if (!$success) echo $redis->error();
});

auth

//  Autenticación por contraseña
$redis->auth('password', function ($result) {

});
// Autenticación por nombre de usuario y contraseña
$redis->auth('username', 'password', function ($result) {

});

pSubscribe

Suscribirse a uno o más canales que coincidan con el patrón dado.

Cada patrón utiliza * como comodín; por ejemplo, it* coincidirá con todos los canales que comiencen con it (it.news, it.blog, it.tweets, etc.). news.* coincidirá con todos los canales que comiencen con news. (news.it, news.global.today, etc.), y así sucesivamente.

Nota: La función de callback pSubscribe tiene 4 parámetros ($pattern, $channel, $message, $redis).

Cuando la instancia $redis llama a las interfaces pSubscribe o subscribe, cualquier otro método que se llame a la instancia actual se ignorará.

$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, contenido de noticias
});

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

subscribe

Utilizado para suscribirse a la información de uno o más canales dados.

Nota: La función de callback subscribe tiene 3 parámetros ($channel, $message, $redis).

Cuando la instancia $redis llama a las interfaces pSubscribe o subscribe, cualquier otro método que se llame a la instancia actual se ignorará.

$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, contenido de noticias
});

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

publish

Se utiliza para enviar información a un canal específico.

Devuelve la cantidad de suscriptores que recibieron la información.

$redis2->publish('news', 'contenido de noticias');

select

// Omitir callback
$redis->select(2);
$redis->select('test', function ($result, $redis) {
    // El parámetro select debe ser un número, por lo que aquí $result es false
    var_dump($result, $redis->error());
});

get

El comando se utiliza para obtener el valor de la clave especificada. Si la clave no existe, se devuelve NULL. Si el valor almacenado en la clave no es de tipo cadena, se devuelve false.

$redis->get('key', function($result) {
     // Si la clave no existe se devuelve NULL, si hay un error se devuelve false
    var_dump($result);
});

set

Se utiliza para establecer el valor de la clave dada. Si la clave ya tiene otro valor almacenado, SET sobrescribirá el valor antiguo, ignorando el tipo.

$redis->set('key', 'value');
$redis->set('key', 'value', function($result){});
// El tercer parámetro puede pasar un tiempo de expiración, expira en 10 segundos
$redis->set('key','value', 10);
$redis->set('key','value', 10, function($result){});

setEx, pSetEx

Establece el valor y el tiempo de expiración de la clave especificada. Si la clave ya existe, el comando SETEX reemplazará el valor antiguo.

// Nota: El segundo parámetro es el tiempo de expiración, en segundos
$redis->setEx('key', 3600, 'value'); 
// pSetEx el tiempo se mide en milisegundos
$redis->pSetEx('key', 3600, 'value'); 

del

Se utiliza para eliminar claves que ya existen, el resultado devuelto es un número que representa cuántas claves fueron eliminadas (las claves que no existen no cuentan).

// Eliminar una clave
$redis->del('key');
// Eliminar múltiples claves
$redis->del(['key', 'key1', 'key2']);

setNx

(SETifNot eXists) El comando establece un valor para la clave especificada solo si la clave no existe.

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

exists

El comando se utiliza para verificar si una clave dada existe. El resultado devuelto es un número que representa cuántas claves existen.

$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

Incrementa el valor numérico almacenado en la clave en uno/número especificado. Si la clave no existe, se inicializa su valor a 0 antes de ejecutar la operación incr/incrBy. Si el valor tiene un tipo incorrecto, o si el valor de tipo cadena no puede representarse como un número, se devuelve false. Si tiene éxito, el resultado será el nuevo valor incrementado.

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

incrByFloat

Agrega un incremento de número en punto flotante al valor almacenado en la clave. Si la clave no existe, INCRBYFLOAT establecerá el valor de la clave a 0 antes de realizar la operación de suma. Si el valor tiene un tipo incorrecto, o si el valor de tipo cadena no puede representarse como un número, se devuelve false. Si tiene éxito, el resultado será el nuevo valor incrementado.

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

decr, decrBy

El comando reduce el valor almacenado en la clave en uno/valor de decremento especificado. Si la clave no existe, se inicializa su valor a 0 antes de realizar la operación de decr/decrBy. Si el valor tiene un tipo incorrecto, o si el valor de tipo cadena no puede representarse como un número, se devuelve false. Si tiene éxito, el resultado será el nuevo valor reducido.

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

mGet

Devuelve todos los valores de las claves dada (una o más). Si alguna de las claves dadas no existe, esta clave devolverá 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

Se utiliza para establecer el valor de la clave especificada y devolver el viejo valor de la clave.

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

randomKey

Devuelve aleatoriamente una clave de la base de datos actual.

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

move

Mueve la clave de la base de datos actual a la base de datos dada db.

$redis->select(0);  // cambiar a DB 0
$redis->set('x', '42'); // escribir 42 en x
$redis->move('x', 1, function ($result) {   // mover a DB 1
    var_dump($result); // 1
}) ;  
$redis->select(1);  // cambiar a DB 1
$redis->get('x', function ($result) {
    var_dump($result); // '42'
}) ;

rename

Cambia el nombre de la clave; si la clave no existe, devuelve false.

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

renameNx

Cambia el nombre de la clave solo si la nueva clave no existe.

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

expire

Establece el tiempo de expiración de la clave; después de que la clave expira, ya no estará disponible. La unidad es en segundos. Devuelve 1 si tiene éxito, 0 si la clave no existe o no tiene tiempo de expiración, y false si hay un error.

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

keys

El comando se utiliza para buscar todas las claves que coincidan con el patrón dado.

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

type

Devuelve el tipo de valor almacenado en la clave. El resultado devuelto es una cadena que puede ser string, set, list, zset, hash o none, donde none indica que la clave no existe.

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

append

Si la clave ya existe y es una cadena, el comando APPEND agregará el valor al final del valor original de la clave y devolverá la longitud de la cadena.

Si la clave no existe, APPEND simplemente establecerá la clave dada en el valor, de la misma manera que ejecuta SET key value y devolverá la longitud de la cadena.

Si la clave existe pero no es una cadena, devuelve 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

Obtiene la subcadena almacenada en la clave especificada. El rango de la subcadena está determinado por los dos desplazamientos start y end (incluyéndolos). Si la clave no existe, devuelve una cadena vacía. Si la clave no es de tipo cadena, devuelve 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

Cubre el valor de la clave almacenada especificada con la cadena dada, comenzando desde el desplazamiento offset. Si la clave no existe, la clave se establece en la cadena especificada. Si la clave no es de tipo cadena, devuelve false.

El resultado devuelto es la longitud de la cadena modificada.

$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

Obtiene la longitud del valor de cadena almacenado en la clave especificada. Cuando el valor almacenado en la clave no es de tipo cadena, devuelve false.

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

getBit

Para el valor de cadena almacenado en la clave, obtiene el bit en el desplazamiento especificado.

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

setBit

Para el valor de cadena almacenado en la clave, establece o limpia el bit en el desplazamiento especificado.
El valor devuelto será 0 o 1, que es el valor anterior antes de la modificación.

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

bitOp

Ejecuta operaciones bit a bit en múltiples claves (que contienen valores de cadena) y almacena el resultado en la clave de destino.

El comando BITOP soporta cuatro operaciones bit a bit: AND, OR, XOR y NOT.

El resultado se almacena en la clave de destino y su tamaño es igual al tamaño de la cadena de entrada más larga.

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

bitCount

Cuenta el número de bits establecidos (población) en la cadena.

Por defecto, se verifican todos los bytes de la cadena. La operación de conteo solo puede especificarse en el intervalo pasando parámetros adicionales start y end.

Al igual que en el comando GETRANGE, start y end pueden incluir valores negativos para indexar los bytes desde el final de la cadena, donde -1 es el último byte, -2 es el penúltimo byte, y así sucesivamente.

El resultado devuelve el número de bits en la cadena cuyo valor es 1.

Las claves que no existen se consideran como cadenas vacías, por lo que este comando devolverá cero.

$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

El comando sort puede ordenar los elementos de list, set y sorted set.

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

Donde options son las siguientes claves y valores opcionales

$options = [
     'by' => 'some_pattern_*',
    'limit' => [0, 1],
    'get' => 'some_other_pattern_*', // o un array de patrones
    'sort' => 'asc', // o '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

Devuelve el tiempo restante de expiración de la clave en segundos/milisegundos.

Si la clave no tiene ttl, devuelve -1. Si la clave no existe, devuelve -2.

$redis->set('key', 'value', 10);
// En segundos
$redis->ttl('key', function ($result) {
    var_dump($result); // 10
});
// En milisegundos
$redis->pttl('key', function ($result) {
    var_dump($result); // 9999
});
// La clave no existe
$redis->pttl('key-not-exists', function ($result) {
    var_dump($result); // -2
});

persist

Elimina el tiempo de expiración de la clave dada, haciendo que la clave nunca expire.

Si se elimina con éxito, devuelve 1; si la clave no existe o no tiene tiempo de expiración, devuelve 0; si hay un error, devuelve false.

$redis->persist('key');

mSet, mSetNx

Establece múltiples pares clave-valor en un comando atómico. mSetNx devuelve 1 solo si se establecen todas las claves.

Devuelve 1 si tiene éxito, 0 si falla y false si hay un error.

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

hSet

Asigna valor a un campo en una tabla hash.

Si el campo es un nuevo campo en la tabla hash y el valor se establece con éxito, devuelve 1. Si el campo ya existe en la tabla hash y el valor antiguo ha sido reemplazado por el nuevo, devuelve 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

Asigna valor a un campo que no existe en la tabla hash.

Si la tabla hash no existe, se crea una nueva tabla hash y se realiza la operación HSET.

Si el campo ya existe en la tabla hash, la operación no tiene efecto.

Si la clave no existe, se crea una tabla hash nueva y se ejecuta el comando HSETNX.

$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

Devuelve el valor del campo especificado en la tabla hash.

Si el campo o la clave dada no existen, devuelve null.

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

hLen

Obtiene la cantidad de campos en la tabla hash.

Cuando la clave no existe, devuelve 0.

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

hDel

El comando se utiliza para eliminar uno o más campos especificados en la clave de la tabla hash; los campos que no existen se ignoran.

Devuelve la cantidad de campos eliminados con éxito, excluyendo los que fueron ignorados. Si la clave no es un hash, devuelve false.

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

hKeys

Devuelve todos los campos de la tabla hash en forma de array.

Si la clave no existe, devuelve un array vacío. Si la clave no es de tipo hash, devuelve false.

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

hVals

Devuelve todos los valores de los campos de la tabla hash en forma de array.

Si la clave no existe, devuelve un array vacío. Si la clave no es de tipo hash, devuelve false.

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

hGetAll

Devuelve todos los campos y valores en la tabla hash en forma de array asociativo.

Si la clave no existe, devuelve un array vacío. Si la clave no es de tipo hash, devuelve 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); 
});

Devuelve

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

hExists

Comprueba si un campo especificado existe en la tabla hash. Devuelve 1 si existe, 0 si el campo no existe o la clave no existe, y false si hay un error.

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

hIncrBy

Se utiliza para incrementar el valor del campo en la tabla hash en un valor de incremento especificado.

El incremento también puede ser un número negativo, que equivale a realizar una operación de resta en el campo especificado.

Si la clave de la tabla hash no existe, se crea una nueva tabla hash y se ejecuta el comando HINCRBY.

Si el campo especificado no existe, el valor del campo se inicializa a 0 antes de ejecutar el comando.

El valor de esta operación está limitado a representar números enteros con signo de 64 bits.

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

hIncrByFloat

Similar a hIncrBy, pero el incremento es de tipo flotante.

hMSet

Establece varios pares field-value (campo-valor) en la tabla hash.

Este comando sobrescribirá los campos existentes en la tabla hash.

Si la tabla hash no existe, creará una nueva tabla hash vacía y realizará la operación HMSET.

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

hMGet

Devuelve uno o más valores de campos específicos en la tabla hash en forma de array asociativo.

Si el campo especificado no existe en la tabla hash, el correspondiente será un valor null. Si la clave no es de tipo hash, devuelve 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);
});

Salida

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

blPop, brPop

Elimina y obtiene el primer elemento/último elemento de la lista; si la lista no tiene elementos, bloquea la lista hasta que se supere el tiempo de espera o se encuentre un elemento que se pueda eliminar.

$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

Extrae el último elemento de la lista e inserta en la parte superior de otra lista; si la lista no tiene elementos, bloquea la lista hasta que se supere el tiempo de espera o se encuentre un elemento que se pueda eliminar. Si se supera el tiempo de espera, devuelve 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

Obtiene el elemento de la lista por su índice. También puedes usar subíndices negativos, donde -1 representa el último elemento de la lista, -2 el penúltimo y así sucesivamente.

Si el valor de índice especificado no está dentro del rango de la lista, devuelve null. Si la clave correspondiente no es de tipo lista, devuelve false.

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

lInsert

Inserta un elemento delante o detrás de un elemento en la lista. Si el elemento especificado no existe en la lista, no realiza ninguna operación.

Si la lista no existe, se considera una lista vacía y no se realiza ninguna operación.

Si la clave no es de tipo lista, devuelve 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

Elimina y devuelve el primer elemento de la lista.

Cuando la clave de la lista no existe, devuelve null.

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

lPush

Inserta uno o más valores en la parte superior de la lista. Si la clave no existe, se crea una lista vacía y se ejecuta la operación LPUSH. Cuando la clave existe pero no es de tipo lista, devuelve false.

Nota: En versiones anteriores de Redis 2.4, el comando LPUSH solo aceptaba un valor.

$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

Inserta un valor en la parte superior de una lista que ya existe; si la lista no existe, la operación es inválida y devuelve 0. Si la clave no es de tipo lista, devuelve false.

El valor devuelto es la longitud de la lista después de ejecutar el comando 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

Devuelve los elementos dentro de la lista en el intervalo especificado, donde el intervalo está determinado por los desplazamientos START y END. Donde 0 representa el primer elemento de la lista, 1 representa el segundo elemento, y así sucesivamente. También puedes usar subíndices negativos, donde -1 representa el último elemento, -2 el penúltimo, y así sucesivamente.

Devuelve un array que contiene los elementos dentro del intervalo especificado. Si la clave no es de tipo lista, devuelve 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

Elimina los elementos que son iguales al valor del parámetro VALUE en la lista, en función del valor del parámetro COUNT.

El valor de COUNT puede ser uno de los siguientes:

• count > 0 : Busca desde el inicio de la lista hacia el final, eliminando tantos elementos como COUNT sean iguales a VALUE.
• count < 0 : Busca desde el final de la lista hacia el inicio, eliminando tantos elementos como el valor absoluto de COUNT sean iguales a VALUE.
• count = 0 : Elimina todos los valores que sean iguales a VALUE en la lista.

Devuelve la cantidad de elementos eliminados. Devuelve 0 si la lista no existe. Si no es una lista, devuelve false.

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

lSet

Establece el valor del elemento en función del índice.

Devuelve true si tiene éxito; si el índice está fuera de rango o se intenta hacer un LSET en una lista vacía, devuelve false.

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

lTrim

Recorta una lista, es decir, solo mantiene los elementos dentro del intervalo especificado, eliminando aquellos que no están dentro del intervalo especificado.

El índice 0 representa el primer elemento de la lista, mientras que 1 representa el segundo elemento, y así sucesivamente. También puedes utilizar índices negativos, donde -1 representa el último elemento de la lista, -2 representa el penúltimo, y así sucesivamente.

Devuelve true si tiene éxito; de lo contrario, devuelve false.

$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

Se utiliza para eliminar el último elemento de la lista, y devuelve el valor del elemento eliminado.

Cuando la lista no existe, devuelve null.

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

rPopLPush

Elimina el último elemento de la lista y lo añade a otra lista, devolviendo el nuevo elemento.

$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

Inserta uno o más valores en la parte final de la lista (más a la derecha), y devuelve la longitud de la lista después de la inserción.

Si la lista no existe, se crea una lista vacía y se ejecuta la operación RPUSH. Si la lista ya existe pero no es de tipo lista, devuelve false.

Nota: En versiones anteriores a Redis 2.4, el comando RPUSH solo aceptaba un único valor.

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

rPushX

Inserta un valor al final de una lista que ya existe (más a la derecha) y devuelve la longitud de la lista. Si la lista no existe, la operación es inválida y devuelve 0. Cuando la lista existe pero no es de tipo lista, devuelve false.

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

lLen

Devuelve la longitud de la lista. Si la clave de la lista no existe, la clave se interpreta como una lista vacía y se devuelve 0. Si la clave no es de tipo lista, devuelve 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

Agrega uno o más miembros al conjunto; los miembros que ya existen en el conjunto se ignoran.

Si la clave del conjunto no existe, se crea un conjunto que solo contiene los miembros agregados.

Cuando la clave del conjunto no es de tipo conjunto, devuelve false.

Nota: En versiones anteriores de Redis 2.4, SADD solo aceptaba un único miembro.

$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

Devuelve el número de elementos en el conjunto. Cuando la clave del conjunto no existe, devuelve 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

Devuelve la diferencia entre el primer conjunto y otros conjuntos, también se puede considerar como los elementos únicos en el primer conjunto. Las claves de conjuntos que no existen se consideran como un conjunto vacío.

$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

Almacena la diferencia entre los conjuntos dados en el conjunto especificado. Si el conjunto de destino ya existe, se sobrescribirá.

$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

Devuelve la intersección de todos los conjuntos dados. Las claves de conjuntos que no existen se consideran como un conjunto vacío. Cuando hay un conjunto vacío entre los conjuntos dados, el resultado también será un conjunto vacío.

$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

Almacena la intersección entre los conjuntos dados en el conjunto especificado y devuelve la cantidad de elementos almacenados en el conjunto de intersección. Si el conjunto especificado ya existe, se sobrescribirá.

$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

Verifica si el miembro especificado es un miembro del conjunto.

Si el miembro es parte del conjunto, devuelve 1. Si el miembro no es parte del conjunto o la clave no existe, devuelve 0. Si la clave no es de tipo conjunto, devuelve false.

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

sMembers

Devuelve todos los miembros del conjunto. Las claves de conjuntos que no existen se consideran como conjuntos vacíos.

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

sMove

Mueve el miembro especificado del conjunto de origen al conjunto de destino.

SMOVE es una operación atómica.

Si el conjunto de origen no existe o no contiene el elemento miembro especificado, el comando SMOVE no realiza ninguna acción y simplemente devuelve 0. De lo contrario, el elemento miembro se elimina del conjunto de origen y se agrega al conjunto de destino.

Cuando el conjunto de destino ya contiene el elemento miembro, el comando SMOVE simplemente elimina el elemento miembro del conjunto de origen.

Cuando la fuente o el destino no son de tipo conjunto, devuelve false.

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

sPop

Elimina y devuelve uno o varios elementos aleatorios de la clave del conjunto; devuelve los elementos eliminados.

Cuando el conjunto no existe o está vacío, devuelve 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

El comando Srandmember de Redis se utiliza para devolver un elemento aleatorio del conjunto.

Desde la versión 2.6 de Redis, el comando Srandmember acepta un parámetro count opcional:

• Si count es un número positivo y menor que el cardinal del conjunto, el comando devolverá un array que contenga count elementos, donde los elementos son distintos entre sí. Si count es mayor o igual que el cardinal del conjunto, devuelve todo el conjunto.
• Si count es un número negativo, el comando devuelve un array donde los elementos pueden aparecer varias veces, y la longitud del array es el valor absoluto de count.

Esta operación es similar a SPOP, pero SPOP elimina elementos aleatorios del conjunto y los devuelve, mientras que Srandmember solo devuelve elementos aleatorios sin modificar el conjunto.

$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

Elimina uno o más miembros del conjunto; los miembros que no existen se ignoran.

Devuelve la cantidad de elementos eliminados con éxito, excluyendo los elementos ignorados.

Cuando la clave no es de tipo conjunto, devuelve false.

En versiones anteriores de Redis 2.4, SREM solo aceptaba un único valor de miembro.

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

sUnion

El comando devuelve la unión de los conjuntos dados. Las claves de conjuntos que no existen se consideran como conjuntos vacíos.

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

sUnionStore

Almacena la unión de los conjuntos dados en el conjunto de destino especificado y devuelve la cantidad de elementos. Si el destino ya existe, se sobrescribirá.

$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']
});