workerman-redis

परिचय

workeman/redis कार्यकर्ता आधारित एसी रीडिस कंपोनेंट है।

नोट
इस प्रोजेक्ट का मुख्य उद्देश्य रीडिस असिंक्रोनस सब्सक्रिप्शन (subscribe, pSubscribe) को लागू करना है।
चूंकि रीडिस पर्याप्त तेज है, इसलिए जब तक आपको pSubscribe या subscribe असिंक्रोनस सब्सक्रिप्शन की आवश्यकता न हो, तब तक इस असिंक्रोनस क्लाइंट का उपयोग करने की आवश्यकता नहीं है, रीडिस एक्सटेंशन का उपयोग करने से बेहतर प्रदर्शन मिलेगा।

स्थापना:

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 रीडिस उदाहरण है। उदाहरण के लिए:

use Workerman\Redis\Client;
$redis = new Client('redis://127.0.0.1:6379');
// सेट करें कॉलबैक फ़ंक्शन सेट करें, सेट कॉल करने के परिणाम की जांच करें
$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 कॉलबैक फ़ंक्शन में 4 पैरामीटर होते हैं ($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 कॉलबैक फ़ंक्शन में 3 पैरामीटर होते हैं ($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

निर्धारित कुंजी का मूल्य सेट करने का उपयोग करें। यदि कुंजी पहले से ही अन्य मान संग्रहीत है, तो सेट पुरानी कीमत को अधिलेखित करेगा, और प्रकार की परवाह नहीं करेगा।

$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

कुंजी में संग्रहीत संख्यात्मक मूल्य को एक/निर्धारित मूल्य द्वारा बढ़ा दें। यदि कुंजी मौजूद नहीं है, तो कुंजी का मूल्य पहले 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

कमांड कुंजी में संग्रहीत मान को एक/निर्धारित कमी के प्रकार में घटावें।
यदि कुंजी मौजूद नहीं है, तो कुंजी का मूल्य पहले 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);  // DB 0 में स्विच करें
$redis->set('x', '42'); // x में 42 लिखें
$redis->move('x', 1, function ($result) {   // DB 1 में जाने के लिए
    var_dump($result); // 1
}) ;  
$redis->select(1);  // DB 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 कमांड मान को कुंजी के मूल मान के अंत में जोड़ता है और स्ट्रिंग की लंबाई लौटाता है।

यदि कुंजी मौजूद नहीं है, तो 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 के दो ऑफसेट द्वारा निर्धारित की जाती है (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 को पास करता है।

बिना अंतराल के, प्रारंभ और समाप्ति नकारात्मक मान को शामिल कर सकते हैं ताकि स्ट्रिंग के अंत से बाइट्स को अनुक्रमित किया जा सके, जिसमें -1 अंतिम बाइट है, -2 दूसरे से अंतिम बाइट है, आदि।

परिणाम एक स्ट्रिंग में मान 1 के बिट्स की संख्या लौटाता है।

मौजूद कुंजी को खाली स्ट्रिंग माना जाता है, इसलिए यह कमांड शून्य लौटाएगी।

$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 कमांड को list, set और sorted set के तत्वों को क्रमबद्ध करने के लिए प्रयोग किया जा सकता है।

प्रोटोटाइप: 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 नहीं है, तो -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

कमांड हैशटेबल कुंजी में एक या एक से अधिक निर्दिष्ट फ़ील्ड को हटाने के लिए, मौजूद नहीं होने वाले फ़ील्डों को अनदेखा किया जाएगा।

सफलता से हटाए गए फ़ील्डों की संख्या लौटायें, अनदेखा फ़ील्डों को नहीं। यदि कुंजी हैश नहीं है, तो 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-बिट बिट सिग्निट नंबर के भीतर सीमित होती है।

$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

एक सहयोगी श्रृंखला के रूप में हैशटेबल में एक या एक से अधिक निर्दिष्ट फ़ील्ड के मान लौटाएगा।

यदि निर्दिष्ट फ़ील्ड हैशटेबल में मौजूद नहीं हैं, तो समकक्ष फ़ील्डों का मान NULL होगा। यदि कुंजी हैश नहीं है, तो 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

पैरामीटर COUNT के मान के आधार पर, सूची में पैरामीटर VALUE के बराबर तत्वों को हटा दें।

COUNT का मान निम्नलिखित में से कोई हो सकता है:

• संख्याएँ > 0: सूची के शीर्ष से सूची के अंत तक ढूंढें, VALUE के बराबर तत्वों को हटा दें, संख्याएँ COUNT।
• संख्याएँ < 0: सूची के अंत से शीर्ष की ओर ढूंढें, VALUE के बराबर तत्वों को हटा दें, संख्याएँ COUNT के अभाज्यता संख्या।
• COUNT = 0: सूची में सभी VALUE के बराबर मान को हटा दें।

हटाए गए तत्वों की संख्या लौटाए। सूची मौजूद नहीं है तो 0 लौटाएगी। यदि सूची नहीं है, तो false लौटाएगी।

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

lSet

सूचकांक द्वारा तत्वों के मान को सेट करें।

प्रभावी होने पर true लौटाएगा, जब सूचकांक पैरामीटर सीमा से बाहर हो, या एक खाली सूची पर LSET करने पर false लौटाएगी।

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

lTrim

एक सूची को ट्रिम करें, अर्थात्, सूची केवल निर्दिष्ट सीमा में तत्वों को बनाए रखेगी, निर्दिष्ट सीमा में नहीं होने वाले तत्व सभी हटा दिए जाएंगे।

सूचकांक 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

निर्दिष्ट सदस्य सदस्य को स्रोत सेट से गंतव्य सेट में स्थानांतरित करें।

SMOVE एक परमाणुता कार्रवाई है।

यदि स्रोत सेट मौजूद नहीं है या निर्दिष्ट सदस्य तत्व को शामिल नहीं करता है, तो SMOVE आदेश कोई कार्रवाई नहीं करेगा और केवल 0 लौटाएगा। अन्यथा, सदस्य तत्व स्रोत सेट से हटा दिया जाएगा और गंतव्य सेट में जोड़ा जाएगा।

जब गंतव्य सेट पहले से सदस्य तत्व को शामिल करता है, तो SMOVE आदेश केवल स्रोत सेट से सदस्य तत्व को हटा देता है और बिना कोई कार्रवाई करता है।

जब स्रोत या गंतव्य सेट सेट प्रकार नहीं हैं, तो 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

Redis Srandmember कमांड सेट के भीतर एक यादृच्छिक तत्व लौटाने के लिए प्रयोग किया जाता है।

Redis 2.6 संस्करण से शुरू होने पर, Srandmember कमांड वैकल्पिक मात्रा का पैरामीटर स्वीकार करता है:

• यदि मात्रा सकारात्मक है और सेट की संख्या से कम है, तो कमांड एक संख्या के सेट को लौटाता है जो मात्रा में है, जिसमें प्रत्येक तत्व अद्वितीय है। यदि मात्रा सेट की संख्या से बड़ी या बराबर है, तो पूरी सेट लौटाई जाएगी।
• यदि मात्रा नकारात्मक है, तो कमांड एक श्रृंखला लौटाता है जिसका लंबाई मात्रा के अभाज्यता मान के बराबर है, जिसमें तत्व कई बार उपस्थित हो सकते हैं।

यह ऑपरेशन 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']
});