The phpredis extension provides an API for communicating with the Redis key-value store. It also supports KeyDB and Valkey, which are open source alternatives to Redis.

It is released under the PHP License, version 3.01.

You can send comments, patches, questions here on github, to michael.grunder@gmail.com (Twitter, Mastodon), p.yatsukhnenko@gmail.com (@yatsukhnenko), or n.favrefelix@gmail.com (@yowgi).

These are a work in progress, but will eventually replace our ONE README TO RULE THEM ALL docs.

PhpRedis will always be free and open source software, but if you or your company has found it useful please consider supporting the project. Developing a large, complex, and performant library like PhpRedis takes a great deal of time and effort, and support would be appreciated! ❤️

The best way to support the project is through GitHub sponsors. Many of the reward tiers grant access to our slack channel where myself and Pavlo are regularly available to answer questions. Additionally this will allow you to provide feedback on which fixes and new features to prioritize.

You can also make a one-time contribution with

1. Installing/Configuring
   • Installation
   • PHP Session handler
   • Distributed Redis Array
   • Redis Cluster support
   • Redis Sentinel support
   • Running the unit tests
2. Classes and methods
   • Usage
   • Connection
   • Retry and backoff
   • Server
   • Keys and strings
   • Hashes
   • Lists
   • Sets
   • Sorted sets
   • HyperLogLogs
   • Geocoding
   • Streams
   • Pub/sub
   • Transactions
   • Scripting
   • Introspection

For everything you should need to install PhpRedis on your system, see the INSTALL.md page.

phpredis can be used to store PHP sessions. To do this, configure session.save_handler and session.save_path in your php.ini to tell phpredis where to store the sessions.

session.save_path can have a simple host:port format too, but you need to provide the tcp:// scheme if you want to use the parameters. The following parameters are available:

• weight (integer): the weight of a host is used in comparison with the others in order to customize the session distribution on several hosts. If host A has twice the weight of host B, it will get twice the amount of sessions. In the example, host1 stores 20% of all the sessions (1/(1+2+2)) while host2 and host3 each store 40% (2/(1+2+2)). The target host is determined once and for all at the start of the session, and doesn't change. The default weight is 1.
• timeout (float): the connection timeout to a redis host, expressed in seconds. If the host is unreachable in that amount of time, the session storage will be unavailable for the client. The default timeout is very high (86400 seconds).
• persistent (integer, should be 1 or 0): defines if a persistent connection should be used.
• prefix (string, defaults to "PHPREDIS_SESSION:"): used as a prefix to the Redis key in which the session is stored. The key is composed of the prefix followed by the session ID.
• auth (string, or an array with one or two elements): used to authenticate with the server prior to sending commands.
• database (integer): selects a different database.

Sessions have a lifetime expressed in seconds and stored in the INI variable "session.gc_maxlifetime". You can change it with ini_set(). The session handler requires a version of Redis supporting EX and NX options of SET command (at least 2.6.12). phpredis can also connect to a unix domain socket: session.save_path = "unix:///var/run/redis/redis.sock?persistent=1&weight=1&database=0".

Multiple Redis servers:

session.save_handler = redis
session.save_path = "tcp://host1:6379?weight=1, tcp://host2:6379?weight=2&timeout=2.5, tcp://host3:6379?weight=2&read_timeout=2.5"

Login to Redis using username and password:

session.save_handler = redis
session.save_path = "tcp://127.0.0.1:6379?auth[]=user&auth[]=password"

Login to Redis using username, password, and set prefix:

session.save_handler = redis
session.save_path = "tcp://127.0.0.1:6379?auth[]=user&auth[]=password&prefix=user_PHPREDIS_SESSION:"

Support: Locking feature is currently only supported for Redis setup with single master instance (e.g. classic master/slave Sentinel environment). So locking may not work properly in RedisArray or RedisCluster environments.

Following INI variables can be used to configure session locking:

; Should the locking be enabled? Defaults to: 0.
redis.session.locking_enabled = 1
; How long should the lock live (in seconds)? Defaults to: value of max_execution_time.
redis.session.lock_expire = 60
; How long to wait between attempts to acquire lock, in microseconds (µs)?. Defaults to: 20000
redis.session.lock_wait_time = 50000
; Maximum number of times to retry (-1 means infinite). Defaults to: 100
redis.session.lock_retries = 2000

Following INI variables can be used to configure session compression:

; Should session compression be enabled? Possible values are zstd, lzf, lz4, none. Defaults to: none
redis.session.compression = zstd
; What compression level should be used? Compression level depends on used library. For most deployments range 1-9 should be fine. Defaults to: 3
redis.session.compression_level = 3

phpredis uses a small custom unit test suite for testing functionality of the various classes. To run tests, simply do the following:

# Run tests for Redis class (note this is the default)
php tests/TestRedis.php --class Redis

# Run tests for RedisArray class
tests/mkring.sh start
php tests/TestRedis.php --class RedisArray
tests/mkring.sh stop

# Run tests for the RedisCluster class
tests/make-cluster.sh start
php tests/TestRedis.php --class RedisCluster
tests/make-cluster.sh stop

# Run tests for RedisSentinel class
php tests/TestRedis.php --class RedisSentinel

Note that it is possible to run only tests which match a substring of the test itself by passing the additional argument '--test ' when invoking.

# Just run the 'echo' test
php tests/TestRedis.php --class Redis --test echo

1. Class Redis
2. Class RedisException
3. Predefined constants

Description: Creates a Redis client

$redis = new Redis();

Starting from version 6.0.0 it's possible to specify configuration options. This allows to connect lazily to the server without explicitly invoking connect command.

$redis = new Redis([
    'host' => '127.0.0.1',
    'port' => 6379,
    'connectTimeout' => 2.5,
    'auth' => ['phpredis', 'phpredis'],
    'ssl' => ['verify_peer' => false],
    'backoff' => [
        'algorithm' => Redis::BACKOFF_ALGORITHM_DECORRELATED_JITTER,
        'base' => 500,
        'cap' => 750,
    ],
]);

host: string. can be a host, or the path to a unix domain socket.
port: int (default is 6379, should be -1 for unix domain socket)
connectTimeout: float, value in seconds (default is 0 meaning unlimited)
retryInterval: int, value in milliseconds (optional)
readTimeout: float, value in seconds (default is 0 meaning unlimited)
persistent: mixed, if value is string then it used as persistend id, else value casts to boolean
auth: mixed, authentication information
ssl: array, SSL context options

phpredis throws a RedisException object if it can't reach the Redis server. That can happen in case of connectivity issues, if the Redis service is down, or if the redis host is overloaded. In any other problematic case that does not involve an unreachable server (such as a key not existing, an invalid command, etc), phpredis will return FALSE.

Description: Available Redis Constants

Redis data types, as returned by type

Redis::REDIS_STRING - String
Redis::REDIS_SET - Set
Redis::REDIS_LIST - List
Redis::REDIS_ZSET - Sorted set
Redis::REDIS_HASH - Hash
Redis::REDIS_NOT_FOUND - Not found / other

@TODO: OPT_SERIALIZER, AFTER, BEFORE,...

1. connect, open - Connect to a server
2. pconnect, popen - Connect to a server (persistent)
3. auth - Authenticate to the server
4. select - Change the selected database for the current connection
5. swapdb - Swaps two Redis databases
6. close - Close the connection
7. setOption - Set client option
8. getOption - Get client option
9. ping - Ping the server
10. echo - Echo the given string

Description: Connects to a Redis instance.

host: string. can be a host, or the path to a unix domain socket. Starting from version 5.0.0 it is possible to specify schema
port: int, optional
timeout: float, value in seconds (optional, default is 0 meaning it will use default_socket_timeout)
reserved: should be '' if retry_interval is specified
retry_interval: int, value in milliseconds (optional)
read_timeout: float, value in seconds (optional, default is 0 meaning it will use default_socket_timeout)
others: array, with PhpRedis >= 5.3.0, it allows setting auth and stream configuration.

BOOL: TRUE on success, FALSE on error.

