workerman-redis

Введение

workeman/redis является асинхронным компонентом redis, основанным на workerman.

Внимание
Основная цель этого проекта - осуществить асинхронную подписку redis (subscribe, pSubscribe).
Так как redis достаточно быстрый, если вам не требуется pSubscribe или subscribe для асинхронной подписки, то нет необходимости использовать этот асинхронный клиент; использование расширения redis будет более производительным.

Установка:

composer require workerman/redis ^v2.0.3

Использование обратного вызова

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

Использование корутин

Внимание
Для использования корутин требуется workerman>=5.0, workerman/redis>=2.0.0 и установка 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();

Когда обратная функция не установлена, клиент будет возвращать результат асинхронного запроса синхронным образом, и процесс запроса не блокирует текущий процесс, что позволяет обрабатывать запросы параллельно.

Внимание
psubscribe subscribe не поддерживают использование корутин.

Документация

Объяснение

В обратном вызове, функции обратного вызова обычно имеют 2 параметра ($result, $redis), где $result - это результат, а $redis - это экземпляр redis. Например:

use Workerman\Redis\Client;
$redis = new Client('redis://127.0.0.1:6379');
// Установка функции обратного вызова для проверки результата вызова set
$redis->set('key', 'value', function ($result, $redis) {
    var_dump($result); // true
});
// Функции обратного вызова являются необязательными параметрами, здесь опущена функция обратного вызова
$redis->set('key1', 'value1');
// Функции обратного вызова могут быть вложенными
$redis->get('key', function ($result, $redis){
    $redis->set('key2', 'value2', function ($result) {
        var_dump($result);
    });
});

Соединение

use Workerman\Redis\Client;
// без обратного вызова
$redis = new Client('redis://127.0.0.1:6379');
// с обратным вызовом
$redis = new Client('redis://127.0.0.1:6379', [
    'connect_timeout' => 10 // устанавливает тайм-аут подключения в 10 секунд, по умолчанию 5 секунд
], function ($success, $redis) {
    // обратный вызов результата подключения
    if (!$success) echo $redis->error();
});

auth

//  Аутентификация по паролю
$redis->auth('password', function ($result) {

});
// Аутентификация по имени пользователя и паролю
$redis->auth('username', 'password', function ($result) {

});

pSubscribe

Подписка на одну или несколько каналов, соответствующих заданному шаблону.

Каждый шаблон использует * в качестве символа соответствия, например it* соответствует всем каналам, начинающимся с it ( it.news, it.blog, it.tweets и т.д.). news.* соответствует всем каналам, начинающимся с news. ( news.it, news.global.today и т.д.), и так далее.

Обратите внимание: у функции обратного вызова pSubscribe четыре параметра ($pattern, $channel, $message, $redis).

Когда экземпляр $redis вызывает интерфейсы pSubscribe или subscribe, последующие вызовы других методов для текущего экземпляра будут игнорироваться.

$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

Используется для подписки на информацию о одном или нескольких каналах.

Обратите внимание: у функции обратного вызова subscribe три параметра ($channel, $message, $redis).

Когда экземпляр $redis вызывает интерфейсы pSubscribe или subscribe, последующие вызовы других методов для текущего экземпляра будут игнорироваться.

$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

Используется для отправки информации на указанный канал.

Возвращает количество подписчиков, получивших информацию.

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

select

// без обратного вызова
$redis->select(2);
$redis->select('test', function ($result, $redis) {
    // параметр select должен быть числом, поэтому здесь $result будет false
    var_dump($result, $redis->error());
});

get

Команда используется для получения значения по указанному ключу. Если ключ не существует, возвращается NULL. Если значение, сохраненное по ключу, не является строковым типом, возвращает false.

$redis->get('key', function($result) {
     // если ключ не существует, возвращается NULL, если произошла ошибка, возвращается false
    var_dump($result);
});

set

Используется для задания значения для заданного ключа. Если ключ уже хранит значение, SET перезаписывает старое значение, игнорируя тип.

$redis->set('key', 'value');
$redis->set('key', 'value', function($result){});
// третий параметр можно передать для срока действия, истекает через 10 секунд
$redis->set('key','value', 10);
$redis->set('key','value', 10, function($result){});

setEx, pSetEx

