workerman-redis

Tanıtım

workerman/redis, workerman tabanlı asenkron redis bileşenidir.

Not
Bu projenin ana amacı redis asenkron aboneliği (subscribe, pSubscribe) gerçekleştirmektir.
Redis yeterince hızlıdır, bu nedenle psubscribe veya subscribe asenkron abonelik ihtiyacı olmadıkça bu asenkron istemcinin kullanılması gerekmez, redis uzantısını kullanmak daha iyi performans sağlayacaktır.

Kurulum:

composer require workerman/redis ^v2.0.3

Geri Çağırma Kullanımı

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

Korutina Kullanımı

Not
Korutina kullanımı workerman>=5.0, workerman/redis>=2.0.0 ve composer require revolt/event-loop ^1.0.0 kurulumu gerektirir.

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

Geri çağırma fonksiyonu ayarlanmadığında, istemci asenkron istek sonucunu senkron bir şekilde döndürür, istek süreci mevcut işlemi engellemez, yani istekleri eşzamanlı olarak işleyebilir.

Not
psubscribe subscribe korutina kullanımını desteklememektedir.

Belgelendirme

Açıklama

Geri çağırma yönteminde, geri çağırma fonksiyonunun genellikle 2 parametresi vardır ($result, $redis), $result sonuçtur, $redis redis örneğidir. Örneğin:

use Workerman\Redis\Client;
$redis = new Client('redis://127.0.0.1:6379');
// Geri çağırma fonksiyonunu set çağrı sonucunu kontrol etmek için ayarlama
$redis->set('key', 'value', function ($result, $redis) {
    var_dump($result); // true
});
// Geri çağırma fonksiyonları isteğe bağlı parametrelerdir, burada geri çağırma fonksiyonu atlanmıştır
$redis->set('key1', 'value1');
// Geri çağırma fonksiyonları iç içe kullanılabilir
$redis->get('key', function ($result, $redis){
    $redis->set('key2', 'value2', function ($result) {
        var_dump($result);
    });
});

Bağlantı

use Workerman\Redis\Client;
// Geri çağırmayı atla
$redis = new Client('redis://127.0.0.1:6379');
// Geri çağırma ile
$redis = new Client('redis://127.0.0.1:6379', [
    'connect_timeout' => 10 // Bağlantı zaman aşımını 10 saniye olarak ayarla, ayarlanmazsa varsayılan 5 saniyedir
], function ($success, $redis) {
    // Bağlantı sonucu geri çağırma
    if (!$success) echo $redis->error();
});

auth

//  Şifre doğrulama
$redis->auth('password', function ($result) {

});
// Kullanıcı adı ve şifre doğrulama
$redis->auth('username', 'password', function ($result) {

});

pSubscribe

Belirtilen desene uyan bir veya daha fazla kanalı abone eder.

Her desen, it* gibi, it ile başlayan tüm kanalları eşleştirmek için kullanılır (it.news, it.blog, it.tweets vb.). news.* tüm news. ile başlayan kanalları eşleştirir (news.it, news.global.today vb.), bu şekilde devam eder.

Dikkat: pSubscribe geri çağırma fonksiyonunun 4 parametresi vardır ($pattern, $channel, $message, $redis)

$redis örneği pSubscribe veya subscribe arayüzünü çağırdıktan sonra, mevcut örnek diğer yöntemleri çağırmayı görmezden gelecektir.

$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 içeriği
});

Timer::add(5, function () use ($redis2){
    $redis2->publish('news.add', 'news içeriği');
});

subscribe

Belirtilen bir veya daha fazla kanalın bilgilerini abone olmak için kullanılır.

Dikkat: subscribe geri çağırma fonksiyonunun 3 parametresi vardır ($channel, $message, $redis)

$redis örneği pSubscribe veya subscribe arayüzünü çağırdıktan sonra, mevcut örnek diğer yöntemleri çağırmayı görmezden gelecektir.

$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 içeriği
});

Timer::add(5, function () use ($redis2){
    $redis2->publish('news', 'news içeriği');
});

publish

Belirtilen kanala bilgi göndermek için kullanılır.

Alınan bilgi sayısını döndürür.

$redis2->publish('news', 'news içeriği');

select

// Geri çağırmayı atla
$redis->select(2);
$redis->select('test', function ($result, $redis) {
    // select parametreleri sayısal olmalıdır, bu nedenle burada $result false olacaktır
    var_dump($result, $redis->error());
});

