workerman-redis

Introdução

workerman/redis é um componente de redis assíncrono baseado em workerman.

Nota
O objetivo principal deste projeto é implementar a assinatura assíncrona do redis (subscribe, pSubscribe).
Como o redis é rápido o suficiente, não é necessário usar este cliente assíncrono a menos que você precise da assinatura assíncrona psubscribe ou subscribe, pois o uso da extensão redis terá um desempenho melhor.

Instalação:

composer require workerman/redis ^v2.0.3

Uso de Callback

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 Corrotina

Nota
O uso de corrotina requer workerman>=5.0, workerman/redis>=2.0.0 e instalação 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();

Quando não se configura uma função de callback, o cliente retornará o resultado da solicitação assíncrona de forma síncrona; o processo de solicitação não bloqueará o processo atual, ou seja, pode tratar solicitações de forma concorrente.

Nota
psubscribe subscribe não suporta uso de corrotina

Documentação

Descrição

No modo de callback, a função de callback geralmente tem 2 parâmetros ($result, $redis), onde $result é o resultado e $redis é a instância do redis. Por exemplo:

use Workerman\Redis\Client;
$redis = new Client('redis://127.0.0.1:6379');
// Define a função de callback para verificar o resultado da chamada set
$redis->set('key', 'value', function ($result, $redis) {
    var_dump($result); // true
});
// Funções de callback são parâmetros opcionais, aqui a função de callback foi omitida
$redis->set('key1', 'value1');
// Função de callback pode ser aninhada
$redis->get('key', function ($result, $redis){
    $redis->set('key2', 'value2', function ($result) {
        var_dump($result);
    });
});

Conexão

use Workerman\Redis\Client;
// Omitir callback
$redis = new Client('redis://127.0.0.1:6379');
// Com callback
$redis = new Client('redis://127.0.0.1:6379', [
    'connect_timeout' => 10 // Define o tempo limite de conexão para 10 segundos; se não definido, o padrão é 5 segundos
], function ($success, $redis) {
    // Callback do resultado da conexão
    if (!$success) echo $redis->error();
});

auth

//  Autenticação de senha
$redis->auth('password', function ($result) {

});
// Autenticação de nome de usuário e senha
$redis->auth('username', 'password', function ($result) {

});

pSubscribe

Assina um ou mais canais que correspondem ao padrão fornecido.

Cada padrão usa como coringa, por exemplo, it corresponde a todos os canais que começam com it (it.news, it.blog, it.tweets, etc.). news.* corresponde a todos os canais que começam com news. (news.it, news.global.today, etc.), e assim por diante.

Nota: A função de callback do pSubscribe tem 4 parâmetros ($pattern, $channel, $message, $redis).

Depois que a instância $redis chama a interface pSubscribe ou subscribe, outras chamadas de método nesta instância serão ignoradas.

$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, conteúdo da notícia
});

Timer::add(5, function () use ($redis2){
    $redis2->publish('news.add', 'conteúdo da notícia');
});

subscribe

Usado para assinar informações de um ou mais canais especificados.

Nota: A função de callback do subscribe tem 3 parâmetros ($channel, $message, $redis).

Depois que a instância $redis chama a interface pSubscribe ou subscribe, outras chamadas de método nesta instância serão ignoradas.

$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, conteúdo da notícia
});

Timer::add(5, function () use ($redis2){
    $redis2->publish('news', 'conteúdo da notícia');
});

publish

Usado para enviar informações ao canal especificado.

Retorna a quantidade de assinantes que receberam a mensagem.

$redis2->publish('news', 'conteúdo da notícia');

select

// Omitir callback
$redis->select(2);
$redis->select('test', function ($result, $redis) {
    // O parâmetro select deve ser um número, então aqui $result será false
    var_dump($result, $redis->error());
});

get

O comando é usado para obter o valor de uma chave específica. Se a chave não existir, retorna NULL. Se o valor armazenado na chave não for do tipo string, retorna false.

$redis->get('key', function($result) {
     // Se a chave não existir, retorna NULL; se ocorrer um erro, retorna false
    var_dump($result);
});

set

Usado para definir o valor de uma chave específica. Se a chave já tiver um valor armazenado, o SET sobrescreverá o valor antigo, ignorando o tipo.

$redis->set('key', 'value');
$redis->set('key', 'value', function($result){});
// O terceiro parâmetro pode passar um tempo de expiração, expirando após 10 segundos
$redis->set('key','value', 10);
$redis->set('key','value', 10, function($result){});

