workerman-redis

Introduzione

workeman/redis è un componente redis asincrono basato su workerman.

Nota
L'obiettivo principale di questo progetto è implementare l'abbonamento asincrono a redis (subscribe, pSubscribe)
Poiché redis è abbastanza veloce, a meno che non sia necessario l'abbonamento asincrono psubscribe subscribe, non è necessario utilizzare questo client asincrono; l'utilizzo dell'estensione redis offrirà prestazioni migliori.

Installazione:

composer require workerman/redis ^v2.0.3

Uso del 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 delle coroutine

Nota
L'uso delle coroutine richiede workerman>=5.0, workerman/redis>=2.0.0 e installare 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 non si impostano callback, il client restituirà il risultato della richiesta asincrona in modo sincrono, il processo di richiesta non blocca il processo attuale, il che significa che è possibile trattare le richieste in modo concorrente.

Nota
psubscribe subscribe non supporta l'uso delle coroutine.

Documentazione

Descrizione

Nel modo di callback, la funzione di callback ha generalmente 2 parametri ($result, $redis), dove $result è il risultato e $redis è l'istanza redis. Ad esempio:

use Workerman\Redis\Client;
$redis = new Client('redis://127.0.0.1:6379');
// Imposta la funzione di callback per verificare il risultato della chiamata set
$redis->set('key', 'value', function ($result, $redis) {
    var_dump($result); // true
});
// Le funzioni di callback sono parametri facoltativi, qui la funzione di callback è stata omessa
$redis->set('key1', 'value1');
// Le funzioni di callback possono essere annidate
$redis->get('key', function ($result, $redis){
    $redis->set('key2', 'value2', function ($result) {
        var_dump($result);
    });
});

Connessione

use Workerman\Redis\Client;
// Callback omesso
$redis = new Client('redis://127.0.0.1:6379');
// Con callback
$redis = new Client('redis://127.0.0.1:6379', [
    'connect_timeout' => 10 // Imposta il timeout di connessione a 10 secondi, senza impostazione predefinita di 5 secondi
], function ($success, $redis) {
    // Callback risultato della connessione
    if (!$success) echo $redis->error();
});

auth

//  Verifica password
$redis->auth('password', function ($result) {

});
// Verifica nome utente e password
$redis->auth('username', 'password', function ($result) {

});

pSubscribe

Sottoscrivi uno o più canali che corrispondono a un modello fornito.

Ogni modello usa come carattere jolly, ad esempio it corrisponde a tutti i canali che iniziano per it ( it.news, it.blog, it.tweets, ecc.). news.* corrisponde a tutti i canali che iniziano per news. ( news.it, news.global.today, ecc.), e così via.

Nota: la funzione di callback pSubscribe ha 4 parametri ($pattern, $channel, $message, $redis)

Quando l'istanza $redis chiama l'interfaccia pSubscribe o subscribe, le altre chiamate a metodi dell'istanza attuale vengono ignorate.

$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

Utilizzato per sottoscrivere le informazioni di uno o più canali specificati.

Nota: la funzione di callback subscribe ha 3 parametri ($channel, $message, $redis)

Quando l'istanza $redis chiama l'interfaccia pSubscribe o subscribe, le altre chiamate a metodi dell'istanza attuale vengono ignorate.

$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

Utilizzato per inviare informazioni al canale specificato.

Restituisce il numero di abbonati che hanno ricevuto l'informazione.

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

select

// Callback omesso
$redis->select(2);
$redis->select('test', function ($result, $redis) {
    // Il parametro select deve essere un numero, quindi qui $result è false
    var_dump($result, $redis->error());
});

get

Il comando è utilizzato per ottenere il valore della chiave specificata. Se la chiave non esiste, restituisce NULL. Se il valore memorizzato nella chiave non è di tipo stringa, restituisce false.