$redis->connect('127.0.0.1', 6379);
$redis->connect('127.0.0.1'); // port 6379 by default
$redis->connect('tls://127.0.0.1', 6379); // enable transport level security.
$redis->connect('tls://127.0.0.1'); // enable transport level security, port 6379 by default.
$redis->connect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout.
$redis->connect('/tmp/redis.sock'); // unix domain socket.
$redis->connect('127.0.0.1', 6379, 1, '', 100); // 1 sec timeout, 100ms delay between reconnection attempts.
$redis->connect('/tmp/redis.sock', 0, 1.5, NULL, 0, 1.5); // Unix socket with 1.5s timeouts (connect and read)

/* With PhpRedis >= 5.3.0 you can specify authentication and stream information on connect */
$redis->connect('127.0.0.1', 6379, 1, '', 0, 0, ['auth' => ['phpredis', 'phpredis']]);

Note: open is an alias for connect and will be removed in future versions of phpredis.

Description: Connects to a Redis instance or reuse a connection already established with pconnect/popen.

The connection will not be closed on end of request until the php process ends. So be prepared for too many open FD's errors (specially on redis server side) when using persistent connections on many servers connecting to one redis server.

Also more than one persistent connection can be made identified by either host + port + timeout or host + persistent_id or unix socket + timeout.

Starting from version 4.2.1, it became possible to use connection pooling by setting INI variable redis.pconnect.pooling_enabled to 1.

This feature is not available in threaded versions. pconnect and popen then working like their non persistent equivalents.

host: string. can be a host, or the path to a unix domain socket. Starting from version 5.0.0 it is possible to specify schema
port: int, optional
timeout: float, value in seconds (optional, default is 0 meaning it will use default_socket_timeout)
persistent_id: string. identity for the requested persistent connection
retry_interval: int, value in milliseconds (optional)
read_timeout: float, value in seconds (optional, default is 0 meaning it will use default_socket_timeout)

BOOL: TRUE on success, FALSE on error.

$redis->pconnect('127.0.0.1', 6379);
$redis->pconnect('127.0.0.1'); // port 6379 by default - same connection like before.
$redis->pconnect('tls://127.0.0.1', 6379); // enable transport level security.
$redis->pconnect('tls://127.0.0.1'); // enable transport level security, port 6379 by default.
$redis->pconnect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout and would be another connection than the two before.
$redis->pconnect('127.0.0.1', 6379, 2.5, 'x'); // x is sent as persistent_id and would be another connection than the three before.
$redis->pconnect('/tmp/redis.sock'); // unix domain socket - would be another connection than the four before.

Note: popen is an alias for pconnect and will be removed in future versions of phpredis.

Description: Authenticate the connection using a password or a username and password. Warning: The password is sent in plain-text over the network.

MIXED: password

BOOL: TRUE if the connection is authenticated, FALSE otherwise.

Note: In order to authenticate with a username and password you need Redis >= 6.0.

/* Authenticate with the password 'foobared' */
$redis->auth('foobared');

/* Authenticate with the username 'phpredis', and password 'haxx00r' */
$redis->auth(['phpredis', 'haxx00r']);

/* Authenticate with the password 'foobared' */
$redis->auth(['foobared']);

/* You can also use an associative array specifying user and pass */
$redis->auth(['user' => 'phpredis', 'pass' => 'phpredis']);
$redis->auth(['pass' => 'phpredis']);

Description: Change the selected database for the current connection.

INTEGER: dbindex, the database number to switch to.

TRUE in case of success, FALSE in case of failure.

See method for example: move

Description: Swap one Redis database with another atomically

INTEGER: db1
INTEGER: db2

TRUE on success and FALSE on failure.

Note: Requires Redis >= 4.0.0

$redis->swapdb(0, 1); /* Swaps DB 0 with DB 1 atomically */

Description: Disconnects from the Redis instance.

Note: Closing a persistent connection requires PhpRedis >= 4.2.0.

None.

BOOL: TRUE on success, FALSE on failure.

Description: Set client option.

parameter name
parameter value

BOOL: TRUE on success, FALSE on error.

$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);	  // Don't serialize data
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);	  // Use built-in serialize/unserialize
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY); // Use igBinary serialize/unserialize
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_MSGPACK);  // Use msgpack serialize/unserialize
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_JSON);  // Use JSON to serialize/unserialize

$redis->setOption(Redis::OPT_PREFIX, 'myAppName:');	// use custom prefix on all keys

/* Options for the SCAN family of commands, indicating whether to abstract
   empty results from the user.  If set to SCAN_NORETRY (the default), phpredis
   will just issue one SCAN command at a time, sometimes returning an empty
   array of results.  If set to SCAN_RETRY, phpredis will retry the scan command
   until keys come back OR Redis returns an iterator of zero
*/
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);

/* Scan can also be configured to automatically prepend the currently set PhpRedis
   prefix to any MATCH pattern. */
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_PREFIX);
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NOPREFIX);

Description: Get client option.

parameter name

Parameter value.

// return Redis::SERIALIZER_NONE, Redis::SERIALIZER_PHP, 
//        Redis::SERIALIZER_IGBINARY, Redis::SERIALIZER_MSGPACK or Redis::SERIALIZER_JSON
$redis->getOption(Redis::OPT_SERIALIZER);

Description: Check the current connection status.

$redis->ping([string $message]);

Mixed: This method returns TRUE on success, or the passed string if called with an argument.

/* When called without an argument, PING returns `TRUE` */
$redis->ping();

/* If passed an argument, that argument is returned.  Here 'hello' will be returned */
$redis->ping('hello');

Note: Prior to PhpRedis 5.0.0 this command simply returned the string +PONG.

Description: Sends a string to Redis, which replies with the same string

STRING: The message to send.

STRING: the same message.

1. Maximum retries
2. Backoff algorithms

You can set and get the maximum retries upon connection issues using the OPT_MAX_RETRIES option. Note that this is the number of retries, meaning if you set this option to n, there will be a maximum n+1 attempts overall. Defaults to 10.

$redis->setOption(Redis::OPT_MAX_RETRIES, 5);
$redis->getOption(Redis::OPT_MAX_RETRIES);

You can set the backoff algorithm using the Redis::OPT_BACKOFF_ALGORITHM option and choose among the following algorithms described in this blog post by Marc Brooker from AWS: Exponential Backoff And Jitter:

• Default: Redis::BACKOFF_ALGORITHM_DEFAULT
• Decorrelated jitter: Redis::BACKOFF_ALGORITHM_DECORRELATED_JITTER
• Full jitter: Redis::BACKOFF_ALGORITHM_FULL_JITTER
• Equal jitter: Redis::BACKOFF_ALGORITHM_EQUAL_JITTER
• Exponential: Redis::BACKOFF_ALGORITHM_EXPONENTIAL
• Uniform: Redis::BACKOFF_ALGORITHM_UNIFORM
• Constant: Redis::BACKOFF_ALGORITHM_CONSTANT

These algorithms depend on the base and cap parameters, both in milliseconds, which you can set using the Redis::OPT_BACKOFF_BASE and Redis::OPT_BACKOFF_CAP options, respectively.

$redis->setOption(Redis::OPT_BACKOFF_ALGORITHM, Redis::BACKOFF_ALGORITHM_DECORRELATED_JITTER);
$redis->setOption(Redis::OPT_BACKOFF_BASE, 500); // base for backoff computation: 500ms
$redis->setOption(Redis::OPT_BACKOFF_CAP, 750); // backoff time capped at 750ms

1. acl - Manage Redis ACLs
2. bgRewriteAOF - Asynchronously rewrite the append-only file
3. bgSave - Asynchronously save the dataset to disk (in background)
4. config - Get or Set the Redis server configuration parameters
5. dbSize - Return the number of keys in selected database
6. flushAll - Remove all keys from all databases
7. flushDb - Remove all keys from the current database
8. info - Get information and statistics about the server
9. lastSave - Get the timestamp of the last disk save
10. save - Synchronously save the dataset to disk (wait to complete)
11. slaveOf - Make the server a slave of another instance, or promote it to master
12. time - Return the current server time
13. slowLog - Access the Redis slowLog entries