setEx, pSetEx

Define o valor e o tempo de expiração para a chave especificada. Se a chave já existir, o comando SETEX substituirá o valor antigo.

// Nota: o segundo parâmetro passa o tempo de expiração, em segundos
$redis->setEx('key', 3600, 'value'); 
// pSetEx o tempo é em milissegundos
$redis->pSetEx('key', 3600, 'value'); 

del

Usado para remover uma chave existente, retornando um número que representa quantas chaves foram removidas (as chaves inexistentes não são contadas).

// Remove uma chave
$redis->del('key');
// Remove várias chaves
$redis->del(['key', 'key1', 'key2']);

setNx

(SETifNot eXists) O comando define um valor para a chave se ela não existir.

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

exists

O comando é usado para verificar se uma chave específica existe. O resultado retornado é um número que representa quantas chaves existem.

$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

Aumenta o valor numérico armazenado na chave em um ou um valor especificado. Se a chave não existir, o valor da chave será inicialmente definido como 0, e depois a operação incr/incrBy será realizada. Se o valor tiver um tipo errôneo, ou se for um valor do tipo string que não puder ser representado como numérico, retornará false. O sucesso retornará o valor após o aumento.

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

incrByFloat

Adiciona um valor de incremento de ponto flutuante armazenado na chave. Se a chave não existir, INCRBYFLOAT definirá o valor da chave como 0 e, em seguida, realizará a operação de adição. Se o valor tiver um tipo errôneo, ou se for um valor do tipo string que não puder ser representado como numérico, retornará false. O sucesso retornará o valor após o aumento.

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

decr, decrBy

O comando diminui o valor armazenado na chave em um/valor especificado. Se a chave não existir, o valor da chave será inicialmente definido como 0 e, em seguida, a operação de decr/decrBy será realizada. Se o valor tiver um tipo errôneo, ou se for um valor do tipo string que não puder ser representado como numérico, retornará false. O sucesso retornará o valor após a diminuição.

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

mGet

Retorna todos os valores (um ou mais) das chaves dadas. Se alguma das chaves não existir, essa chave retornará 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

Usado para definir o valor da chave especificada e retornar o antigo valor da chave.

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

randomKey

Retorna aleatoriamente uma chave do banco de dados atual.

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

move

Move a chave do banco de dados atual para o banco de dados db dado.

$redis->select(0);  // muda para o DB 0
$redis->set('x', '42'); // escreve 42 em x
$redis->move('x', 1, function ($result) {   // move para o DB 1
    var_dump($result); // 1
}) ;  
$redis->select(1);  // muda para o DB 1
$redis->get('x', function ($result) {
    var_dump($result); // '42'
}) ;

rename

Modifica o nome da chave; se a chave não existir, retorna false.

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

renameNx

Modifica o nome da chave quando a nova chave não existir.

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

expire

Define o tempo de expiração da chave, que não estará mais disponível após o término. A unidade é em segundos. Retorna 1 se o sucesso e 0 se a chave não existir ou não tiver tempo de expiração, retorna false se ocorrer erro.

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

keys

O comando é usado para encontrar todas as chaves que correspondem ao padrão dado.

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

type

Retorna o tipo do valor armazenado na chave. O resultado é uma string, uma das seguintes: string, set, list, zset, hash, none, onde none significa que a chave não existe.

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

append

Se a chave já existir e for uma string, o comando APPEND irá anexar o valor ao final do valor de origem da chave e retornar o comprimento da string.

Se a chave não existir, o APPEND simplesmente definirá a chave fornecida como valor, assim como executando SET key value e retornando o comprimento da string.

Se a chave existir, mas não for uma string, retornará 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

Obtém a substring armazenada na chave especificada. O intervalo da string é determinado pelos deslocamentos start e end (incluindo start e end). Se a chave não existir, retorna uma string vazia. Se a chave não for do tipo string, retorna 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

Substitui o valor da string que a chave armazena na posição específica a partir do deslocamento offset. Se a chave não existir, define a chave como a string especificada. Se a chave não for do tipo string, retorna false.

O resultado é o comprimento da string alterada.

$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

Obtém o comprimento do valor armazenado na chave específica. Quando a chave não armazena valor string, retorna false.

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

getBit

Para o valor de string armazenado na chave, obtém o bit no deslocamento especificado.

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