get

Belirtilen key'in değerini almak için komut kullanılır. Eğer key mevcut değilse, NULL döner. Eğer key'in sakladığı değer string tipi değilse, false döner.

$redis->get('key', function($result) {
     // Eğer key mevcut değilse NULL döndürülür, hata varsa false döner
    var_dump($result);
});

set

Verilen key'in değerini ayarlamak için kullanılır. Eğer key zaten başka bir değer saklıyorsa, SET eski değeri üzerine yazar, türü göz ardı eder.

$redis->set('key', 'value');
$redis->set('key', 'value', function($result){});
// Üçüncü parametre bir süre geçerlilik süresi, 10 saniye sonra süresi dolacak
$redis->set('key','value', 10);
$redis->set('key','value', 10, function($result){});

setEx, pSetEx

Belirtilen key için değer ve geçerlilik süresi ayarlamak için kullanılır. Eğer key zaten varsa, SETEX komutu eski değeri değiştirecektir.

// Dikkat ikinci parametre geçerlilik süresini saniye cinsinden alır
$redis->setEx('key', 3600, 'value'); 
// pSetEx birim milisaniye
$redis->pSetEx('key', 3600, 'value'); 

del

Mevcut bir anahtarı silmek için kullanılır, dönen sonuç sayısaldır ve kaç key'in silindiğini gösterir (var olmayan key'ler sayılmaz).

// Bir key sil
$redis->del('key');
// Birden fazla key sil
$redis->del(['key', 'key1', 'key2']);

setNx

(SETifNot eXists) komutu, belirtilen key mevcut değilse, key'e belirtilen değeri ayarlar.

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

exists

Belirtilen key'in mevcut olup olmadığını kontrol etmek için komut kullanılır. Dönen sonuç sayısaldır ve mevcut key'lerin sayısını gösterir.

$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

Key'de saklanan sayısal değeri bir/ belirlenen değere artırır. Eğer key mevcut değilse, key'in değeri önce 0 olarak başlatılır, ardından incr/incrBy işlemi gerçekleştirilir.
Eğer değer hatalı türdeyse, veya string türdeki bir değer sayısal olarak ifade edilemiyorsa, false döner.
Başarıyla dönen sonuç artırılan değerdir.

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

incrByFloat

Key'de saklanan değere belirtilen ondalık artış değerini ekler.
Eğer key mevcut değilse, INCRBYFLOAT önce key'in değerini 0 olarak ayarlar, ardından toplama işlemi gerçekleştirir.
Eğer değer hatalı türdeyse, veya string türdeki bir değer sayısal olarak ifade edilemiyorsa, false döner.
Başarıyla dönen sonuç artırılan değerdir.

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

decr, decrBy

Komut, key'de saklanan değeri bir/ belirlenen azaltma değeri kadar azaltır.
Eğer key mevcut değilse, key'in değeri önce 0 olarak başlatılır, ardından decr/decrBy işlemi gerçekleştirilir.
Eğer değer hatalı türdeyse, veya string türdeki bir değer sayısal olarak ifade edilemiyorsa, false döner.
Başarıyla dönen sonuç azaltılan değerdir.

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

mGet

Verilen tüm (bir veya daha fazla) key'in değerlerini döndürür. Eğer verilen key'lerden biri mevcut değilse, bu key NULL döner.

$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

Belirtilen key'in değerini ayarlamak ve key'in eski değerini döndürmek için kullanılır.

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

randomKey

Mevcut veritabanından rastgele bir key döndürür.

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

move

Mevcut veritabanındaki key'i belirtilen veritabanı db'ye taşır.

$redis->select(0);  // DB 0'a geç
$redis->set('x', '42'); // x'e 42 yaz
$redis->move('x', 1, function ($result) {   // DB 1'e taşı
    var_dump($result); // 1
}) ;  
$redis->select(1);  // DB 1'e geç
$redis->get('x', function ($result) {
    var_dump($result); // '42'
}) ;

rename

Key'in adını değiştirir, key mevcut değilse false döner.

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

renameNx

Yeni key mevcut değilken key'in adını değiştirir.

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

expire

Key'in geçerlilik süresini ayarlamak için kullanılır, key süresi dolduğunda artık kullanılamaz. Birim saniye cinsindendir. Başarıyla dönerse 1, key mevcut değilse 0, hata varsa false döner.

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

keys