Устанавливает значение и его срок действия для указанного ключа. Если ключ уже существует, SETEX заменяет старое значение.

// Обратите внимание, что второй параметр передает срок действия, в секундах
$redis->setEx('key', 3600, 'value'); 
// pSetEx имеет единицу измерения в миллисекундах
$redis->pSetEx('key', 3600, 'value'); 

del

Удаляет существующие ключи, возвращает результат в виде числа, представляющего количество удаленных ключей (несуществующие ключи не учитываются).

// удалить один ключ
$redis->del('key');
// удалить несколько ключей
$redis->del(['key', 'key1', 'key2']);

setNx

(SETifNot eXists) команда устанавливает заданное значение для ключа, если ключ не существует.

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

exists

Команда используется для проверки, существует ли заданный ключ. Результат возвращается в виде числа, представляющего количество существующих ключей.

$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

Увеличивает числовое значение, хранящееся по ключу на 1/указанное значение. Если ключ не существует, значение ключа сначала инициализируется как 0, а затем выполняется операция incr/incrBy.
Если значение имеет неправильный тип или строковое значение не может быть интерпретировано как число, возвращает false.
Успешное выполнение возвращает увеличенное значение.

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

incrByFloat

Увеличивает значение, хранящееся по ключу, на заданное дробное число.
Если ключ не существует, INCRBYFLOAT сначала устанавливает значение ключа как 0, а затем выполняет операцию сложения.
Если значение имеет неправильный тип или строковое значение не может быть интерпретировано как число, возвращает false.
Успешное выполнение возвращает увеличенное значение.

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

decr, decrBy

Команда уменьшает значение, хранящееся по ключу на 1/указанное уменьшение.
Если ключ не существует, значение ключа сначала инициализируется как 0, а затем выполняется операция decr/decrBy.
Если значение имеет неправильный тип или строковое значение не может быть интерпретировано как число, возвращает false.
Успешное выполнение возвращает уменьшенное значение.

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

mGet

Возвращает все (один или несколько) значения для заданных ключей. Если в заданном наборе ключей есть ключ, который не существует, то он возвращает 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

Устанавливает заданное значение для указанного ключа и возвращает старое значение данного ключа.

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

randomKey

Случайно возвращает один ключ из текущей базы данных.

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

move

Перемещает ключ из текущей базы данных в указанную базу данных db.

$redis->select(0);  // переключение на БД 0
$redis->set('x', '42'); // записать 42 в x
$redis->move('x', 1, function ($result) {   // перемещение в БД 1
    var_dump($result); // 1
}) ;  
$redis->select(1);  // переключение на БД 1
$redis->get('x', function ($result) {
    var_dump($result); // '42'
}) ;

rename

Изменяет имя ключа, возвращает false, если ключ не существует.

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

renameNx

Изменяет имя ключа, если новый ключ не существует.

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

expire

Устанавливает срок действия ключа, после которого ключ больше не будет доступен. Устанавливается в секундах. Возвращает 1 при успешном удалении, 0 если ключ не существует или нет срока действия, возвращает false в случае ошибки.

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

keys

Команда используется для поиска всех ключей, соответствующих заданному шаблону pattern.

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

type

Возвращает тип значения, хранящегося по ключу. Результат возвращается в виде строки, одной из следующих: string set list zset hash none, где none обозначает, что ключ не существует.

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

append

Если ключ уже существует и является строкой, команда APPEND добавит value в конец ранее существующего значения для ключа и вернет длину строки.

Если ключ не существует, APPEND просто установит данный ключ в значение value, как если бы была выполнена команда SET key value, и вернет длину строки.

Если ключ существует, но не является строкой, возвращает 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

Получает подстроку, хранящуюся в строке для заданного ключа. Диапазон среза строки определяется двумя смещениями start и end (включительно). Если ключ не существует, возвращается пустая строка. Если ключ не является строковым типом, возвращает 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

Перезаписывает значение строки, хранящейся по указанному ключу, начиная с указанного смещения offset. Если ключ не существует, он будет установлен в указанный строковый. Если ключ не является строковым типом, возвращает false.

Результат возвращает длину измененной строки.

$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

Получает длину строкового значения, хранящегося по указанному ключу. Когда значение по ключу не является строковым, возвращает false.

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

getBit