setBit

Para o valor armazenado na chave, define ou limpa o bit no deslocamento especificado.
O valor retornado é 0 ou 1, que é o valor antes da modificação.

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

bitOp

Executa operações bit a bit entre várias chaves (que contêm valores de string) e armazena o resultado na chave de destino.

O comando BITOP suporta quatro operações bit a bit: AND, OR, XOR e NOT.

O resultado é o tamanho da string armazenada na chave de destino, que é igual ao tamanho da string de entrada mais longa.

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

bitCount

Conta o número de bits configurados na string (contagem populacional).

Por padrão, irá verificar todos os bytes contidos na string. Somente operações de contagem podem ser especificadas dentro do intervalo ao passar parâmetros adicionais start e end.

Similar ao comando GETRANGE, start e end podem incluir valores negativos para indexar os bytes da string a partir do final, onde -1 é o último byte, -2 é o penúltimo byte, e assim por diante.

O resultado é o número de bits na string com valor 1.

As chaves inexistentes são tratadas como strings vazias, então esse comando retornará zero.

$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

O comando sort pode ordenar elementos de listas, conjuntos e conjuntos ordenados.

Protótipo: sort($key, $options, $callback);

Onde options são as seguintes chaves e valores opcionais

$options = [
     'by' => 'some_pattern_*',
    'limit' => [0, 1],
    'get' => 'some_other_pattern_*', // ou um array de padrões
    '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

Retorna o tempo restante em que a chave expire, em segundos/milissegundos.

Se uma chave não tiver ttl, retorna -1. Se a chave não existir, retorna -2.

$redis->set('key', 'value', 10);
// Em segundos
$redis->ttl('key', function ($result) {
    var_dump($result); // 10
});
// Em milissegundos
$redis->pttl('key', function ($result) {
    var_dump($result); // 9999
});
// Chave não existe
$redis->pttl('key-not-exists', function ($result) {
    var_dump($result); // -2
});

persist

Remove o tempo de expiração da chave dada, fazendo com que a chave nunca expire.

Se for removido com sucesso, retorna 1; se a chave não existir ou não tiver tempo de expiração, retorna 0; se ocorrer um erro, retorna false.

$redis->persist('key');

mSet, mSetNx

Define múltiplos pares chave-valor em um comando atômico. mSetNx retorna 1 somente se todas as chaves forem definidas.

Retorna 1 em caso de sucesso, 0 em caso de falha, ou false se ocorrer erro.

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

hSet

Define um valor para um campo em uma tabela hash.

Se o campo for um novo campo na tabela hash e o valor for definido com sucesso, retorna 1. Se o campo já existir na tabela hash e o valor antigo for sobrescrito pelo novo, retorna 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

Define um valor para um campo que não existe na tabela hash.

Se a tabela hash não existir, uma nova tabela hash será criada e a operação HSET será realizada.

Se o campo já existir na tabela hash, a operação não terá efeito.

Se a chave não existir, uma nova tabela hash será criada e o comando HSETNX será executado.

$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

Retorna o valor de um campo específico na tabela hash.

Se o campo ou a chave especificada não existir, retorna null.

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

hLen

Usado para obter a quantidade de campos em uma tabela hash.

Quando a chave não existir, retorna 0.

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

hDel

Comando usado para remover um ou mais campos especificados na tabela hash key, campos inexistentes serão ignorados.

Retorna a quantidade de campos removidos com sucesso, excluindo campos ignorados. Se a chave não for hash, retorna false.

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

hKeys

Obtém todos os campos da tabela hash em forma de array.

Se a chave não existir, retorna um array vazio. Se a chave não corresponder ao tipo hash, retorna false.

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

hVals

Retorna todos os valores dos campos na tabela hash em forma de array.

Se a chave não existir, retorna um array vazio. Se a chave não corresponder ao tipo hash, retorna false.

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

hGetAll

Retorna todos os campos e valores da tabela hash em forma de array associativo.

Se a chave não existir, retorna um array vazio. Se a chave não for do tipo hash, retorna 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); 
});

Retorno

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

hExists

Verifica se um campo especificado existe na tabela hash. Retorna 1 se existir, 0 se o campo não existir ou a chave não existir, retorna false se ocorrer erro.

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

hIncrBy

Usado para incrementar o valor de um campo na tabela hash em um valor específico.

O incremento também pode ser um número negativo, o que equivale a realizar a operação de subtração no campo especificado.