$redis->get('key', function($result) {
     // Se la chiave non esiste restituisce NULL, se c'è un errore restituisce false
    var_dump($result);
});

set

Usato per impostare il valore di una chiave specificata. Se la chiave ha già un valore memorizzato, SET sovrascrive il valore precedente, ignorando il tipo.

$redis->set('key', 'value');
$redis->set('key', 'value', function($result){});
// Il terzo parametro può specificare un tempo di scadenza, scade dopo 10 secondi
$redis->set('key','value', 10);
$redis->set('key','value', 10, function($result){});

setEx, pSetEx

Imposta il valore e il tempo di scadenza per una chiave specificata. Se la chiave esiste già, il comando SETEX sostituisce il valore vecchio.

// Nota: il secondo parametro specifica il tempo di scadenza in secondi
$redis->setEx('key', 3600, 'value'); 
// pSetEx il tempo è in millisecondi
$redis->pSetEx('key', 3600, 'value'); 

del

Utilizzato per eliminare una chiave esistente, il risultato restituito è un numero che rappresenta quanti key sono stati eliminati (le chiavi non esistenti non vengono conteggiate).

// Elimina una chiave
$redis->del('key');
// Elimina più chiavi
$redis->del(['key', 'key1', 'key2']);

setNx

(SETifNot eXists) Il comando imposta il valore specificato per la chiave solo se essa non esiste.

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

exists

Il comando è utilizzato per verificare se una chiave data esiste. Il risultato restituito è un numero che rappresenta il numero di chiavi esistenti.

$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 di uno/di un valore specificato il valore numerico memorizzato nella chiave. Se la chiave non esiste, il valore della chiave viene inizializzato a 0 e quindi si esegue l'operazione incr/incrBy.
Se il valore è di tipo errato, o se il valore di tipo stringa non può essere rappresentato come un numero, restituisce false.
Se ha successo, restituisce il valore aumentato.

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

incrByFloat

Incrementa per un valore di tipo float il valore memorizzato nella chiave.
Se la chiave non esiste, INCRBYFLOAT imposterà prima il valore della chiave a 0, e poi eseguirà l'operazione di somma.
Se il valore è di tipo errato, o se il valore di tipo stringa non può essere rappresentato come un numero, restituisce false.
Se ha successo, restituisce il valore aumentato.

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

decr, decrBy

Il comando sottrae uno/un valore di sottrazione specificato a un valore memorizzato nella chiave.
Se la chiave non esiste, il valore della chiave viene inizializzato a 0 e quindi si esegue l'operazione decr/decrBy.
Se il valore è di tipo errato, o se il valore di tipo stringa non può essere rappresentato come un numero, restituisce false.
Se ha successo, restituisce il valore diminuito.

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

mGet

Restituisce tutti i valori di una o più chiavi specificate. Se una delle chiavi specificate non esiste, restituisce 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

Utilizzato per impostare il valore specificato per una chiave e restituire il valore vecchio della chiave.

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

randomKey

Restituisce una chiave casuale dal database corrente.

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

move

Sposta una chiave dal database corrente al database specificato db.

$redis->select(0);  // passa al DB 0
$redis->set('x', '42'); // scrivi 42 in x
$redis->move('x', 1, function ($result) {   // sposta al DB 1
    var_dump($result); // 1
}) ;  
$redis->select(1);  // passa al DB 1
$redis->get('x', function ($result) {
    var_dump($result); // '42'
}) ;

rename

Rinomina una chiave, se la chiave non esiste restituisce false.

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

renameNx

Rinomina una chiave se la nuova chiave non esiste.

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

expire

Imposta un tempo di scadenza per la chiave, dopo il quale la chiave non sarà più disponibile. L'unità è in secondi. Restituisce 1 se ha successo, 0 se la chiave non esiste o non ha un tempo di scadenza, e false se si verifica un errore.

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

keys

Il comando viene utilizzato per cercare tutte le chiavi che corrispondono al modello pattern fornito.

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