Получает бит (bit) по заданному смещению для строкового значения, хранящегося по ключу.

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

setBit

Устанавливает или очищает бит (bit) по указанному смещению для строкового значения, хранящегося по ключу.
Возвращает 0 или 1, что соответствует значению перед изменением.

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

bitOp

Выполняет побитовые операции между несколькими ключами (содержит строковые значения) и сохраняет результат в целевом ключе.

Команда BITOP поддерживает четыре побитовые операции: AND, OR, XOR и NOT.

Возвращает размер строки, сохраненной в целевом ключе, то есть равный размеру самой длинной входной строки.

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

bitCount

Подсчитывает количество установленных битов (популяция) в строке.

По умолчанию проверяются все байты, содержащиеся в строке. Только при передаче дополнительных параметров start и end можно указать интервал для подсчета.

По аналогии с командой GETRANGE, начало и конец могут включать отрицательные значения для индексации байтов с конца строки, где -1 - это последний байт, -2 - предпоследний байт и так далее.

Результат возвращает количество единичных битов в строке.

Несуществующие ключи воспринимаются как пустые строки, поэтому данная команда вернет ноль.

$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

Команда sort позволяет сортировать элементы списка, множества и сортированного множества.

Прототип: sort($key, $options, $callback);

Где options - это следующие опциональные ключи и значения

$options = [
     'by' => 'some_pattern_*',
    'limit' => [0, 1],
    'get' => 'some_other_pattern_*', // или массив паттернов
    'sort' => 'asc', // или '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

Возвращает оставшееся время жизни (TTL) ключа в секундах/миллисекундах.

Если у ключа нет ttl, возвращается -1. Если ключ не существует, возвращается -2.

$redis->set('key', 'value', 10);
// В секундах
$redis->ttl('key', function ($result) {
    var_dump($result); // 10
});
// В миллисекундах
$redis->pttl('key', function ($result) {
    var_dump($result); // 9999
});
// ключ не существует
$redis->pttl('key-not-exists', function ($result) {
    var_dump($result); // -2
});

persist

Удаляет срок действия для заданного ключа, таким образом ключ никогда не истечет.

Если удаление выполнено успешно, возвращает 1, если ключ не существует или срок действия не установлен, возвращает 0, возвращает false в случае ошибки.

$redis->persist('key');

mSet, mSetNx

В одном атомарном команде устанавливает несколько пар ключ-значение. mSetNx возвращает 1 только в случае успешной установки всех ключей.

Успешное выполнение возвращает 1, неуспешное - 0, с ошибкой - false.

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

hSet

Устанавливает значение для поля в хэш-таблице.

Если поле является новым в хэш-таблице, и значение успешно установлено, возвращает 1. Если поле уже существует в хэш-таблице и старое значение было перезаписано, возвращает 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

Устанавливает значение для поля, если оно не существует в хэш-таблице.

Если хэш-таблица не существует, создается новая хэш-таблица и выполняется HSET.

Если поле уже существует в хэш-таблице, операция игнорируется.

Если ключ не существует, создается новая хэш-таблица и выполняется команда 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

Возвращает значение указанного поля в хэш-таблице.

Если указанное поле или ключ не существует, возвращает null.

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

hLen

Используется для получения количества полей в хэш-таблице.

Когда ключ не существует, возвращает 0.

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

hDel

Команда используется для удаления одного или нескольких указанных полей в хэш-таблице key. Поля, которые не существуют, будут игнорироваться.

Возвращает количество успешно удаленных полей, не включая проигнорированные. Если ключ не является хэшем, возвращает false.

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

hKeys

Возвращает все ключи в хэш-таблице в виде массива.

Если ключ не существует, возвращает пустой массив. Если ключ не является хэшем, возвращает false.

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

hVals

Возвращает все значения в хэш-таблице в виде массива.

Если ключ не существует, возвращает пустой массив. Если ключ не является хэшем, возвращает false.

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

hGetAll

Возвращает все поля и значения в хэш-таблице в виде ассоциативного массива.

Если ключ не существует, возвращает пустой массив. Если ключ не является хэш-таблицей, возвращает 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); 
});

Возврат

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

hExists

Проверяет, существует ли указанное поле в хэш-таблице. Возвращает 1, если поле существует, 0, если поле не существует или ключ не существует, возвращает false в случае ошибки.

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