Se a chave da tabela hash não existir, uma nova tabela hash será criada e o comando HINCRBY será executado.

Se o campo especificado não existir, o valor do campo será inicializado em 0 antes da execução do comando.

Executar o comando HINCRBY em um campo que armazena um valor do tipo string retornará false.

O valor das operações está limitado à representação dos números inteiros de 64 bits (bit).

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

hIncrByFloat

Similar ao hIncrBy, exceto que o incremento é do tipo float.

hMSet

Define simultaneamente vários pares field-value (campo-valor) na tabela hash.

Este comando sobrescreve campos existentes na tabela hash.

Se a tabela hash não existir, uma tabela hash vazia é criada e a operação HMSET é executada.

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

hMGet

Retorna um ou mais campos dados da tabela hash em forma de array associativo.

Se um campo especificado não existir na tabela hash, o campo correspondente será null. Se a chave não for hash, retorna 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);
});

Saída

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

blPop, brPop

Remove e obtém o primeiro/último elemento da lista; Se não houver elementos, a lista será bloqueada até que um elemento seja removido ou o tempo de espera ocorra.

$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

Remove o último elemento da lista e o insere no início de outra lista; Se não houver elementos, a lista será bloqueada até que um elemento seja removido ou o tempo de espera ocorra. Se houver tempo limite, retorna 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

Obtém um elemento na lista pelo índice. Você também pode usar índices negativos, onde -1 representa o último elemento da lista, -2 representa o penúltimo elemento, e assim por diante.

Se o índice não estiver no intervalo da lista, retorna null. Se a chave correspondente não for do tipo lista, retorna false.

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

lInsert

Insere um elemento antes ou depois de um elemento na lista. Se o elemento especificado não existir na lista, não faz nenhuma operação.

Se a lista não existir, é considerada uma lista vazia e não faz nenhuma operação.

Se a chave não for do tipo lista, retorna 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

Remove e retorna o primeiro elemento da lista.

Quando a chave da lista não existir, retorna null.

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

lPush

Insere um ou mais valores no início da lista. Se a chave não existir, uma lista vazia será criada e a operação LPUSH será executada. Quando a chave existe, mas não é do tipo lista, retorna false.

Nota: No Redis antes da versão 2.4, o comando LPUSH só aceitava um único 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

Insere um valor no início de uma lista já existente; se a lista não existir, a operação não terá efeito, retornando 0. Se a chave não for do tipo lista, retorna false.

O valor retornado é o comprimento da lista depois da execução do 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

Retorna os elementos da lista no intervalo especificado, onde o intervalo é definido pelos deslocamentos START e END. Onde 0 representa o primeiro elemento da lista, 1 representa o segundo elemento, e assim por diante. Você também pode usar índices negativos, onde -1 representa o último elemento, -2 representa o penúltimo, e assim por diante.

Retorna um array contendo os elementos no intervalo especificado. Se a chave não for do tipo lista, retorna 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

Remove elementos que são iguais ao valor especificado da lista de acordo com o valor do parâmetro COUNT.

O valor de COUNT pode ser dos seguintes tipos:

• count > 0 : Procura de cabeça para cauda, removendo elementos iguais ao VALUE, um número igual a COUNT.
• count < 0 : Procura de cauda para cabeça, removendo elementos iguais ao VALUE, um número igual ao valor absoluto de COUNT.
• count = 0 : Remove todos os valores iguais ao VALUE da lista.

Retorna o número de elementos removidos. Retorna 0 se a lista não existir. Se não for do tipo lista, retorna false.

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

lSet

Define o valor de um elemento através do índice.

Retorna true se for bem sucedido; se o parâmetro do índice estiver fora do intervalo ou se a operação LSET for aplicada em uma lista vazia, retorna false.

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

lTrim

Faz um corte na lista, isto é, mantém a lista apenas com os elementos no intervalo especificado, excluindo os elementos fora desse intervalo.

O índice 0 representa o primeiro elemento da lista, o índice 1 representa o segundo elemento, e assim por diante. Você também pode usar índices negativos, onde -1 representa o último elemento da lista, -2 representa o penúltimo elemento, e assim por diante.

Retorna true se for bem-sucedido; caso contrário, retorna 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

Usado para remover o último elemento da lista, retornando o valor do elemento removido.

Quando a lista não existe, retorna null.

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

rPopLPush

Remove o último elemento da lista e o adiciona a outra lista, retornando o 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