type

Restituisce il tipo del valore memorizzato nella chiave. Il risultato restituito è una stringa, che può essere string, set, list, zset, hash o none, dove none indica che la chiave non esiste.

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

append

Se la chiave esiste già ed è una stringa, il comando APPEND aggiunge il valore alla fine del valore originale della chiave e restituisce la lunghezza della stringa.

Se la chiave non esiste, APPEND semplicemente imposta la chiave con il valore, come se eseguisse SET key value e restituisce la lunghezza della stringa.

Se la chiave esiste, ma non è di tipo stringa, restituisce 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

Ottiene la sottostringa memorizzata nella chiave specificata. L'intervallo di ritaglio della stringa è determinato da due offset: start e end (inclusi start e end). Se la chiave non esiste, restituisce la stringa vuota. Se la chiave non è di tipo stringa, restituisce 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

Sovrascrive il valore della stringa memorizzato nella chiave specificata con una stringa fornita, partendo dall'offset. Se la chiave non esiste, imposta la chiave sulla stringa specificata. Se la chiave non è di tipo stringa, restituisce false.

Il risultato è la lunghezza della stringa modificata.

$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

Restituisce la lunghezza del valore stringa memorizzato nella chiave specificata. Quando la chiave non memorizza valori stringa, restituisce false.

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

getBit

Ottiene il bit alla posizione specificata dell valore stringa memorizzato nella chiave.

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

setBit

Imposta o cancella il bit alla posizione specificata dell valore stringa memorizzato nella chiave.
Il valore restituito è 0 o 1, è il valore prima della modifica.

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

bitOp

Esegue operazioni bitwise tra più chiavi (che contengono valori stringa) e memorizza il risultato nell chiave di destinazione.

Il comando BITOP supporta quattro operazioni bitwise: AND, OR, XOR e NOT.

Il risultato memorizzato nella chiave di destinazione è la dimensione della stringa, pari alla dimensione della stringa di input più lunga.

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

bitCount

Controlla il numero di bit impostati nella stringa (conteggio della popolazione).

Per impostazione predefinita, esamina tutti i byte contenuti nella stringa. Il conteggio può essere specificato solo all'interno dell'intervallo passando i parametri aggiuntivi start e end.

Simile al comando GETRANGE, start e end possono includere valori negativi per indicizzare i byte dalla fine della stringa, dove -1 è l'ultimo byte, -2 è il penultimo byte, e così via.

Il risultato è il numero di bit con valore 1 nella stringa.

Le chiavi non esistenti sono considerate stringhe vuote, quindi questo comando restituirà 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

Il comando sort può ordinare gli elementi di list, set e sorted set.

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

Dove options è la seguente chiave e valore opzionali

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

Restituisce il tempo rimanente prima della scadenza della chiave in secondi/millisecondi.

Se la chiave non ha ttl, restituisce -1. Se la chiave non esiste, restituisce -2.

$redis->set('key', 'value', 10);
// in secondi
$redis->ttl('key', function ($result) {
    var_dump($result); // 10
});
// in millisecondi
$redis->pttl('key', function ($result) {
    var_dump($result); // 9999
});
// chiave non esiste
$redis->pttl('key-not-exists', function ($result) {
    var_dump($result); // -2
});

persist

Rimuove il tempo di scadenza per la chiave data, rendendo la chiave mai scaduta.

Restituisce 1 se ha rimosso correttamente, 0 se la chiave non esiste o non ha un tempo di scadenza, e false se si verifica un errore.

$redis->persist('key');

mSet, mSetNx

Imposta più coppie chiave-valore in un unico comando atomico. mSetNx restituisce 1 solo se tutte le chiavi sono state impostate.

Restituisce 1 in caso di successo, 0 in caso di fallimento e false se si verifica un errore.

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

hSet

Imposta un valore per un campo nella tabella hash.