Description: Execute the Redis ACL command.

variable: Minimum of one argument for Redis and two for RedisCluster.

$redis->acl('USERS'); /* Get a list of users */
$redis->acl('LOG');   /* See log of Redis' ACL subsystem */

Note: In order to user the ACL command you must be communicating with Redis >= 6.0 and be logged into an account that has access to administration commands such as ACL. Please reference this tutorial for an overview of Redis 6 ACLs and the redis command reference for every ACL subcommand.

Note: If you are connecting to Redis server >= 4.0.0 you can remove a key with the unlink method in the exact same way you would use del. The Redis unlink command is non-blocking and will perform the actual deletion asynchronously.

Description: Start the background rewrite of AOF (Append-Only File)

None.

BOOL: TRUE in case of success, FALSE in case of failure.

$redis->bgRewriteAOF();

Description: Asynchronously save the dataset to disk (in background)

None.

BOOL: TRUE in case of success, FALSE in case of failure. If a save is already running, this command will fail and return FALSE.

$redis->bgSave();

Description: Get or Set the Redis server configuration parameters.

$redis->config(string $operation, string|array|null $key = NULL, ?string $value = NULL): mixed;

Associative array for GET, key(s) -> value(s)
bool for SET, RESETSTAT, and REWRITE

$redis->config("GET", "*max-*-entries*");
$redis->config("SET", ['timeout', 'loglevel']);
$redis->config("SET", "dir", "/var/run/redis/dumps/");
$redis->config("SET", ['timeout' => 128, 'loglevel' => 'warning']);
$redis->config('RESETSTAT');

Description: Return the number of keys in selected database.

None.

INTEGER: DB size, in number of keys.

$count = $redis->dbSize();
echo "Redis has $count keys\n";

Description: Remove all keys from all databases.

async (bool) requires server version 4.0.0 or greater

BOOL: Always TRUE.

$redis->flushAll();

Description: Remove all keys from the current database.

$redis->flushdb(?bool $sync = NULL): Redis|bool;

BOOL: This command returns true on success and false on failure.

$redis->flushDb();

Description: Get information and statistics about the server

Returns an associative array that provides information about the server. Passing no arguments to INFO will call the standard REDIS INFO command, which returns information such as the following:

• redis_version
• arch_bits
• uptime_in_seconds
• uptime_in_days
• connected_clients
• connected_slaves
• used_memory
• changes_since_last_save
• bgsave_in_progress
• last_save_time
• total_connections_received
• total_commands_processed
• role

You can pass a variety of options to INFO (per the Redis documentation), which will modify what is returned.

option: The option to provide redis (e.g. "COMMANDSTATS", "CPU")

$redis->info(); /* standard redis INFO command */
$redis->info("COMMANDSTATS"); /* Information on the commands that have been run (>=2.6 only)
$redis->info("CPU"); /* just CPU information from Redis INFO */

Description: Returns the timestamp of the last disk save.

None.

INT: timestamp.

$redis->lastSave();

Description: Synchronously save the dataset to disk (wait to complete)

None.

BOOL: TRUE in case of success, FALSE in case of failure. If a save is already running, this command will fail and return FALSE.

$redis->save();

Description: Changes the slave status

Either host (string) and port (int), or no parameter to stop being a slave.

BOOL: TRUE in case of success, FALSE in case of failure.

$redis->slaveOf('10.0.1.7', 6379);
/* ... */
$redis->slaveOf();

Description: Return the current server time.

(none)

If successful, the time will come back as an associative array with element zero being the unix timestamp, and element one being microseconds.

$redis->time();

Description: Access the Redis slowLog

Operation (string): This can be either GET, LEN, or RESET
Length (integer), optional: If executing a SLOWLOG GET command, you can pass an optional length.

The return value of SLOWLOG will depend on which operation was performed. SLOWLOG GET: Array of slowLog entries, as provided by Redis SLOGLOG LEN: Integer, the length of the slowLog SLOWLOG RESET: Boolean, depending on success

// Get ten slowLog entries
$redis->slowLog('get', 10);
// Get the default number of slowLog entries

$redis->slowLog('get');
// Reset our slowLog
$redis->slowLog('reset');

// Retrieve slowLog length
$redis->slowLog('len');

• append - Append a value to a key
• bitCount - Count set bits in a string
• bitOp - Perform bitwise operations between strings
• decr, decrBy - Decrement the value of a key
• get - Get the value of a key
• getEx - Get the value of a key and set its expiration
• getBit - Returns the bit value at offset in the string value stored at key
• getRange - Get a substring of the string stored at a key
• getSet - Set the string value of a key and return its old value
• incr, incrBy - Increment the value of a key
• incrByFloat - Increment the float value of a key by the given amount
• mGet - Get the values of all the given keys
• mSet, mSetNX - Set multiple keys to multiple values
• set - Set the string value of a key
• setBit - Sets or clears the bit at offset in the string value stored at key
• setEx, pSetEx - Set the value and expiration of a key
• setNx - Set the value of a key, only if the key does not exist
• setRange - Overwrite part of a string at key starting at the specified offset
• strLen - Get the length of the value stored in a key

• del, delete, unlink - Delete a key
• dump - Return a serialized version of the value stored at the specified key.
• exists - Determine if a key exists
• expire, pexpire - Set a key's time to live in seconds
• expireAt, pexpireAt - Set the expiration for a key as a UNIX timestamp
• keys - Find all keys matching the given pattern
• scan - Scan for keys in the keyspace (Redis >= 2.8.0)
• migrate - Atomically transfer a key from a Redis instance to another one
• move - Move a key to another database
• object - Inspect the internals of Redis objects
• persist - Remove the expiration from a key
• randomKey - Return a random key from the keyspace
• rename - Rename a key
• renameNx - Rename a key, only if the new key does not exist
• type - Determine the type stored at key
• sort - Sort the elements in a list, set or sorted set
• ttl, pttl - Get the time to live for a key
• restore - Create a key using the provided serialized value, previously obtained with dump.

Description: Get the value related to the specified key

key

String or Bool: If key didn't exist, FALSE is returned. Otherwise, the value related to this key is returned.

$redis->get('key');

Description: Get the value related to the specified key and set its expiration

key options array (optional) with the following keys:

• EX - expire time in seconds
• PX - expire time in milliseconds
• EXAT - expire time in seconds since UNIX epoch
• PXAT - expire time in milliseconds since UNIX epoch
• PERSIST - remove the expiration from the key

String or Bool: If key didn't exist, FALSE is returned. Otherwise, the value related to this key is returned.

$redis->getEx('key', ['EX' => 10]); // get key and set its expiration to 10 seconds

Description: Set the string value in argument as value of the key. If you're using Redis >= 2.6.12, you can pass extended options as explained below

Key
Value
Timeout or Options Array (optional). If you pass an integer, phpredis will redirect to SETEX, and will try to use Redis >= 2.6.12 extended options if you pass an array with valid values

Bool TRUE if the command is successful.

// Simple key -> value set
$redis->set('key', 'value');

// Will redirect, and actually make an SETEX call
$redis->set('key','value', 10);

// Will set the key, if it doesn't exist, with a ttl of 10 seconds
$redis->set('key', 'value', ['nx', 'ex'=>10]);

// Will set a key, if it does exist, with a ttl of 1000 milliseconds
$redis->set('key', 'value', ['xx', 'px'=>1000]);

Description: Set the string value in argument as value of the key, with a time to live. PSETEX uses a TTL in milliseconds.

Key TTL Value

Bool TRUE if the command is successful.

$redis->setEx('key', 3600, 'value'); // sets key → value, with 1h TTL.
$redis->pSetEx('key', 100, 'value'); // sets key → value, with 0.1 sec TTL.

Description: Set the string value in argument as value of the key if the key doesn't already exist in the database.

key value

Bool TRUE in case of success, FALSE in case of failure.