Insere um ou mais valores no final da lista (na extremidade direita) e retorna o comprimento da lista após a inserção.

Se a lista não existir, uma lista vazia será criada e a operação RPUSH será executada. Quando a lista existe, mas não é do tipo lista, retorna false.

Nota: No Redis, antes da versão 2.4, o comando RPUSH só aceitava um único valor.

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

rPushX

Insere um valor no final de uma lista existente (na extremidade direita) e retorna o comprimento da lista. Se a lista não existir, a operação não terá efeito, retornando 0. Quando a lista existe, mas não é do tipo lista, retorna false.

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

lLen

Retorna o comprimento da lista. Se a chave não existir, a chave é interpretada como uma lista vazia e retorna 0. Se a chave não for do tipo lista, retorna 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

Adiciona um ou mais membros ao conjunto, ignorando elementos que já existem.

Se a chave do conjunto não existir, cria um conjunto que contém apenas os elementos adicionados como membros.

Quando a chave do conjunto não é do tipo conjunto, retorna false.

Nota: No Redis, antes da versão 2.4, o SADD só aceitava um único valor de membro.

$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

Retorna a quantidade de elementos no conjunto. Quando a chave do conjunto não existir, retorna 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

Retorna a diferença entre o primeiro conjunto e os outros conjuntos; também pode ser considerável como os elementos únicos do primeiro conjunto. Um conjunto que não existir será tratado como um conjunto vazio.

$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

Armazena a diferença entre conjuntos especificados em um conjunto especificado. Se o conjunto especificado já existir, será sobrescrito.

$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

Retorna a interseção de todos os conjuntos dados. Um conjunto não existente será tratado como um conjunto vazio. Quando um conjunto dado é vazio, o resultado também é um conjunto vazio.

$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

Armazena a interseção entre conjuntos em um conjunto especificado e retorna a quantidade de elementos do conjunto armazenado. Se o conjunto especificado já existir, será sobrescrito.

$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 se um determinado membro é membro do conjunto.

Se o membro for parte do conjunto, retorna 1. Se não for membro do conjunto ou a chave não existir, retorna 0. Se a chave não for do tipo conjunto, retorna false.

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

sMembers

Retorna todos os membros do conjunto. Um conjunto não existente será tratado como um conjunto vazio.

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

sMove

Move o membro especificado do conjunto de origem para o conjunto de destino.

SMOVE é uma operação atômica.

Se o conjunto de origem não existir ou não contiver o membro especificado, o comando SMOVE não terá efeito e retornará apenas 0. Caso contrário, o membro é removido do conjunto de origem e adicionado ao conjunto de destino.

Quando o conjunto de destino já contém o membro, o comando SMOVE simplesmente remove o membro do conjunto de origem.

Quando os conjuntos de origem ou de destino não são do tipo conjunto, retorna false.

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

sPop

Remove um ou mais elementos aleatórios do conjunto especificado e retorna os elementos removidos.

Quando o conjunto não existir ou estiver vazio, retorna 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

O comando Redis Srandmember é usado para retornar um elemento aleatório do conjunto.

A partir da versão 2.6 do Redis, o comando Srandmember aceita um parâmetro opcional count:

• Se count for um número positivo e menor que a cardinalidade do conjunto, o comando retornará um array contendo count elementos, onde cada elemento é exclusivo. Se count for maior ou igual à cardinalidade do conjunto, retornará todo o conjunto.
• Se count for um número negativo, o comando retornará um array cujo comprimento é o valor absoluto de count, onde os elementos podem aparecer repetidamente.

Essa operação é semelhante ao SPOP, mas o SPOP remove e retorna elementos aleatórios do conjunto, enquanto o Srandmember apenas retorna elementos aleatórios, sem modificar o 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

Remove um ou mais membros do conjunto; membros inexistentes serão ignorados.

Retorna a quantidade de elementos removidos com sucesso, excluindo elementos ignorados.

Quando a chave não for do tipo conjunto, retorna false.

No Redis antes da versão 2.4, o SREM só aceitava um valor de membro.

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

sUnion

O comando retorna a união dos conjuntos dados. Um conjunto não existente será tratado como um conjunto vazio.

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

sUnionStore

Armazena a união dados dos conjuntos em um conjunto especificado e retorna a quantidade de elementos do conjunto de destino. Se o conjunto de destino já existir, será sobrescrito.

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