Se il campo è un nuovo campo nella tabella hash e il valore è impostato correttamente, restituisce 1. Se il campo esiste già nella tabella hash e il valore precedente è stato sovrascritto dal nuovo valore, restituisce 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

Imposta un valore in un campo di hash non esistente.

Se la tabella hash non esiste, viene creata una nuova tabella hash e viene eseguita l'operazione HSET.

Se il campo esiste già nella tabella hash, l'operazione non ha effetto.

Se la chiave non esiste, viene creata una nuova tabella hash e viene eseguita l'operazione 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

Restituisce il valore di un campo specificato nella tabella hash.

Se il campo o la chiave specificati non esistono, restituisce null.

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

hLen

Restituisce il numero di campi in una tabella hash.

Quando la chiave non esiste, restituisce 0.

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

hDel

Elimina uno o più campi specificati dalla tabella hash. I campi che non esistono vengono ignorati.

Restituisce il numero di campi eliminati con successo, escluse le chiavi ignorate. Se la chiave non è di tipo hash, restituisce false.

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

hKeys

Restituisce tutti i campi nella tabella hash in forma di array.

Se la chiave non esiste, restituisce un array vuoto. Se la chiave non è di tipo hash, restituisce false.

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

hVals

Restituisce tutti i valori dei campi della tabella hash in forma di array.

Se la chiave non esiste, restituisce un array vuoto. Se la chiave non è di tipo hash, restituisce false.

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

hGetAll

Restituisce tutti i campi e i valori della tabella hash in forma di array associativo.

Se la chiave non esiste, restituisce un array vuoto. Se la chiave non è di tipo hash, restituisce 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); 
});

Restituisce

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

hExists

Controlla se un campo specificato esiste nella tabella hash. Restituisce 1 se esiste, 0 se il campo non esiste o la chiave non esiste, e false in caso di errore.

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

hIncrBy

Incrementa il valore di un campo della tabella hash di un valore specificato.

L'incremento può essere anche negativo, equivalenti a un'operazione di sottrazione sul campo specificato.

Se la chiave della tabella hash non esiste, viene creata una nuova tabella hash e viene eseguito il comando HINCRBY.

Se il campo specificato non esiste, il valore del campo viene inizializzato a 0 prima di eseguire il comando.

Se si esegue HINCRBY su un campo memorizzato come valore stringa, restituirà false.

Il valore operativo è limitato a numeri interi 64 bit (bit) firmati.

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

hIncrByFloat

Simile a hIncrBy, solo che l'incremento è di tipo float.

hMSet

Imposta più coppie campo-valore (field-value) nella tabella hash.

Questo comando sovrascrive i campi già esistenti nella tabella hash.

Se la tabella hash non esiste, viene creata una tabella hash vuota e viene eseguita l'operazione HMSET.

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

hMGet

Restituisce in forma di array associativo il valore di uno o più campi specificati nella tabella hash.

Se un campo specificato non esiste nella tabella hash, il valore corrispondente sarà null. Se la chiave non è di tipo hash, restituisce 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);
});

Output

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

blPop, brPop

Rimuove e ottiene il primo/ultimo elemento della lista. Se la lista è vuota, blocca la lista fino a quando non scade o trova un elemento da rimuovere.

$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

Rimuove l'ultimo elemento della lista e lo inserisce nella testa di un'altra lista; se non ci sono elementi nella lista, la lista rimane bloccata fino al timeout o fino al momento in cui trova un elemento da rimuovere. Se scade, restituisce 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

Ottiene un elemento della lista in base all'indice. Puoi anche utilizzare indici negativi, dove -1 indica l'ultimo elemento della lista, -2 indica il penultimo elemento, e così via.

Se il valore dell'indice specificato non si trova nell'intervallo della lista, restituisce null. Se la chiave non è di tipo lista, restituisce false.

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

lInsert