$redis->setNx('key', 'value'); /* return TRUE */
$redis->setNx('key', 'value'); /* return FALSE */

Description: Remove specified keys.

An array of keys, or an undefined number of parameters, each a key: key1 key2 key3 ... keyN

Note: If you are connecting to Redis server >= 4.0.0 you can remove a key with the unlink method in the exact same way you would use del. The Redis unlink command is non-blocking and will perform the actual deletion asynchronously.

Long Number of keys deleted.

$redis->set('key1', 'val1');
$redis->set('key2', 'val2');
$redis->set('key3', 'val3');
$redis->set('key4', 'val4');

$redis->del('key1', 'key2'); /* return 2 */
$redis->del(['key3', 'key4']); /* return 2 */

/* If using Redis >= 4.0.0 you can call unlink */
$redis->unlink('key1', 'key2');
$redis->unlink(['key1', 'key2']);

Note: delete is an alias for del and will be removed in future versions of phpredis.

Description: Verify if the specified key exists.

key

long: The number of keys tested that do exist.

$redis->set('key', 'value');
$redis->exists('key'); /* 1 */
$redis->exists('NonExistingKey'); /* 0 */

$redis->mset(['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz']);
$redis->exists(['foo', 'bar', 'baz']); /* 3 */
$redis->exists('foo', 'bar', 'baz'); /* 3 */

Note: This function took a single argument and returned TRUE or FALSE in phpredis versions < 4.0.0.

Description: Increment the number stored at key by one. If the second argument is filled, it will be used as the integer value of the increment.

key
value: value that will be added to key (only for incrBy)

INT the new value

$redis->incr('key1'); /* key1 didn't exists, set to 0 before the increment */
					  /* and now has the value 1  */

$redis->incr('key1'); /* 2 */
$redis->incr('key1'); /* 3 */
$redis->incr('key1'); /* 4 */

// Will redirect, and actually make an INCRBY call
$redis->incr('key1', 10);   /* 14 */

$redis->incrBy('key1', 10); /* 24 */

Description: Increment the key with floating point precision.

key
value: (float) value that will be added to the key

FLOAT the new value

$redis->incrByFloat('key1', 1.5); /* key1 didn't exist, so it will now be 1.5 */


$redis->incrByFloat('key1', 1.5); /* 3 */
$redis->incrByFloat('key1', -1.5); /* 1.5 */
$redis->incrByFloat('key1', 2.5); /* 4 */

Description: Decrement the number stored at key by one. If the second argument is filled, it will be used as the integer value of the decrement.

key
value: value that will be subtracted to key (only for decrBy)

INT the new value

$redis->decr('key1'); /* key1 didn't exists, set to 0 before the increment */
					  /* and now has the value -1  */

$redis->decr('key1'); /* -2 */
$redis->decr('key1'); /* -3 */

// Will redirect, and actually make an DECRBY call
$redis->decr('key1', 10);   /* -13 */

$redis->decrBy('key1', 10); /* -23 */

Description: Get the values of all the specified keys. If one or more keys don't exist, the array will contain FALSE at the position of the key.

Array: Array containing the list of the keys

Array: Array containing the values related to keys in argument

$redis->set('key1', 'value1');
$redis->set('key2', 'value2');
$redis->set('key3', 'value3');
$redis->mGet(['key1', 'key2', 'key3']); /* ['value1', 'value2', 'value3'];
$redis->mGet(['key0', 'key1', 'key5']); /* [`FALSE`, 'value1', `FALSE`];

Description: Sets a value and returns the previous entry at that key.

Key: key

STRING: value

A string, the previous value located at this key.

$redis->set('x', '42');
$exValue = $redis->getSet('x', 'lol');	// return '42', replaces x by 'lol'
$newValue = $redis->get('x')'		// return 'lol'

Description: Returns a random key.

None.

STRING: an existing key in redis.

$key = $redis->randomKey();
$surprise = $redis->get($key);	// who knows what's in there.

Description: Moves a key to a different database.

Key: key, the key to move.

INTEGER: dbindex, the database number to move the key to.

BOOL: TRUE in case of success, FALSE in case of failure.

$redis->select(0);	// switch to DB 0
$redis->set('x', '42');	// write 42 to x
$redis->move('x', 1);	// move to DB 1
$redis->select(1);	// switch to DB 1
$redis->get('x');	// will return 42

Description: Renames a key.

STRING: srckey, the key to rename.

STRING: dstkey, the new name for the key.

BOOL: TRUE in case of success, FALSE in case of failure.

$redis->set('x', '42');
$redis->rename('x', 'y');
$redis->get('y'); 	// → 42
$redis->get('x'); 	// → `FALSE`

Description: Same as rename, but will not replace a key if the destination already exists. This is the same behaviour as setNx.

Description: Sets an expiration on a key in either seconds or milliseconds.

public function expire(string $key, int $seconds, ?string $mode = NULL): Redis|bool;
public function pexpire(string $key, int $milliseconds, ?string $mode = NULL): Redis|bool;

BOOL: TRUE if an expiration was set, and FALSE on failure or if one was not set. You can distinguish between an error and an expiration not being set by checking getLastError().

$redis->set('x', '42');
$redis->expire('x', 3);	// x will disappear in 3 seconds.
sleep(5);				// wait 5 seconds
$redis->get('x'); 		// will return `FALSE`, as 'x' has expired.

Description: Seta specific timestamp for a key to expire in seconds or milliseconds.

public function expireat(string $key, int $unix_timestamp, ?string $mode = NULL): Redis|bool;
public function pexpireat(string $key, int $unix_timestamp_millis, ?string $mode = NULL): Redis|bool;

BOOL: TRUE if an expiration was set and FALSE if one was not set or in the event on an error. You can detect an actual error by checking getLastError().

$redis->set('x', '42');
$redis->expireAt('x', time(NULL) + 3); // x will disappear in 3 seconds.
sleep(5);				// wait 5 seconds
$redis->get('x'); 	// will return `FALSE`, as 'x' has expired.

Description: Returns the keys that match a certain pattern.

STRING: pattern, using '*' as a wildcard.

Array of STRING: The keys that match a certain pattern.

$allKeys = $redis->keys('*');	// all keys will match this.
$keyWithUserPrefix = $redis->keys('user*');

Description: Scan the keyspace for keys

LONG (reference): Iterator, initialized to NULL STRING, Optional: Pattern to match LONG, Optional: Count of keys per iteration (only a suggestion to Redis)

Array, boolean: This function will return an array of keys or FALSE if Redis returned zero keys

Note: SCAN is a "directed node" command in RedisCluster

/* Without enabling Redis::SCAN_RETRY (default condition) */
$it = NULL;
do {
    // Scan for some keys
    $arr_keys = $redis->scan($it);

    // Redis may return empty results, so protect against that
    if ($arr_keys !== FALSE) {
        foreach($arr_keys as $str_key) {
            echo "Here is a key: $str_key\n";
        }
    }
} while ($it > 0);
echo "No more keys to scan!\n";

/* With Redis::SCAN_RETRY enabled */
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
$it = NULL;

/* phpredis will retry the SCAN command if empty results are returned from the
   server, so no empty results check is required. */
while ($arr_keys = $redis->scan($it)) {
    foreach ($arr_keys as $str_key) {
        echo "Here is a key: $str_key\n";
    }
}
echo "No more keys to scan!\n";

Description: Describes the object pointed to by a key.

The information to retrieve (string) and the key (string). Info can be one of the following:

• "encoding"
• "refcount"
• "idletime"

STRING for "encoding", LONG for "refcount" and "idletime", FALSE if the key doesn't exist.

$redis->object("encoding", "l"); // → ziplist
$redis->object("refcount", "l"); // → 1
$redis->object("idletime", "l"); // → 400 (in seconds, with a precision of 10 seconds).

Description: Returns the type of data pointed by a given key.

Key: key

Depending on the type of the data pointed by the key, this method will return the following value:
string: Redis::REDIS_STRING
set: Redis::REDIS_SET
list: Redis::REDIS_LIST
zset: Redis::REDIS_ZSET
hash: Redis::REDIS_HASH
other: Redis::REDIS_NOT_FOUND