Komut, verilen desen pattern'e uyan tüm key'leri bulmak için kullanılır.

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

type

Key'in sakladığı değerin türünü döndürür. Dönen sonuç, string, set, list, zset, hash veya none'dan biri olup, none key mevcut değilse kullanılır.

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

append

Eğer key zaten mevcut ve bir string ise, APPEND komutu value'i key'in orijinal değeri sonuna ekler ve string uzunluğunu döndürür.

Eğer key mevcut değilse, APPEND, belirtilen key'i value olarak ayarlar, bunun gibi SET key value kullanır ve string uzunluğunu döner.

Eğer key mevcut ama bir string değilse, false döner.

$redis->set('key', 'value1');
$redis->append('key', 'value2', function ($result) {
    var_dump($result); // 12
}) ; 
$redis->get('key', function ($result) {
    var_dump($result); // 'value1value2'
}) ;

getRange

Belirtilen key içerisinde saklanan string'in alt dizesini alır. String'in kesim aralığı start ve end iki ofsetle belirlenir (start ve end dahil). Eğer key mevcut değilse, boş bir string döner. Eğer key string türü değilse, false döner.

$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

Belirtilen string'in key'de saklanan string değerinin üzerine belirlenen string'i yazmak için kullanılır, yazım yeri ofset offset'ten başlar. Eğer key mevcut değilse, key belirtilen string olarak ayarlanır. Eğer key string türü değilse, false döner.

Dönen sonuç, değişmeden sonra string uzunluğudur.

$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

Belirtilen key'in sakladığı string değerinin uzunluğunu alır. Eğer key, string değeri saklamıyorsa, false döner.

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

getBit

Key'de saklanan string değerinden, belirtilen ofset üzerindeki biti alır.

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

setBit

Key'de saklanan string değerinden, belirtilen ofset üzerindeki biti ayarlar veya temizler.
Dönüş değeri 0 veya 1, bitin önceki değeridir.

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

bitOp

Birden fazla key (string değer içeren) arasında bit işlemi gerçekleştirir ve sonucu hedef key'de saklar.

BITOP komutu, dört bit işlemi destekler: AND, OR, XOR ve NOT.

Dönen sonuç, hedef key'de saklanan string'in boyutudur, bu da en uzun girdi string'in boyutuna eşittir.

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

bitCount

String'deki set bitlerin sayısını (popülasyon sayımı) hesaplar.

Varsayılan olarak, string içinde bulunan tüm byte'lar kontrol edilir. Yalnızca ek argüman start ve end aralığı geçirildiğinde sayım işlemi belirlenebilir.

GETRANGE komutuna benzer bir şekilde, başlamak ve bitirmek negatif değerleri içerebilir, bu da string'in sonundan byte'ları sıralamak için kullanılır; burada -1 son byte, -2 sondan ikinci byte vb. anlamına gelir.

Sonuç, string içinde değeri 1 olan bitlerin sayısını döner.

Mevcut olmayan key, boş string olarak kabul edilir, bu nedenle bu komut sıfır döndürür.

$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 komutu list, set ve sorted set elemanlarını sıralamak için kullanılabilir.

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

Burada options aşağıdaki isteğe bağlı anahtar ve değerlerdir