Inserisce un elemento prima o dopo un elemento nella lista. Quando l'elemento specificato non esiste nella lista, non esegue alcuna operazione.

Quando la lista non esiste, viene considerata come lista vuota e non esegue alcuna operazione.

Se la chiave non è di tipo lista, restituisce 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

Rimuove e restituisce il primo elemento della lista.

Quando la chiave della lista non esiste, restituisce null.

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

lPush

Inserisce uno o più valori all'inizio della lista. Se la chiave non esiste, viene creata una lista vuota e viene eseguita l'operazione LPUSH. Quando la chiave esiste ma non è di tipo lista, restituisce false.

Nota: nelle versioni di Redis 2.4 precedenti, il comando LPUSH accettava solo un singolo valore.

$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

Inserisce un valore all'inizio della lista che esiste già; se la lista non esiste, l'operazione non ha effetto e restituisce 0. Se la chiave non è di tipo lista, restituisce false.

Il valore restituito è la lunghezza della lista dopo l'esecuzione del 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

Restituisce gli elementi nella lista all'interno di un intervallo specificato; l'intervallo è determinato dagli offset START e END. Dove 0 indica il primo elemento della lista, 1 indica il secondo elemento della lista, e così via. Puoi anche utilizzare indici negativi, dove -1 indica l'ultimo elemento, -2 indica il penultimo elemento, e così via.

Restituisce un array contenente gli elementi all'interno dell'intervallo specificato. Se la chiave non è di tipo lista, restituisce 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

Rimuove gli elementi dalla lista che corrispondono al valore specificato, in base al valore del parametro COUNT.

Il valore di COUNT può essere uno dei seguenti:

• count > 0 : cerca dalla testa della lista verso la coda e rimuove elementi uguali a VALUE, fino a COUNT elementi.
• count < 0 : cerca dalla coda verso la testa e rimuove elementi uguali a VALUE, fino all'assoluto valore di COUNT.
• count = 0 : rimuove tutti i valori che sono uguali a VALUE dalla lista.

Restituisce il numero di elementi rimossi. Restituisce 0 se la lista non esiste. Restituisce false se non è una lista.

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

lSet

Imposta il valore di un elemento nella lista in base all'indice.

Restituisce true se ha successo, restituisce false se l'indice è fuori limite, o se si esegue LSET su una lista vuota.

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

lTrim

Riduce la lista mantenendo solo gli elementi all'interno di un intervallo specificato, eliminando gli elementi al di fuori di tale intervallo.

L'indice 0 indica il primo elemento della lista, l'indice 1 indica il secondo elemento della lista, e così via. Puoi anche utilizzare indici negativi, dove -1 indica l'ultimo elemento, -2 indica il penultimo elemento, e così via.

Restituisce true se ha successo, false se fallisce.

$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

Utilizzato per rimuovere l'ultimo elemento della lista, il valore restituito è l'elemento rimosso.

Quando la lista non esiste, restituisce null.

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

rPopLPush

Rimuove l'ultimo elemento della lista e lo aggiunge a un'altra lista, restituendo così il suo valore.

$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

Inserisce uno o più valori alla fine della lista (lato destro) e restituisce la lunghezza della lista inserita.

Se la lista non esiste, viene creata una lista vuota e viene eseguita l'operazione RPUSH. Quando la lista esiste ma non è di tipo lista, restituisce false.

Nota: nelle versioni di Redis 2.4 precedenti, il comando RPUSH accettava solo un singolo valore.

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

rPushX

Inserisce un valore alla fine della lista già esistente (lato destro) e restituisce la lunghezza della lista. Se la lista non esiste, l'operazione è invalida e restituisce 0. Quando la lista esiste ma non è di tipo lista, restituisce false.

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

lLen

Restituisce la lunghezza della lista. Se la chiave della lista non esiste, la chiave è interpretata come una lista vuota e restituisce 0. Se la chiave non è di tipo lista, restituisce 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