$redis->type('key');

Description: Append specified string to the string stored in specified key.

Key Value

INTEGER: Size of the value after the append

$redis->set('key', 'value1');
$redis->append('key', 'value2'); /* 12 */
$redis->get('key'); /* 'value1value2' */

Description: Return a substring of a larger string

key
start
end

STRING: the substring

$redis->set('key', 'string value');
$redis->getRange('key', 0, 5); /* 'string' */
$redis->getRange('key', -5, -1); /* 'value' */

Description: Changes a substring of a larger string.

key offset value

STRING: the length of the string after it was modified.

$redis->set('key', 'Hello world');
$redis->setRange('key', 6, "redis"); /* returns 11 */
$redis->get('key'); /* "Hello redis" */

Description: Get the length of a string value.

key

INTEGER

$redis->set('key', 'value');
$redis->strlen('key'); /* 5 */

Description: Return a single bit out of a larger string

key
offset

LONG: the bit value (0 or 1)

$redis->set('key', "\x7f"); // this is 0111 1111
$redis->getBit('key', 0); /* 0 */
$redis->getBit('key', 1); /* 1 */

Description: Changes a single bit of a string.

key
offset
value: bool or int (1 or 0)

LONG: 0 or 1, the value of the bit before it was set.

$redis->set('key', "*");	// ord("*") = 42 = 0x2f = "0010 1010"
$redis->setBit('key', 5, 1); /* returns 0 */
$redis->setBit('key', 7, 1); /* returns 0 */
$redis->get('key'); /* chr(0x2f) = "/" = b("0010 1111") */

Description: Bitwise operation on multiple keys.

operation: either "AND", "OR", "NOT", "XOR"
ret_key: return key
key1
key2...

LONG: The size of the string stored in the destination key.

Description: Count bits in a string.

key

LONG: The number of bits set to 1 in the value behind the input key.

Description: Sort the elements in a list, set or sorted set.

Key: key Options: [key => value, ...] - optional, with the following keys and values:

    'by' => 'some_pattern_*',
    'limit' => [0, 1],
    'get' => 'some_other_pattern_*' or an array of patterns,
    'sort' => 'asc' or 'desc',
    'alpha' => TRUE,
    'store' => 'external-key'

An array of values, or a number corresponding to the number of elements stored if that was used.

$redis->del('s');
$redis->sAdd('s', 5);
$redis->sAdd('s', 4);
$redis->sAdd('s', 2);
$redis->sAdd('s', 1);
$redis->sAdd('s', 3);

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

Description: Returns the time to live left for a given key in seconds (ttl), or milliseconds (pttl).

Key: key

LONG: The time to live in seconds. If the key has no ttl, -1 will be returned, and -2 if the key doesn't exist.

$redis->ttl('key');

Description: Remove the expiration timer from a key.

Key: key

BOOL: TRUE if a timeout was removed, FALSE if the key didn’t exist or didn’t have an expiration timer.

$redis->persist('key');

Description: Sets multiple key-value pairs in one atomic command. MSETNX only returns TRUE if all the keys were set (see SETNX).

Pairs: [key => value, ...]

Bool TRUE in case of success, FALSE in case of failure.

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

Output:

string(6) "value0"
string(6) "value1"

Description: Dump a key out of a redis database, the value of which can later be passed into redis using the RESTORE command. The data that comes out of DUMP is a binary representation of the key as Redis stores it.

key string

The Redis encoded value of the key, or FALSE if the key doesn't exist

$redis->set('foo', 'bar');
$val = $redis->dump('foo'); // $val will be the Redis encoded key value

Description: Restore a key from the result of a DUMP operation.

key string. The key name
ttl integer. How long the key should live (if zero, no expire will be set on the key)
value string (binary). The Redis encoded key value (from DUMP)

$redis->set('foo', 'bar');
$val = $redis->dump('foo');
$redis->restore('bar', 0, $val); // The key 'bar', will now be equal to the key 'foo'

Description: Migrates a key to a different Redis instance.

Note:: Redis introduced migrating multiple keys in 3.0.6, so you must have at least that version in order to call migrate with an array of keys.

host string. The destination host
port integer. The TCP port to connect to.
key(s) string or array.
destination-db integer. The target DB.
timeout integer. The maximum amount of time given to this transfer.
copy boolean, optional. Should we send the COPY flag to redis.
replace boolean, optional. Should we send the REPLACE flag to redis

$redis->migrate('backup', 6379, 'foo', 0, 3600);
$redis->migrate('backup', 6379, 'foo', 0, 3600, true, true); /* copy and replace */
$redis->migrate('backup', 6379, 'foo', 0, 3600, false, true); /* just REPLACE flag */

/* Migrate multiple keys (requires Redis >= 3.0.6)
$redis->migrate('backup', 6379, ['key1', 'key2', 'key3'], 0, 3600);

• hDel - Delete one or more hash fields
• hExists - Determine if a hash field exists
• hGet - Get the value of a hash field
• hGetAll - Get all the fields and values in a hash
• hIncrBy - Increment the integer value of a hash field by the given number
• hIncrByFloat - Increment the float value of a hash field by the given amount
• hKeys - Get all the fields in a hash
• hLen - Get the number of fields in a hash
• hMGet - Get the values of all the given hash fields
• hMSet - Set multiple hash fields to multiple values
• hSet - Set the string value of a hash field
• hSetNx - Set the value of a hash field, only if the field does not exist
• hVals - Get all the values in a hash
• hScan - Scan a hash key for members
• hStrLen - Get the string length of the value associated with field in the hash

Description: Adds a value to the hash stored at key.

key
hashKey
value

LONG 1 if value didn't exist and was added successfully, 0 if the value was already present and was replaced, FALSE if there was an error.

$redis->del('h')
$redis->hSet('h', 'key1', 'hello'); /* 1, 'key1' => 'hello' in the hash at "h" */
$redis->hGet('h', 'key1'); /* returns "hello" */

$redis->hSet('h', 'key1', 'plop'); /* 0, value was replaced. */
$redis->hGet('h', 'key1'); /* returns "plop" */

Description: Adds a value to the hash stored at key only if this field isn't already in the hash.

BOOL TRUE if the field was set, FALSE if it was already present.

$redis->del('h')
$redis->hSetNx('h', 'key1', 'hello'); /* TRUE, 'key1' => 'hello' in the hash at "h" */
$redis->hSetNx('h', 'key1', 'world'); /* FALSE, 'key1' => 'hello' in the hash at "h". No change since the field wasn't replaced. */

Description: Gets a value from the hash stored at key. If the hash table doesn't exist, or the key doesn't exist, FALSE is returned.

key
hashKey

STRING The value, if the command executed successfully
BOOL FALSE in case of failure

Description: Returns the length of a hash, in number of items

key

LONG the number of items in a hash, FALSE if the key doesn't exist or isn't a hash.

$redis->del('h')
$redis->hSet('h', 'key1', 'hello');
$redis->hSet('h', 'key2', 'plop');
$redis->hLen('h'); /* returns 2 */

Description: Removes a value from the hash stored at key. If the hash table doesn't exist, or the key doesn't exist, FALSE is returned.

key
hashKey1
hashKey2
...

LONG the number of deleted keys, 0 if the key doesn't exist, FALSE if the key isn't a hash.

Description: Returns the keys in a hash, as an array of strings.

Key: key

An array of elements, the keys of the hash. This works like PHP's array_keys().

$redis->del('h');
$redis->hSet('h', 'a', 'x');
$redis->hSet('h', 'b', 'y');
$redis->hSet('h', 'c', 'z');
$redis->hSet('h', 'd', 't');
var_dump($redis->hKeys('h'));

Output:

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [2]=>
  string(1) "c"
  [3]=>
  string(1) "d"
}

The order is random and corresponds to redis' own internal representation of the set structure.

Description: Returns the values in a hash, as an array of strings.

Key: key

An array of elements, the values of the hash. This works like PHP's array_values().