hIncrBy

Используется для увеличения значения поля в хэш-таблице на указанное значение.

Увеличение также может быть отрицательным, эквивалентно операции вычитания для указанного поля.

Если ключ хэш-таблицы не существует, создается новая хэш-таблица и выполняется команда HINCRBY.

Если указанное поле не существует, значение поля инициализируется как 0 перед выполнением команды.

Выполнение команды HINCRBY для поля, хранящего строковое значение, вернет false.

Результаты находятся в пределах 64-битного (bit) знакового числа.

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

hIncrByFloat

Аналогично hIncrBy, но увеличение имеет дробный тип.

hMSet

Устанавливает несколько пар field-value (поле-значение) в хэш-таблице одновременно.

Эта команда перезаписывает существующие поля в хэш-таблице.

Если хэш-таблица не существует, создается пустая хэш-таблица и выполняется операция HMSET.

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

hMGet

Возвращает значения одного или нескольких указанных полей хэш-таблицы в виде ассоциативного массива.

Если указанное поле не существует в хэш-таблице, то соответствующее поле будет nul. Если ключ не является хэшем, возвращает 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);
});

Вывод

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

blPop, brPop

Удаляет и получает первый/последний элемент списка. Если у списка нет элементов, будет блокироваться до тех пор, пока не истечет время ожидания или не будет найден элемент для удаления.

$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

Извлекает последний элемент из списка и вставляет его в начало другого списка; если список пуст, блокирует до истечения времени ожидания или появления элемента для удаления. Если время ожидания истечет, вернет 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

Извлекает элемент списка по индексу. Вы также можете использовать отрицательные индексы, чтобы -1 обозначало последний элемент списка, -2 - предпоследний и так далее.

Если заданный индекс не находится в диапазоне списка, возвращает null. Если соответствующий ключ не является списком, возвращает false.

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

lInsert

Вставляет элемент перед или после существующего в списке. Если указанный элемент не существует в списке, операция не выполняется.

Когда список не существует, он рассматривается как пустой список, операция не выполняется.

Если ключ не является списком, возвращает 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

Удаляет и возвращает первый элемент списка.

Когда ключ списка не существует, возвращает null.

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

lPush

Вставляет одно или несколько значений в начало списка. Если ключ не существует, создается пустой список и выполняется операция LPUSH. Если ключ существует, но не является списком, возвращает false.

Внимание: до версии Redis 2.4 команда LPUSH принимала только одно значение.

$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

Вставляет одно значение в начало уже существующего списка. Если список не существует, операция не выполняется, возвращает 0. Если ключ не является списком, возвращает false.

Возвращает длину списка после выполнения команды 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

Возвращает элементы списка, находящиеся в указанном диапазоне, где диапазон задается смещениями START и END. В то время как 0 означает первый элемент списка, 1 означает второй элемент и так далее. Вы также можете использовать отрицательные индексы, чтобы -1 обозначало последний элемент списка, -2 - предпоследний и так далее.

Возвращает массив, содержащий элементы, находящиеся в указанном диапазоне. Если ключ не является списком, возвращает 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

Удаляет из списка элементы, равные значению параметра VALUE, в зависимости от значения параметра COUNT.

Значение COUNT может быть следующим:

• count > 0 : Ищет от начала к концу списка, удаляя элементы, равные VALUE, в количестве COUNT.
• count < 0 : Ищет от конца к началу списка, удаляя элементы, равные VALUE, в количестве, равном абсолютному значению COUNT.
• count = 0 : Удаляет все элементы, равные VALUE, из списка.

Возвращает количество удаленных элементов. Если список не существует, возвращает 0. Если элемент не является списком, возвращает false.

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

lSet

Устанавливает значение элемента по индексу.

Возвращает true при успешном выполнении, возвращает false, если индекс выходит за пределы диапазона или если команда LSET выполняется для пустого списка.

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

lTrim

Обрезает (trim) список, то есть сохраняет только элементы, находящиеся в указанном диапазоне, удаляя все элементы, которые находятся вне этого диапазона.

Индекс 0 означает первый элемент списка, 1 означает второй элемент списка и так далее. Вы также можете использовать отрицательные индексы, чтобы -1 обозначало последний элемент списка, -2 - предпоследний и так далее.