Aggiunge uno o più membri a un insieme, i membri già presenti nell'insieme verranno ignorati.

Se la chiave dell'insieme non esiste, viene creata una nuova insieme che contiene solo gli elementi aggiunti.

Quando la chiave dell'insieme non è di tipo insieme, restituisce false.

Nota: nelle versioni di Redis 2.4 precedenti, il comando SADD accettava solo un singolo valore 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

Restituisce il numero di membri nell'insieme. Quando la chiave dell'insieme non esiste, restituisce 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

Restituisce la differenza tra il primo insieme e gli altri insieme, può essere considerato come gli elementi unici del primo insieme. Gli insiemi non esistenti vengono trattati come insiemi vuoti.

$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

Memoria la differenza tra dati insiemi specificati in un insieme specificato. Se l'insieme di destinazione esiste già, verrà sovrascritto.

$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

Restituisce l'intersezione di tutti gli insiemi specificati. Gli insiemi non esistenti vengono trattati come insiemi vuoti. Se uno degli insiemi specificati è vuoto, il risultato sarà anche vuoto.

$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

Memorizza l'intersezione tra insiemi specificati e restituisce il numero di elementi nell'insieme di intersezione memorizzato. Se l'insieme di destinazione esiste già, verrà sovrascritto.

$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

Controlla se un membro è membro dell'insieme.

Restituisce 1 se il membro è membro dell'insieme. Restituisce 0 se il membro non è presente nell'insieme, o se la chiave non esiste. Se la chiave non è di tipo insieme, restituisce false.

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

sMembers

Restituisce tutti i membri dell'insieme. Gli insiemi non esistenti vengono trattati come insiemi vuoti.

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

sMove

Sposta un membro specificato dall'insieme sorgente a un insieme di destinazione.

SMOVE è un'operazione atomica.

Se l'insieme sorgente non esiste o non contiene il membro specificato, il comando SMOVE non eseguirà alcuna operazione e restituirà solo 0. Altrimenti, il membro verrà rimosso dall'insieme sorgente e aggiunto all'insieme di destinazione.

Se l'insieme di destinazione esiste già e contiene già il membro, il comando SMOVE semplicemente rimuoverà il membro dall'insieme sorgente.

Se la sorgente o la destinazione non sono di tipo insieme, restituisce false.

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

sPop

Rimuove uno o più membri casuali di un dato insieme, e restituisce i membri rimossi.

Quando l'insieme è vuoto o non esiste, restituisce 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

Il comando Redis Srandmember è utilizzato per restituire un membro casuale dall'insieme.

A partire dalla versione 2.6 di Redis, il comando Srandmember accetta un parametro count opzionale:

• Se count è positivo e minore della cardinalità dell'insieme, il comando restituisce un array contenente count elementi, ciascuno diverso. Se count è maggiore o uguale alla cardinalità, restituisce l'intero insieme.
• Se count è negativo, il comando restituisce un array in cui i membri possono apparire più volte e la lunghezza dell'array è l'assoluto valore di count.

Questa operazione è simile a SPOP, ma SPOP rimuove e restituisce i membri casuali dall'insieme, mentre Srandmember restituirà solo membri casuali senza modificare l'insieme.

$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

Rimuove uno o più membri dall'insieme, ignorando i membri non presenti.

Restituisce il numero di membri rimossi con successo, non includendo i membri ignorati.

Quando la chiave non è di tipo insieme, restituisce false.

Nelle versioni di Redis 2.4 precedenti, il comando SREM accettava solo un singolo valore membro.

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

sUnion

Il comando restituisce l'unione di insiemi specificati. Gli insiemi non esistenti vengono trattati come insiemi vuoti.

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

sUnionStore

Memorizza l'unione di insiemi specificati in un insieme di destinazione e restituisce il numero di elementi. Se l'insieme di destinazione esiste già, verrà sovrascritto.

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