$redis->del('h');
$redis->hSet('h', 'a', 'x');
$redis->hSet('h', 'b', 'y');
$redis->hSet('h', 'c', 'z');
$redis->hSet('h', 'd', 't');
var_dump($redis->hVals('h'));

Output:

array(4) {
  [0]=>
  string(1) "x"
  [1]=>
  string(1) "y"
  [2]=>
  string(1) "z"
  [3]=>
  string(1) "t"
}

The order is random and corresponds to redis' own internal representation of the set structure.

Description: Returns the whole hash, as an array of strings indexed by strings.

Key: key

An array of elements, the contents of the hash.

$redis->del('h');
$redis->hSet('h', 'a', 'x');
$redis->hSet('h', 'b', 'y');
$redis->hSet('h', 'c', 'z');
$redis->hSet('h', 'd', 't');
var_dump($redis->hGetAll('h'));

Output:

array(4) {
  ["a"]=>
  string(1) "x"
  ["b"]=>
  string(1) "y"
  ["c"]=>
  string(1) "z"
  ["d"]=>
  string(1) "t"
}

The order is random and corresponds to redis' own internal representation of the set structure.

Description: Verify if the specified member exists in a key.

key
memberKey

BOOL: If the member exists in the hash table, return TRUE, otherwise return FALSE.

$redis->hSet('h', 'a', 'x');
$redis->hExists('h', 'a'); /*  TRUE */
$redis->hExists('h', 'NonExistingKey'); /* FALSE */

Description: Increments the value of a member from a hash by a given amount.

key
member
value: (integer) value that will be added to the member's value

LONG the new value

$redis->del('h');
$redis->hIncrBy('h', 'x', 2); /* returns 2: h[x] = 2 now. */
$redis->hIncrBy('h', 'x', 1); /* h[x] ← 2 + 1. Returns 3 */

Description: Increments the value of a hash member by the provided float value

key
member
value: (float) value that will be added to the member's value

FLOAT the new value

$redis->del('h');
$redis->hIncrByFloat('h','x', 1.5); /* returns 1.5: h[x] = 1.5 now */
$redis->hIncrByFloat('h', 'x', 1.5); /* returns 3.0: h[x] = 3.0 now */
$redis->hIncrByFloat('h', 'x', -3.0); /* returns 0.0: h[x] = 0.0 now */

Description: Fills in a whole hash. Non-string values are converted to string, using the standard (string) cast. NULL values are stored as empty strings.

key
members: key → value array

BOOL

$redis->del('user:1');
$redis->hMSet('user:1', ['name' => 'Joe', 'salary' => 2000]);
$redis->hIncrBy('user:1', 'salary', 100); // Joe earns 100 more now.

Description: Retrieve the values associated to the specified fields in the hash.

key
memberKeys Array

Array An array of elements, the values of the specified fields in the hash, with the hash keys as array keys.

$redis->del('h');
$redis->hSet('h', 'field1', 'value1');
$redis->hSet('h', 'field2', 'value2');
$redis->hMGet('h', ['field1', 'field2']); /* returns ['field1' => 'value1', 'field2' => 'value2'] */

Description: Scan a HASH value for members, with an optional pattern and count

key: String
iterator: Long (reference)
pattern: Optional pattern to match against
count: How many keys to return in a go (only a suggestion to Redis)

Array An array of members that match our pattern

$it = NULL;
/* Don't ever return an empty array until we're done iterating */
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
while($arr_keys = $redis->hScan('hash', $it)) {
    foreach($arr_keys as $str_field => $str_value) {
        echo "$str_field => $str_value\n"; /* Print the hash member and value */
    }
}

Description: Get the string length of the value associated with field in the hash stored at key.

key: String
field: String

LONG the string length of the value associated with field, or zero when field is not present in the hash or key does not exist at all.

• blPop, brPop - Remove and get the first/last element in a list
• bRPopLPush - Pop a value from a list, push it to another list and return it
• lIndex - Get an element from a list by its index
• lInsert - Insert an element before or after another element in a list
• lLen - Get the length/size of a list
• lPop - Remove and get the first element in a list
• lPush - Prepend one or multiple values to a list
• lPushx - Prepend a value to a list, only if the list exists
• lRange - Get a range of elements from a list
• lRem - Remove elements from a list
• lSet - Set the value of an element in a list by its index
• lTrim - Trim a list to the specified range
• rPop - Remove and get the last element in a list
• rPopLPush - Remove the last element in a list, append it to another list and return it (redis >= 1.1)
• rPush - Append one or multiple values to a list
• rPushX - Append a value to a list, only if the list exists

Description: Is a blocking lPop(rPop) primitive. If at least one of the lists contains at least one element, the element will be popped from the head of the list and returned to the caller. If all the list identified by the keys passed in arguments are empty, blPop will block during the specified timeout until an element is pushed to one of those lists. This element will be popped.

ARRAY Array containing the keys of the lists
INTEGER Timeout
Or
STRING Key1
STRING Key2
STRING Key3
...
STRING Keyn
INTEGER Timeout

ARRAY ['listName', 'element']

/* Non blocking feature */
$redis->lPush('key1', 'A');
$redis->del('key2');

$redis->blPop('key1', 'key2', 10); /* ['key1', 'A'] */
/* OR */
$redis->blPop(['key1', 'key2'], 10); /* ['key1', 'A'] */

$redis->brPop('key1', 'key2', 10); /* ['key1', 'A'] */
/* OR */
$redis->brPop(['key1', 'key2'], 10); /* ['key1', 'A'] */

/* Blocking feature */

/* process 1 */
$redis->del('key1');
$redis->blPop('key1', 10);
/* blocking for 10 seconds */

/* process 2 */
$redis->lPush('key1', 'A');

/* process 1 */
/* ['key1', 'A'] is returned*/

Description: A blocking version of rPopLPush, with an integral timeout in the third parameter.

Key: srckey
Key: dstkey
Long: timeout

STRING The element that was moved in case of success, FALSE in case of timeout.

Description: Return the specified element of the list stored at the specified key.

0 the first element, 1 the second ...
-1 the last element, -2 the penultimate ...

Return FALSE in case of a bad index or a key that doesn't point to a list.

key
index

String the element at this index
Bool FALSE if the key identifies a non-string data type, or no value corresponds to this index in the list Key.

$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); /* key1 => [ 'A', 'B', 'C' ] */
$redis->lindex('key1', 0); /* 'A' */
$redis->lindex('key1', -1); /* 'C' */
$redis->lindex('key1', 10); /* `FALSE` */

Description: Insert value in the list before or after the pivot value.

The parameter options specify the position of the insert (before or after). If the list didn't exists, or the pivot didn't exists, the value is not inserted.

key
position Redis::BEFORE | Redis::AFTER
pivot
value

The number of the elements in the list, -1 if the pivot didn't exists.

$redis->del('key1');
$redis->lInsert('key1', Redis::AFTER, 'A', 'X'); /* 0 */

$redis->lPush('key1', 'A');
$redis->lPush('key1', 'B');
$redis->lPush('key1', 'C');

$redis->lInsert('key1', Redis::BEFORE, 'C', 'X'); /* 4 */
$redis->lRange('key1', 0, -1); /* ['A', 'B', 'X', 'C'] */

$redis->lInsert('key1', Redis::AFTER, 'C', 'Y'); /* 5 */
$redis->lRange('key1', 0, -1); /* ['A', 'B', 'X', 'C', 'Y'] */

$redis->lInsert('key1', Redis::AFTER, 'W', 'value'); /* -1 */

Description: Return and remove the first element of the list.

key

STRING if command executed successfully
BOOL FALSE in case of failure (empty list)

$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); /* key1 => [ 'A', 'B', 'C' ] */
$redis->lPop('key1'); /* key1 => [ 'B', 'C' ] */

Description: Adds one or more values to the head of a LIST. Creates the list if the key didn't exist. If the key exists and is not a list, FALSE is returned.

$redis->lPush($key, $entry [, $entry, $entry]);

LONG The new length of the list in case of success, FALSE in case of Failure.