$options = [
     'by' => 'some_pattern_*',
    'limit' => [0, 1],
    'get' => 'some_other_pattern_*', // veya bir dizi desen
    'sort' => 'asc', // veya '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

Saniye/milisaniye cinsinden key'in kalan geçerlilik süresini döndürür.

Eğer key'in ttl yoksa, -1 döner. Eğer key mevcut değilse, -2 döner.

$redis->set('key', 'value', 10);
// Saniye cinsinden
$redis->ttl('key', function ($result) {
    var_dump($result); // 10
});
// Milisaniye cinsinden
$redis->pttl('key', function ($result) {
    var_dump($result); // 9999
});
// key mevcut değil
$redis->pttl('key-not-exists', function ($result) {
    var_dump($result); // -2
});

persist

Verilen key'in geçerlilik süresini kaldırır, böylece key asla süre aşımına uğramaz.

Eğer başarılı bir şekilde kaldırılırsa 1 döner, eğer key mevcut değilse veya geçerlilik süresi yoksa 0 döner, hata durumunda false döner.

$redis->persist('key');

mSet, mSetNx

Tek seferde birden fazla anahtar-değer çiftini ayarlamak için kullanılır. mSetNx yalnızca tüm anahtarlar ayarlanıldığında 1 döner.

Başarıyla dönerse 1, başarısız olursa 0, hata meydana gelirse false döner.

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

hSet

Hash tablosundaki alanı değeri ayarlamak için kullanılır.

Eğer alan hash tablosunda yeni bir alan ise ve değer başarıyla ayarlandıysa, 1 döner. Eğer hash tablosundaki alan mevcutsa ve eski değer yeni değerle değiştirilirse, 0 döner.

$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

Hash tablosunda mevcut olmayan bir alana değer atamak için kullanılır.

Eğer hash tablosu mevcut değilse, yeni bir hash tablosu oluşturulup HSET işlemi uygulanır.

Eğer alan zaten hash tablosunda mevcutsa, işlem geçersizdir.

Eğer key mevcut değilse, yeni bir hash tablosu oluşturulup HSETNX komutu uygulanır.

$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

Hash tablosundaki belirtilen alanın değerini döndürür.

Eğer belirtilen alan veya key mevcut değilse, null döner.

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

hLen

Hash tablosundaki alanların sayısını alın.

Eğer key mevcut değilse, 0 döner.

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

hDel

Komut, hash tablosundaki bir veya daha fazla belirtilen alanı silmek için kullanılır, mevcut olmayan alanlar göz ardı edilir.

Başarıyla silinen alanların sayısını döner, göz ardı edilen alanları içermez. Eğer key hash değilse false döner.

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

hKeys

Hash tablosundaki tüm alanları dizi şeklinde almak için kullanılır.

Eğer key mevcut değilse, boş dizi döner. Eğer key hash türünde değilse, false döner.

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

hVals

Hash tablosundaki tüm alan değerlerini dizi şeklinde döndürür.

Eğer key mevcut değilse, boş dizi döner. Eğer key hash türünde değilse, false döner.

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

hGetAll

Hash tablosundaki tüm alanları ve değerleri ilişkilendirilmiş dizi şeklinde döndürür.

Eğer key mevcut değilse, boş dizi döner. Eğer key hash türünde değilse, false döner.

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

Dönüş

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

hExists

Hash tablosundaki belirtilen alanın mevcut olup olmadığını kontrol eder. Var ise 1, alan mevcut değilse veya key mevcut değilse 0, hata oluşursa false döner.

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

hIncrBy

Hash tablosundaki alan değerine belirtilen artırma değerini ekler.

Artırma negatif değeri de alabilir, bu da belirtilen alan üzerinde çıkarma işlemi gerektirir.

Eğer hash tablosunun key'i mevcut değilse, yeni bir hash tablosu oluşturulur ve HINCRBY komutu uygulanır.

Eğer belirtilen alan mevcut değilse, komut uygulanmadan önce alanın değeri 0 olarak başlatılır.

String değeri saklayan bir alan üzerinde HINCRBY komutu uygulandığında false döner.

Bu işlemin değeri 64 bit işaretli sayının ifade edilebileceği değerler ile sınırlıdır.

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

hIncrByFloat

hIncrBy ile benzerdir, yalnızca artırma noktası ondalık türdedir.

hMSet

Birden fazla alan-değer (alan-değer) çiftini hash tablosuna ayarlar.

Bu komut mevcut alanları güncelleyerek değiştirir.

Eğer hash tablosu mevcut değilse, boş bir hash tablosu oluşturulup HMSET işlemi uygulanır.

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

hMGet

Hash tablosundaki bir veya daha fazla belirtilen alanın değerlerini ilişkilendirilmiş dizi şeklinde döndürür.

Eğer belirtilen alan hash tablosunda mevcut değilse, karşılık gelen alan null değerini alır. Eğer key hash değilse false döner.

$redis->del('h');
$redis->hSet('h', 'field1', 'value1');
$redis->hSet('h', 'field2', 'value2');
$redis->hMGet('h', ['field1', 'field2', 'field3'], function ($r) {
    var_export($r);
});

Çıktı

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

blPop, brPop

Liste'den ilk/ son elemanı çıkarır ve alır, eğer liste eleman içermezse, bekleme süresinin dolmasını bekler veya patlatılacak bir eleman bulur.

$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

Liste'den son elemanı çıkarır ve başka bir listeye başa ekler; Eğer liste eleman içermezse, bekleme süresinin dolmasını bekler veya patlatılacak bir eleman bulur. Eğer zaman aşımına uğrarsa, null döner.

$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

Liste'deki elemanı index ile almak için kullanılır. Negatif indeks kullanarak listenin son elemanı -1, sondan ikinci elemanı -2 şeklinde gösterebilirsiniz.

Eğer belirtilen indeks değeri listenin aralığında değilse, null döner. Eğer karşılık gelen key liste türünde değilse, false döner.

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

lInsert

Liste elemanının önüne veya arkasına eleman eklemek için kullanılır. Belirtilen eleman listede mevcut değilse herhangi bir işlem yapılmaz.

Liste mevcut değilse, boş liste olarak kabul edilir, herhangi bir işlem yapılmaz.

Eğer key liste türünde değilse, false döner.

$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

Liste'nin ilk elemanını çıkarır ve döndürür.

Eğer liste key mevcut değilse, null döner.

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

lPush

Bir veya daha fazla değer liste başına ekler. Eğer key mevcut değilse, boş bir liste oluşturulur ve LPUSH işlemi gerçekleştirilir. Eğer key mevcut ancak liste türünde değilse false döner.

Not: Redis 2.4 sürümünden önceki LPUSH komutları yalnızca tek bir değer alıyordu.

$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

Bir değeri mevcut bir listenin başına ekler, liste mevcut değilse işlem geçersizdir, 0 döner. Eğer key liste türünde değilse false döner.

Dönen değer lPushx komutu uygulandıktan sonra listenin uzunluğudur.

$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

Liste içinde belirtilen aralıktaki elemanları döndürür, aralık offset START ve END ile belirlenir. 0, listenin ilk elemanını belirtir, 1, listenin ikinci elemanını belirtir, vb. Negatif indeksler kullanarak listenin son elemanını -1, sondan ikinci elemanı -2 belirtmek mümkündür.

Belirtilen aralıktaki elemanları içeren bir dizi döner. Eğer key liste türünde değilse, false döner.

$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

Parametre COUNT'un değeriyle, listeden VALUE ile eşleşen elemanları kaldırır.

COUNT aşağıdaki değerlerden biri olabilir:

• count > 0: Başından itibaren sona kadar arama yapar, VALUE ile eşleşen elemanları, COUNT sayısı kadar kaldırır.
• count < 0: Sondan başlayarak başa kadar arama yapar, VALUE ile eşleşen elemanları, COUNT sayısının mutlak değeri kadar kaldırır.
• count = 0: Listede yer alan tüm VALUE ile eşleşen değerleri kaldırır.

Kaldırılan elemanların sayısını döner. Liste mevcut değilse 0 döner. Liste değilse false döner.

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

lSet

İndeks ile elemanın değerini ayarlamak için kullanılır.

Başarıyla dönerse true, indeks parametresi sınırları aştığında veya boş listeye LSET uygulandığında false döner.

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

lTrim

Listeyi kesmek için kullanılır, yani liste yalnızca belirtilen aralardaki elemanları bırakır, belirtilen aralığın dışında kalan tüm elemanlar silinir.

İndeks 0 liste'nin ilk elemanını belirtir, 1 liste'nin ikinci elemanını belirtir, vb. Negatif indeksler kullanarak listenin son elemanını -1, sondan ikinci elemanı -2 belirtmek mümkündür.

Başarıyla dönerse true, başarısız olursa false döner.

$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

Liste'nin son elemanını kaldırmak için kullanılır, kaldırılan elemanı döndürür.

Eğer liste mevcut değilse, null döner.

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

rPopLPush

Liste'nin son elemanını kaldırır ve bu elemanı başka bir listeye ekler ve döner.

$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

Bir veya daha fazla değeri listenin sonuna (en sağa) ekler ve ekleme sonrası listenin uzunluğunu döndürür.

Eğer liste mevcut değilse, boş bir liste oluşturulur ve RPUSH işlemi gerçekleştirilir. Eğer liste mevcut fakat liste türünde değilse false döner.

Not: Redis 2.4 sürümünden önceki RPUSH komutları yalnızca tek bir değer alıyordu.

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

rPushX

Bir değeri mevcut liste sonuna (en sağa) ekler ve listenin uzunluğunu döner. Eğer liste mevcut değilse, işlem geçersizdir ve 0 döner. Eğer liste mevcut fakat liste türünde değilse false döner.

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

lLen

Listenin uzunluğunu döndürür. Eğer liste key mevcut değilse, key boş bir liste olarak değerlendirilir ve 0 döner. Eğer key liste türünde değilse, false döner.

$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

Bir veya birden fazla üye elemanlarını kümeye ekler, zaten kümede mevcut olan üye elemanlar yoksayılarak eklenir.

Eğer küme key mevcut değilse, yalnızca eklenen elemanları içeren bir küme oluşturulur.

Eğer küme key küme türünde değilse false döner.

Not: Redis 2.4 sürümünden önceki SADD yalnızca tek bir üye değer alıyordu.

$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

Kümedeki eleman sayısını döner. Eğer küme key mevcut değilse 0 döner.

$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

İlk küme ile diğer kümeler arasındaki farkı döner, bu da ilk kümenin sahibinin yalnızca bulunan elemanları olarak düşünülebilir. Mevcut olmayan kümeler boş küme olarak kabul edilir.

$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

Belirtilen kümeler arasındaki farkı belirtilen kümeye kaydeder. Eğer belirtilen kümeye sahip küme mevcutsa, üzerine yazılır.

$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

Belirlenen tüm kümelerin kesişimini döndürür. Mevcut olmayan kümeler boş küme olarak kabul edilir. Belirtilen kümelerin içinden birinin boş küme olması sonucu da boş küme olacaktır.

$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

Kümülatif küme kesişimini belirtilen kümeye depolar ve depolanan kesişim kümesinin eleman sayısını döndürür. Eğer belirtilen küme mevcutsa, üzerine yazılacaktır.

$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

Üye elemanın kümenin üyesi olup olmadığını kontrol eder.

Eğer üye eleman kümenin üyesi ise 1 döner. Eğer üye eleman kümenin üyesi değilse veya key mevcut değilse 0 döner. Eğer key küme türünde değilse false döner.

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

sMembers

Kümedeki tüm üyeleri döndürür. Mevcut olmayan kümeler boş küme olarak kabul edilir.

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

sMove

Belirtilen üye member elemanını source kümelerden destination kümeye taşır.

SMOVE atomik bir işlemdir.

Eğer source kümesi mevcut değilse veya belirtilen member elemanını içermiyorsa, SMOVE komutu herhangi bir işlem gerçekleştirmez ve yalnızca 0 döner. Aksi takdirde, member elemanı source kümesinden kaldırılır ve destination kümesine eklenir.

Eğer destination kümesi member elemanını içeriyorsa, SMOVE komutu yalnızca source kümesindeki member elemanını kaldırır.

Eğer source veya destination küme türünde değilse false döner.

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

sPop

Kümeden belirtilen key'in bir veya daha fazla rastgele elemanını kaldırır, kaldırılan elemanları döndürür.

Eğer küme mevcut değilse veya boş küme ise, null döner.

$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 komutu, kümeden rastgele bir eleman döndürmek için kullanılır.

Redis 2.6 sürümünden başlayarak, Srandmember komutu isteğe bağlı count parametresini kabul eder:

• Eğer count pozitif bir sayıysa ve küme temeline göre küçükse, komut count adet elemanı içeren bir dizi döndürür, dizideki elemanlar birbirinden farklıdır. Eğer count küme temeline eşit veya daha büyükse, tüm kümeyi döndürür.
• Eğer count negatifse, komut bir dizi döndürür, dizideki elemanlar birden fazla kez yer alabilir, dizinin uzunluğu count'un mutlak değerine eşit olacaktır.

Bu işlem SPOP ile benzerlik gösterir, ancak SPOP, rastgele elemanları kümeden kaldırır ve döndürürken, Srandmember yalnızca rastgele elemanları döndürür ve kümeye herhangi bir müdahalede bulunmaz.

$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

Kümeden bir veya daha fazla üye elemanını kaldırır, mevcut olmayan üye elemanları göz ardı edilir.

Başarıyla kaldırılan elemanların sayısını döner, göz ardı edilen elemanları saymaz.

Eğer key küme türünde değilse false döner.

Redis 2.4 sürümünden önce SREM yalnızca tek bir üye değer alıyordu.

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

sUnion

Komut, verilen kümelerin birleşimini döndürür. Mevcut olmayan kümeler boş küme olarak kabul edilir.

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

sUnionStore

Verilen kümelerin birleşimini belirtilen destination kümesine depolar ve eleman sayısını döndürür. Eğer destination mevcutsa bu üzerine yazılır.

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