Возвращает true при успешном выполнении, возвращает 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

Удаляет последний элемент списка и возвращает значение удаленного элемента.

Когда список не существует, возвращает null.

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

rPopLPush

Удаляет последний элемент списка и добавляет его в другой список, возвращая его.

$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

Вставляет одно или несколько значений в конец списка (в самый правый конец) и возвращает длину списка после вставки.

Если список не существует, создается пустой список и выполняется операция RPUSH. Если список существует, но не является списком, возвращает false.

Внимание: до версии Redis 2.4 команда RPUSH принимала только одно значение.

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

rPushX

Вставляет одно значение в конец уже существующего списка (в самый правый конец) и возвращает длину списка. Если список не существует, операция не выполняется, возвращает 0. Если список существует, но не является списком, возвращает false.

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

lLen

Возвращает длину списка. Если ключ списка не существует, ключ рассматривается как пустой список, возвращает 0. Если ключ не является списком, возвращает 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

Добавляет один или несколько элементов в множество. Существует элементы, которые уже находятся в множестве, будут проигнорированы.

Если множество ключа не существует, создается множество, содержащее только добавленные элементы.

Когда ключ множества не является множеством, возвращает false.

Внимание: до версии Redis 2.4 команда SADD принимала только одно значение элемента.

$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

Возвращает количество элементов в множестве. Когда ключ множества не существует, возвращает 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

Возвращает разницу между первым множеством и другими множествами, можно также рассматривать это как элементы, уникальные для первого множества. Несуществующие ключи множества рассматриваются как пустое множество.

$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

Сохраняет разность между указанными множествами в заданном множестве. Если указанное множество уже существует, оно будет перезаписано.

$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

Возвращает пересечение всех заданных множеств. Несуществующие ключи множества рассматриваются как пустое множество. Если одно из множества пустое, результат также будет пустым множеством.

$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

Сохраняет пересечение между указанными множествами в заданном множестве и возвращает количество элементов, хранящихся в множестве. Если указанное множество уже существует, оно будет перезаписано.

$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

Определяет, является ли указанный элемент членом множества.

Если элемент принадлежит множеству, возвращает 1. Если элемент не принадлежит множеству или ключ не существует, возвращает 0. Если ключ не является множеством, возвращает false.

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

sMembers

Возвращает всех членов в множестве. Несуществующие ключи множества рассматриваются как пустое множество.

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

sMove

Перемещает указанный элемент member из исходного множества в целевое множество.

SMOVE - это атомарная операция.

Если исходное множество не существует или не содержит указанный элемент member, команда SMOVE не выполняется и просто возвращает 0. В противном случае элемент member удаляется из исходного множества и добавляется в целевое множество.

Если целевое множество уже содержит элемент member, команда SMOVE просто удаляет элемент member из исходного множества.

Если исходный или целевой ключ не является множеством, возвращает false.

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

sPop

Удаляет один или несколько случайных элементов из множества, возвращая удаленные элементы.

Если множество не существует или пустое, возвращает 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

Команда Srandmember в Redis используется для возвращения случайного элемента из множества.

С версии Redis 2.6 команда Srandmember принимает дополнительные параметры count:

• Если count положительное и меньше количества элементов в множестве, команда возвращает массив из count уникальных элементов. Если count больше или равно количеству элементов в множестве, возвращается все множество.
• Если count отрицательное, команда возвращает массив, в котором элементы могут повторяться несколько раз, а длина массива равняется абсолютному значению count.

Эта операция аналогична SPOP, однако SPOP удаляет случайные элементы из множества и возвращает их, а Srandmember просто возвращает случайные элементы, не изменяя множество.

$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

Удаляет один или несколько элементов из множества, несуществующие элементы игнорируются.

Возвращает количество успешно удаленных элементов, исключая проигнорированные элементы.

Если ключ не является множеством, возвращает false.

До версии Redis 2.4 команда SREM принимала только одно значение элемента.

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

sUnion

Возвращает объединение заданных множеств. Несуществующие ключи множества рассматриваются как пустое множество.

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

sUnionStore

Сохраняет объединение заданных множеств в указанном множестве назначения и возвращает количество элементов. Если назначение уже существует, оно будет перезаписано.

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