$redis->del('key1');
$redis->lPush('key1', 'F'); // returns 1
$redis->lPush('key1', 'E'); // returns 2
$redis->lPush('key1', 'D'); // returns 3
/* key1 now contains: [ 'D', 'E', 'F' ] */

$redis->lPush('key1', 'C', 'B', 'A'); // Returns 6
/* key1 now contains: [ 'A', 'B', 'C', 'D', 'E', 'F' ]

Description: Adds the string value to the head (left) of the list if the list exists.

key
value String, value to push in key

LONG The new length of the list in case of success, FALSE in case of Failure.

$redis->del('key1');
$redis->lPushx('key1', 'A'); // returns 0
$redis->lPush('key1', 'A'); // returns 1
$redis->lPushx('key1', 'B'); // returns 2
$redis->lPushx('key1', 'C'); // returns 3
/* key1 now points to the following list: [ 'A', 'B', 'C' ] */

Description: Returns the specified elements of the list stored at the specified key in the range [start, end]. start and stop are interpreted as indices:
0 the first element, 1 the second ...
-1 the last element, -2 the penultimate ...

key
start
end

Array containing the values in specified range.

$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C');
$redis->lRange('key1', 0, -1); /* ['A', 'B', 'C'] */

Description: Removes the first count occurrences of the value element from the list. If count is zero, all the matching elements are removed. If count is negative, elements are removed from tail to head.

Note: The argument order is not the same as in the Redis documentation. This difference is kept for compatibility reasons.

key
value
count

LONG the number of elements to remove
BOOL FALSE if the value identified by key is not a list.

$redis->lPush('key1', 'A');
$redis->lPush('key1', 'B');
$redis->lPush('key1', 'C');
$redis->lPush('key1', 'A');
$redis->lPush('key1', 'A');

$redis->lRange('key1', 0, -1); /* ['A', 'A', 'C', 'B', 'A'] */
$redis->lRem('key1', 'A', 2); /* 2 */
$redis->lRange('key1', 0, -1); /* ['C', 'B', 'A'] */

Description: Set the list at index with the new value.

key
index
value

BOOL TRUE if the new value was set. FALSE if the index is out of range, or data type identified by key is not a list.

$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); /* key1 => [ 'A', 'B', 'C' ] */
$redis->lindex('key1', 0); /* 'A' */
$redis->lSet('key1', 0, 'X');
$redis->lindex('key1', 0); /* 'X' */

Description: Trims an existing list so that it will contain only a specified range of elements.

key
start
stop

Array
Bool return FALSE if the key identify a non-list value.

$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C');
$redis->lRange('key1', 0, -1); /* ['A', 'B', 'C'] */
$redis->lTrim('key1', 0, 1);
$redis->lRange('key1', 0, -1); /* ['A', 'B'] */

Description: Returns and removes the last element of the list.

key

STRING if command executed successfully
BOOL FALSE in case of failure (empty list)

$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); /* key1 => [ 'A', 'B', 'C' ] */
$redis->rPop('key1'); /* key1 => [ 'A', 'B' ] */

Description: Pops a value from the tail of a list, and pushes it to the front of another list. Also return this value. (redis >= 1.1)

Key: srckey
Key: dstkey

STRING The element that was moved in case of success, FALSE in case of failure.

$redis->del('x', 'y');

$redis->lPush('x', 'abc');
$redis->lPush('x', 'def');
$redis->lPush('y', '123');
$redis->lPush('y', '456');

// move the last of x to the front of y.
var_dump($redis->rPopLPush('x', 'y'));
var_dump($redis->lRange('x', 0, -1));
var_dump($redis->lRange('y', 0, -1));

Output:

string(3) "abc"
array(1) {
  [0]=>
  string(3) "def"
}
array(3) {
  [0]=>
  string(3) "abc"
  [1]=>
  string(3) "456"
  [2]=>
  string(3) "123"
}

Description: Adds one or more entries to the tail of a LIST. Redis will create the list if it doesn't exist.

$redis->rPush($key, $entry [, $entry, $entry]);

LONG The new length of the list in case of success, FALSE in case of Failure.

$redis->del('key1');
$redis->rPush('key1', 'A');           // returns 1
$redis->rPush('key1', 'B');           // returns 2
$redis->rPush('key1', 'C');           // returns 3
$redis->rPush('key1', 'D', 'E', 'F'); // returns 6
/* key1 now contains: [ 'A', 'B', 'C', 'D', 'E', 'F' ] */

Description: Adds the string value to the tail (right) of the list if the list exists. FALSE in case of Failure.

key
value String, value to push in key

LONG The new length of the list in case of success, FALSE in case of Failure.

$redis->del('key1');
$redis->rPushX('key1', 'A'); // returns 0
$redis->rPush('key1', 'A'); // returns 1
$redis->rPushX('key1', 'B'); // returns 2
$redis->rPushX('key1', 'C'); // returns 3
/* key1 now points to the following list: [ 'A', 'B', 'C' ] */

Description: Returns the size of a list identified by Key.

If the list didn't exist or is empty, the command returns 0. If the data type identified by Key is not a list, the command return FALSE.

Key

LONG The size of the list identified by Key exists.
BOOL FALSE if the data type identified by Key is not list

$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); /* key1 => [ 'A', 'B', 'C' ] */
$redis->lLen('key1');/* 3 */
$redis->rPop('key1');
$redis->lLen('key1');/* 2 */

• sAdd - Add one or more members to a set
• sCard - Get the number of members in a set
• sDiff - Subtract multiple sets
• sDiffStore - Subtract multiple sets and store the resulting set in a key
• sInter - Intersect multiple sets
• sInterStore - Intersect multiple sets and store the resulting set in a key
• sIsMember - Determine if a given value is a member of a set
• sMembers - Get all the members in a set
• sMove - Move a member from one set to another
• sPop - Remove and return one or more members of a set at random
• sRandMember - Get one or multiple random members from a set
• sRem - Remove one or more members from a set
• sUnion - Add multiple sets
• sUnionStore - Add multiple sets and store the resulting set in a key
• sScan - Scan a set for members

Description: Adds a value to the set value stored at key.

key
value

LONG the number of elements added to the set.

$redis->sAdd('key1' , 'member1'); /* 1, 'key1' => {'member1'} */
$redis->sAdd('key1' , 'member2', 'member3'); /* 2, 'key1' => {'member1', 'member2', 'member3'}*/
$redis->sAdd('key1' , 'member2'); /* 0, 'key1' => {'member1', 'member2', 'member3'}*/

Description: Returns the cardinality of the set identified by key.

key

LONG the cardinality of the set identified by key, 0 if the set doesn't exist.

$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member1', 'member2', 'member3'}*/
$redis->sCard('key1'); /* 3 */
$redis->sCard('keyX'); /* 0 */

Description: Performs the difference between N sets and returns it.

Keys: key1, key2, ... , keyN: Any number of keys corresponding to sets in redis.

Array of strings: The difference of the first set will all the others.

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

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

Return value: all elements of s0 that are neither in s1 nor in s2.

array(2) {
  [0]=>
  string(1) "4"
  [1]=>
  string(1) "2"
}

Description: Performs the same action as sDiff, but stores the result in the first key

Key: dstkey, the key to store the diff into.

Keys: key1, key2, ... , keyN: Any number of keys corresponding to sets in redis

INTEGER: The cardinality of the resulting set, or FALSE in case of a missing key.

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

var_dump($redis->sDiffStore('dst', 's0', 's1', 's2'));
var_dump($redis->sMembers('dst'));

Return value: the number of elements of s0 that are neither in s1 nor in s2.

int(2)
array(2) {
  [0]=>
  string(1) "4"
  [1]=>
  string(1) "2"
}

Description: Returns the members of a set resulting from the intersection of all the sets held at the specified keys.

If just a single key is specified, then this command produces the members of this set. If one of the keys is missing, FALSE is returned.

key1, key2, keyN: keys identifying the different sets on which we will apply the intersection.

Array, contain the result of the intersection between those keys. If the intersection between the different sets is empty, the return value will be empty array.

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

var_dump($redis->sInter('key1', 'key2', 'key3'));

Output:

array(2) {
  [0]=>
  string(4) "val4"
  [1]=>
  string(4) "val3"
}

Description: Performs a sInter command and stores the result in a new set.

Key: dstkey, the key to store the diff into.

Keys: key1, key2... keyN. key1..keyN are intersected as in sInter.

INTEGER: The cardinality of the resulting set, or FALSE in case of a missing key.

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

var_dump($redis->sInterStore('output', 'key1', 'key2', 'key3'));
var_dump($redis->sMembers('output'));

Output:

int(2)

array(2) {
  [0]=>
  string(4) "val4"
  [1]=>
  string(4) "val3"
}

Description: Checks if value is a member of the set stored at the key key.

key
value

BOOL TRUE if value is a member of the set at key key, FALSE otherwise.

$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member1', 'member2', 'member3'}*/

$redis->sIsMember('key1', 'member1'); /* TRUE */
$redis->sIsMember('key1', 'memberX'); /* FALSE */

Description: Returns the contents of a set.

Key: key

An array of elements, the contents of the set.

$redis->del('s');
$redis->sAdd('s', 'a');
$redis->sAdd('s', 'b');
$redis->sAdd('s', 'a');
$redis->sAdd('s', 'c');
var_dump($redis->sMembers('s'));

Output:

array(3) {
  [0]=>
  string(1) "c"
  [1]=>
  string(1) "a"
  [2]=>
  string(1) "b"
}

The order is random and corresponds to redis' own internal representation of the set structure.

Description: Moves the specified member from the set at srcKey to the set at dstKey.

srcKey
dstKey
member

BOOL If the operation is successful, return TRUE. If the srcKey and/or dstKey didn't exist, and/or the member didn't exist in srcKey, FALSE is returned.

$redis->sAdd('key1' , 'member11');
$redis->sAdd('key1' , 'member12');
$redis->sAdd('key1' , 'member13'); /* 'key1' => {'member11', 'member12', 'member13'}*/
$redis->sAdd('key2' , 'member21');
$redis->sAdd('key2' , 'member22'); /* 'key2' => {'member21', 'member22'}*/
$redis->sMove('key1', 'key2', 'member13'); /* 'key1' =>  {'member11', 'member12'} */
					/* 'key2' =>  {'member21', 'member22', 'member13'} */

Description: Removes and returns a random element from the set value at Key.

key
count: Integer, optional

String "popped" value
Bool FALSE if set identified by key is empty or doesn't exist.

Array: Member(s) returned or an empty array if the set doesn't exist
Bool: FALSE on error if the key is not a set

$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member3', 'member1', 'member2'}*/
$redis->sPop('key1'); /* 'member1', 'key1' => {'member3', 'member2'} */
$redis->sPop('key1'); /* 'member3', 'key1' => {'member2'} */

/* With count */
$redis->sAdd('key2', 'member1', 'member2', 'member3');
$redis->sPop('key2', 3); /* Will return all members but in no particular order */

Description: Returns a random element from the set value at Key, without removing it.

key
count (Integer, optional)

If no count is provided, a random String value from the set will be returned. If a count is provided, an array of values from the set will be returned. Read about the different ways to use the count here: SRANDMEMBER Bool FALSE if set identified by key is empty or doesn't exist.

$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member3', 'member1', 'member2'}*/

// No count
$redis->sRandMember('key1'); /* 'member1', 'key1' => {'member3', 'member1', 'member2'} */
$redis->sRandMember('key1'); /* 'member3', 'key1' => {'member3', 'member1', 'member2'} */

// With a count
$redis->sRandMember('key1', 3); // Will return an array with all members from the set
$redis->sRandMember('key1', 2); // Will an array with 2 members of the set
$redis->sRandMember('key1', -100); // Will return an array of 100 elements, picked from our set (with dups)
$redis->sRandMember('empty-set', 100); // Will return an empty array
$redis->sRandMember('not-a-set', 100); // Will return FALSE

Description: Removes the specified member from the set value stored at key.

key
member

LONG The number of elements removed from the set.

$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member1', 'member2', 'member3'}*/
$redis->sRem('key1', 'member2', 'member3'); /*return 2. 'key1' => {'member1'} */

Description: Performs the union between N sets and returns it.

Keys: key1, key2, ... , keyN: Any number of keys corresponding to sets in redis.

Array of strings: The union of all these sets.

Note: sUnion can also take a single array with keys (see example below).

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

/* Get the union with variadic arguments */
var_dump($redis->sUnion('s0', 's1', 's2'));

/* Pass a single array */
var_dump($redis->sUnion(['s0', 's1', 's2']));

Return value: all elements that are either in s0 or in s1 or in s2.

array(4) {
  [0]=>
  string(1) "3"
  [1]=>
  string(1) "4"
  [2]=>
  string(1) "1"
  [3]=>
  string(1) "2"
}

Description: Performs the same action as sUnion, but stores the result in the first key

Key: dstkey, the key to store the diff into.

Keys: key1, key2, ... , keyN: Any number of keys corresponding to sets in redis.

INTEGER: The cardinality of the resulting set, or FALSE in case of a missing key.

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

var_dump($redis->sUnionStore('dst', 's0', 's1', 's2'));
var_dump($redis->sMembers('dst'));

Return value: the number of elements that are either in s0 or in s1 or in s2.

int(4)
array(4) {
  [0]=>
  string(1) "3"
  [1]=>
  string(1) "4"
  [2]=>
  string(1) "1"
  [3]=>
  string(1) "2"
}

Description: Scan a set for members

Key: The set to search
iterator: LONG (reference) to the iterator as we go
pattern: String, optional pattern to match against
count: How many members to return at a time (Redis might return a different amount)

Array, boolean: PHPRedis will return an array of keys or FALSE when we're done iterating

$it = NULL;
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY); /* don't return empty results until we're done */
while($arr_mems = $redis->sScan('set', $it, "*pattern*")) {
    foreach($arr_mems as $str_mem) {
        echo "Member: $str_mem\n";
    }
}

$it = NULL;
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY); /* return after each iteration, even if empty */
while(($arr_mems = $redis->sScan('set', $it, "*pattern*"))!==FALSE) {
    if(count($arr_mems) > 0) {
        foreach($arr_mems as $str_mem) {
            echo "Member found: $str_mem\n";
        }
    } else {
        echo "No members in this iteration, iterator value: $it\n";
    }
}

• bzPop - Block until Redis can pop the highest or lowest scoring member from one or more ZSETs.
• zAdd - Add one or more members to a sorted set or update its score if it already exists
• zCard - Get the number of members in a sorted set
• zCount - Count the members in a sorted set with scores within the given values
• zDiff - Computes the difference between the first and all successive input sorted sets and return the resulting sorted set
• zdiffstore - Computes the difference between the first and all successive input sorted sets and stores the result in a new key
• zIncrBy - Increment the score of a member in a sorted set
• zInter - Intersect multiple sorted sets and return the resulting sorted set
• zinterstore - Intersect multiple sorted sets and store the resulting sorted set in a new key
• zMscore - Get the scores associated with the given members in a sorted set
• zPop - Redis can pop the highest or lowest scoring member from one a ZSET.
• zRange - Return a range of members in a sorted set, by index
• zRangeByScore, zRevRangeByScore - Return a range of members in a sorted set, by score
• zRangeByLex - Return a lexicographical range from members that share the same score
• zRank, zRevRank - Determine the index of a member in a sorted set
• zRem - Remove one or more members from a sorted set
• zRemRangeByRank - Remove all members in a sorted set within the given indexes
• zRemRangeByScore - Remove all members in a sorted set within the given scores
• zRevRange - Return a range of members in a sorted set, by index, with scores ordered from high to low
• zScore - Get the score associated with the given member in a sorted set
• zUnion - Add multiple sorted sets and return the resulting sorted set
• zunionstore - Add multiple sorted sets and store the resulting sorted set in a new key
• zScan - Scan a sorted set for members