workerman-redis

Einführung

workeman/redis ist eine auf workerman basierende asynchrone Redis-Komponente.

Hinweis
Dieses Projekt hat in erster Linie zum Ziel, die asynchrone Redis-Subscription (subscribe, pSubscribe) zu implementieren.
Da Redis schnell genug ist, ist es nicht erforderlich, diesen asynchronen Client zu verwenden, es sei denn, man benötigt psubscribe oder subscribe für asynchrone Abonnements. Die Verwendung der Redis-Erweiterung bietet bessere Leistung.

Installation:

composer require workerman/redis ^v2.0.3

Callback-Nutzung

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

Coroutine-Nutzung

Hinweis
Die Coroutine-Nutzung erfordert workerman>=5.0, workerman/redis>=2.0.0 und die Installation von 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();

Wenn keine Callback-Funktion gesetzt wird, wird das Client synchron die Ergebnisse von asynchronen Anforderungen zurückgeben. Der Anfrageprozess blockiert den aktuellen Prozess nicht, das bedeutet, dass Anforderungen gleichzeitig bearbeitet werden können.

Hinweis
psubscribe und subscribe unterstützen keine Coroutine-Nutzung.

Dokumentation

Hinweis

Bei der Callback-Methode hat die Callback-Funktion in der Regel 2 Parameter ($result, $redis), wobei $result das Ergebnis und $redis die Redis-Instanz ist. Zum Beispiel:

use Workerman\Redis\Client;
$redis = new Client('redis://127.0.0.1:6379');
// Setzen Sie die Callback-Funktion, um das Ergebnis des Set-Aufrufs zu überprüfen
$redis->set('key', 'value', function ($result, $redis) {
    var_dump($result); // true
});
// Callback-Funktionen sind optionale Parameter, hier wird die Callback-Funktion weggelassen
$redis->set('key1', 'value1');
// Callback-Funktionen können geschachtelt werden
$redis->get('key', function ($result, $redis) {
    $redis->set('key2', 'value2', function ($result) {
        var_dump($result);
    });
});

Verbindung

use Workerman\Redis\Client;
// Ohne Callback
$redis = new Client('redis://127.0.0.1:6379');
// Mit Callback
$redis = new Client('redis://127.0.0.1:6379', [
    'connect_timeout' => 10 // Setzt die Verbindungszeitüberschreitung auf 10 Sekunden, standardmäßig 5 Sekunden
], function ($success, $redis) {
    // Callback für das Verbindungsergebnis
    if (!$success) echo $redis->error();
});

auth

//  Passwortüberprüfung
$redis->auth('password', function ($result) {

});
// Überprüfung von Benutzername und Passwort
$redis->auth('username', 'password', function ($result) {

});

pSubscribe

Abonnieren eines oder mehrerer Kanäle, die dem angegebenen Muster entsprechen.

Jedes Muster verwendet als Platzhalter, zum Beispiel it passt zu allen Kanälen, die mit it beginnen (it.news, it.blog, it.tweets usw.). news.* passt zu allen Kanälen, die mit news. beginnen (news.it, news.global.today usw.) und so weiter.

Hinweis: Die pSubscribe-Callback-Funktion hat 4 Parameter ($pattern, $channel, $message, $redis)

Sobald die $redis-Instanz die pSubscribe- oder subscribe-Schnittstelle aufruft, werden alle weiteren Methodenaufrufe für die aktuelle Instanz ignoriert.

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

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

subscribe

Verwendet, um Informationen zu einem oder mehreren angegebenen Kanälen zu abonnieren.

Hinweis: Die subscribe-Callback-Funktion hat 3 Parameter ($channel, $message, $redis)

Wenn die $redis-Instanz die pSubscribe- oder subscribe-Schnittstelle aufruft, werden alle weiteren Methodenaufrufe für die aktuelle Instanz ignoriert.

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

Timer::add(5, function () use ($redis2) {
    $redis2->publish('news', 'newsinhalt');
});

publish

Verwendet zum Senden von Informationen an den angegebenen Kanal.

Gibt die Anzahl der empfangenden Abonnenten zurück.

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

select

// Ohne Callback
$redis->select(2);
$redis->select('test', function ($result, $redis) {
    // Der select-Parameter muss eine Zahl sein, daher ist $result hier false
    var_dump($result, $redis->error());
});

get

Der Befehl wird verwendet, um den Wert des angegebenen Schlüssels zu erhalten. Wenn der Schlüssel nicht existiert, wird NULL zurückgegeben. Wenn der Wert, der für den Schlüssel gespeichert ist, kein String-Typ ist, wird false zurückgegeben.

$redis->get('key', function($result) {
    // Wenn der Schlüssel nicht existiert, wird NULL zurückgegeben, bei Fehlern wird false zurückgegeben
    var_dump($result);
});

set

Verwendet zum Setzen des Wertes des angegebenen Schlüssels. Wenn der Schlüssel bereits einen anderen Wert gespeichert hat, wird SET den alten Wert überschreiben, ohne auf den Typ zu achten.

$redis->set('key', 'value');
$redis->set('key', 'value', function($result){});
// Der dritte Parameter kann eine Ablaufzeit übergeben werden, die nach 10 Sekunden abläuft
$redis->set('key','value', 10);
$redis->set('key','value', 10, function($result){});

setEx, pSetEx

Setzt den Wert und die Ablaufzeit für den angegebenen Schlüssel. Wenn der Schlüssel bereits existiert, wird der SETEX-Befehl den alten Wert ersetzen.

// Hinweis: Der zweite Parameter gibt die Ablaufzeit in Sekunden an
$redis->setEx('key', 3600, 'value'); 
// pSetEx hat Millisekunden als Einheit
$redis->pSetEx('key', 3600, 'value'); 

del

Verwendet, um einen bestehenden Schlüssel zu löschen, das Ergebnis ist eine Zahl, die angibt, wie viele Schlüssel gelöscht wurden (nicht-existing Schlüssel zählen nicht).

// Löschen eines Schlüssels
$redis->del('key');
// Löschen mehrerer Schlüssel
$redis->del(['key', 'key1', 'key2']);

setNx

(SETifNot eXists) Der Befehl setzt den angegebenen Wert für den Schlüssel, wenn der Schlüssel nicht existiert.

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

exists

Der Befehl wird verwendet, um zu überprüfen, ob der angegebene Schlüssel existiert. Das Ergebnis ist eine Zahl, die die Anzahl der existierenden Schlüssel angibt.

$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

Erhöht den in dem Schlüssel gespeicherten Zahlenwert um eins/einen bestimmten Wert. Wenn der Schlüssel nicht existiert, wird der Wert des Schlüssels zuerst auf 0 initialisiert, bevor die incr/incrBy-Operation ausgeführt wird.
Wenn der Wert einen falschen Typ hat oder der String-Wert nicht als Zahl dargestellt werden kann, wird false zurückgegeben.
Im Erfolgsfall wird der erhöhte Wert zurückgegeben.

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

incrByFloat

Erhöht den gespeicherten Wert im Schlüssel um einen angegebenen Floatsummenwert.
Wenn der Schlüssel nicht existiert, wird INCRBYFLOAT zuerst den Wert des Schlüssels auf 0 setzen, bevor die Additionsoperation ausgeführt wird.
Wenn der Wert einen falschen Typ hat oder der String-Wert nicht als Zahl dargestellt werden kann, wird false zurückgegeben.
Im Erfolgsfall wird der erhöhte Wert zurückgegeben.

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

decr, decrBy

Der Befehl verringert den Wert, der im Schlüssel gespeichert ist, um eins/einen bestimmten Wert.
Wenn der Schlüssel nicht existiert, wird der Wert des Schlüssels zuerst auf 0 initialisiert, bevor die decr/decrBy-Operation ausgeführt wird.
Wenn der Wert einen falschen Typ hat oder der String-Wert nicht als Zahl dargestellt werden kann, wird false zurückgegeben.
Im Erfolgsfall wird der verringerte Wert zurückgegeben.

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

mGet

Gibt alle (einen oder mehrere) Werte der angegebenen Schlüssel zurück. Wenn ein gegebener Schlüssel nicht existiert, wird NULL zurückgegeben.

$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

Setzt den Wert eines bestimmten Schlüssels und gibt den alten Wert des Schlüssels zurück.

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

randomKey

Gibt einen Schlüssel zufällig aus der aktuellen Datenbank zurück.

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

move

Bewegt den Schlüssel aus der aktuellen Datenbank in die angegebene Datenbank db.

$redis->select(0);  // wechselt zu DB 0
$redis->set('x', '42'); // schreibt 42 in x
$redis->move('x', 1, function ($result) {   // bewegt nach DB 1
    var_dump($result); // 1
}) ;  
$redis->select(1);  // wechselt zu DB 1
$redis->get('x', function ($result) {
    var_dump($result); // '42'
}) ;

rename

Ändert den Namen des Schlüssels. Existiert der Schlüssel nicht, wird false zurückgegeben.

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

renameNx

Ändert den Namen des Schlüssels, wenn der neue Schlüssel nicht existiert.

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

expire

Setzt die Ablaufzeit des Schlüssels. Nach Ablauf des Schlüssels ist dieser nicht mehr verfügbar. Einheit in Sekunden. Erfolg gibt 1 zurück, der Schlüssel existiert nicht gibt 0 zurück, bei Fehler false.

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

keys

Der Befehl wird verwendet, um alle Schlüssel zu findensch pattern zu durchsuchen.

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

type

Gibt den Typ des Wertes zurück, der im Schlüssel gespeichert ist. Das Ergebnis ist eine Zeichenfolge, die einer der folgenden ist: string set list zset hash none, wobei none angibt, dass der Schlüssel nicht existiert.

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

append

Wenn der Schlüssel bereits existiert und ein String ist, wird der APPEND-Befehl dem ursprünglichen Wert des Schlüssels einen Wert hinzufügen und die Länge der Zeichenfolge zurückgeben.

Existiert der Schlüssel nicht, wird APPEND einfach den angegebenen Schlüssel als Wert gesetzt, als ob SET key value ausgeführt wird, und gibt die Länge der Zeichenfolge zurück.

Wenn der Schlüssel existiert, aber kein String ist, wird false zurückgegeben.

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

getRange

Erhält die Teilzeichenfolge, die im angegebenen Schlüssel gespeichert ist. Der Bereich der Zeichenbeschneidung wird durch die Start- und End-Offsets bestimmt (einschließlich Start und Ende). Wenn der Schlüssel nicht existiert, wird eine leere Zeichenfolge zurückgegeben. Wenn der Schlüssel kein String-Typ ist, wird false zurückgegeben.

$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

Überschreibt den gespeicherten Zeichenwert im angegebenen Schlüssel mit der gegebenen Zeichenfolge, beginnend beim Offset. Existiert der Schlüssel nicht, wird der Schlüssel auf die angegebene Zeichenfolge gesetzt. Ist der Schlüssel kein String, wird false zurückgegeben.

Das Ergebnis ist die Länge der veränderten Zeichenfolge.

$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

Gibt die Länge des gespeicherten Zeichenwerts des angegebenen Schlüssels zurück. Wenn der Schlüssel nicht als String gespeichert ist, wird false zurückgegeben.

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

getBit

Für den im Schlüssel gespeicherten String-Wert wird das Bit an der angegebenen Offset angezeigt.

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

setBit

Für den im Schlüssel gespeicherten String-Wert wird das Bit an der angegebenen Offset gesetzt oder gelöscht.
Der Rückgabewert ist 0 oder 1, der Wert vor der Änderung.

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

bitOp

Führt bitweise Operationen zwischen mehreren Schlüsseln (einschließlich String-Werte) aus und speichert das Ergebnis im Zielschlüssel.

Der BITOP-Befehl unterstützt vier bitweise Operationen: AND, OR, XOR und NOT.

Das Ergebnis wird im Ziel-Schlüssel gespeichert und entspricht der Größe des längsten Eingabestrings.

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

bitCount

Zählt die gesetzten Bits in der Zeichenfolge (Populationszählung).

Standardmäßig werden alle Bytes in der Zeichenfolge überprüft. Die Zähloperation kann nur innerhalb des Intervalls angegeben werden, indem zusätzliche Argumente start und end übergeben werden.

Ähnlich wie der GETRANGE-Befehl können die Start- und Endwerte negative Werte enthalten, um Bytes von hinten zu indizieren, wobei -1 das letzte Byte, -2 das vorletzte Zeichen usw. bedeutet.

Das Ergebnis gibt die Anzahl der Bits in der Zeichenfolge zurück, die den Wert 1 haben.

Nicht existierende Schlüssel werden als leere Zeichenfolge betrachtet, sodass dieser Befehl Null zurückgibt.

$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

Der sort-Befehl kann Elemente von Listen, Sets und sortierten Sets sortieren.

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

Dabei sind options die folgenden optionalen Schlüssel und Werte

$options = [
    'by' => 'some_pattern_*',
    'limit' => [0, 1],
    'get' => 'some_other_pattern_*', // oder ein Array von Mustern
    'sort' => 'asc', // oder '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

Gibt die verbleibende Ablaufzeit des Schlüssels in Sekunden/Millisekunden zurück.

Wenn der Schlüssel kein TTL hat, wird -1 zurückgegeben. Wenn der Schlüssel nicht existiert, wird -2 zurückgegeben.

$redis->set('key', 'value', 10);
// in Sekunden
$redis->ttl('key', function ($result) {
    var_dump($result); // 10
});
// in Millisekunden
$redis->pttl('key', function ($result) {
    var_dump($result); // 9999
});
// Schlüssel existiert nicht
$redis->pttl('key-not-exists', function ($result) {
    var_dump($result); // -2
});

persist

Entfernt die Ablaufzeit des angegebenen Schlüssels, sodass der Schlüssel niemals abläuft.

Wenn das Entfernen erfolgreich ist, wird 1 zurückgegeben. Wenn der Schlüssel nicht existiert oder keine Ablaufzeit hat, wird 0 zurückgegeben. Bei Fehler false zurückgegeben.

$redis->persist('key');

mSet, mSetNx

Setzt mehrere Schlüssel-Werte-Paare in einem atomaren Befehl. mSetNx gibt nur 1 zurück, wenn alle Schlüssel gesetzt wurden.

Erfolg gibt 1 zurück, Misserfolg 0, bei Fehler false.

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

hSet

Setzt einen Wert für ein Feld in der Hash-Tabelle.

Wenn das Feld ein neu angelegtes Feld in der Hash-Tabelle ist und der Wert erfolgreich gesetzt wird, gibt es 1 zurück. Wenn das Feld in der Hash-Tabelle bereits existiert und der alte Wert durch den neuen Wert überschrieben wird, gibt es 0 zurück.

$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

Setzt einen Wert für ein nicht existentes Feld in der Hash-Tabelle.

Wenn die Hash-Tabelle nicht existiert, wird eine neue Hash-Tabelle erstellt und die HSET-Operation durchgeführt.

Wenn das Feld bereits in der Hash-Tabelle existiert, wird die Operation ignoriert.

Wenn der Schlüssel nicht existiert, wird eine neue Hash-Tabelle erstellt und der HSETNX-Befehl ausgeführt.

$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

Gibt den Wert des angegebenen Feldes in der Hash-Tabelle zurück.

Wenn das angegebene Feld oder der Schlüssel nicht existiert, wird null zurückgegeben.

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

hLen

Erhält die Anzahl der Felder in der Hash-Tabelle.

Wenn der Schlüssel nicht existiert, wird 0 zurückgegeben.

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

hDel

Der Befehl wird verwendet, um ein oder mehrere angegebene Felder in der Hash-Tabelle zu löschen; nicht existierende Felder werden ignoriert.

Es wird die Anzahl der erfolgreich gelöschten Felder zurückgegeben, die ignorierten Felder nicht mitgezählt. Wenn der Schlüssel kein Hash ist, wird false zurückgegeben.

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

hKeys

Erhält alle Felder in der Hash-Tabelle in Form eines Arrays.

Wenn der Schlüssel nicht existiert, wird ein leeres Array zurückgegeben. Wenn der Schlüssel kein Hash ist, wird false zurückgegeben.

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

hVals

Gibt alle Werte der Felder in der Hash-Tabelle in Form eines Arrays zurück.

Wenn der Schlüssel nicht existiert, wird ein leeres Array zurückgegeben. Wenn der Schlüssel kein Hash ist, wird false zurückgegeben.

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

hGetAll

Gibt alle Felder und Werte in der Hash-Tabelle als assoziatives Array zurück.

Wenn der Schlüssel nicht existiert, wird ein leeres Array zurückgegeben. Wenn der Schlüssel kein Hash ist, wird false zurückgegeben.

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

Gibt zurück

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

hExists

Überprüft, ob das angegebene Feld in der Hash-Tabelle existiert. Existiert es, wird 1 zurückgegeben, wenn das Feld nicht existiert oder der Schlüssel nicht existiert, wird 0 zurückgegeben, bei Fehlern false.

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

hIncrBy

Erhöht den Wert des Feldes in der Hash-Tabelle um den angegebenen Inkrementwert.

Das Inkrement kann auch negativ sein, was einer Subtraktion des angegebenen Feldwerts entspricht.

Wenn der Schlüssel der Hash-Tabelle nicht existiert, wird eine neue Hash-Tabelle erstellt und der HINCRBY-Befehl ausgeführt.

Wenn das angegebene Feld nicht existiert, wird der Wert des Feldes vor Ausführung des Befehls auf 0 initialisiert.

Wenn der Befehl auf ein Feld ausgeführt wird, das einen String-Wert speichert, wird false zurückgegeben.

Der Wert ist auf 64-Bit (bit) signierte Zahleneingaben beschränkt.

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

hIncrByFloat

Ähnlich wie hIncrBy, nur dass der Inkrementwert ein Float ist.

hMSet

Setzt gleichzeitig mehrere field-value (Feld-Wert) Paare in die Hash-Tabelle.

Dieser Befehl überschreibt vorhandene Felder in der Hash-Tabelle.

Wenn die Hash-Tabelle nicht existiert, wird eine leere Hash-Tabelle erstellt und der HMSET-Befehl wird ausgeführt.

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

hMGet

Gibt die Werte der ein oder mehrere angegebenen Felder in der Hash-Tabelle als assoziatives Array zurück.

Wenn das angegebene Feld nicht in der Hash-Tabelle existiert, wird der entsprechende Feldwert null sein. Wenn der Schlüssel kein Hash ist, wird false zurückgegeben.

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

Gibt aus

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

blPop, brPop

Entfernt das erste/letzte Element einer Liste und gibt es zurück. Wenn die Liste kein Element hat, wird die Liste blockiert, bis die Wartezeit abgelaufen ist oder ein entfernbares Element gefunden wird.

$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

Entfernt das letzte Element einer Liste und fügt es an den Kopf einer anderen Liste hinzu; wenn die Liste kein Element hat, blockiert die Liste, bis die Wartezeit abgelaufen ist oder ein entfernbares Element gefunden wurde. Wenn der Timeout abläuft, wird null zurückgegeben.

$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

Erhält das Element in der Liste anhand des Index. Du kannst auch negative Indizes verwenden, wobei -1 das letzte Listenelement, -2 das vorletzte Listenelement usw. darstellt.

Wenn der angegebene Indexwert nicht im Bereich der Liste liegt, wird null zurückgegeben. Wenn der entsprechende Schlüssel nicht vom Typ List ist, wird false zurückgegeben.

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

lInsert

Fügt ein Element vor oder nach einem bestehenden Element in der Liste hinzu. Wenn das angegebene Element nicht in der Liste vorhanden ist, wird keine Aktion durchgeführt.

Wenn die Liste nicht existiert, wird sie als leere Liste betrachtet und keine Aktion durchgeführt.

Wenn der Schlüssel nicht vom Typ List ist, wird false zurückgegeben.

$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

Entfernt und gibt das erste Element der Liste zurück.

Wenn der Listen-Schlüssel nicht existiert, wird null zurückgegeben.

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

lPush

Fügt einen oder mehrere Werte am Kopf der Liste hinzu. Wenn der Schlüssel nicht existiert, wird eine leere Liste erstellt und die LPUSH-Operation wird durchgeführt. Wenn der Schlüssel existiert, aber kein List-Typ ist, wird false zurückgegeben.

Hinweis: Ab der Redis-Version 2.4 akzeptiert der LPUSH-Befehl nur einen einzelnen Wert.

$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

Fügt einen Wert am Kopf einer bereits existierenden Liste hinzu; wenn die Liste nicht existiert, wird keine Aktion durchgeführt, es wird 0 zurückgegeben. Wenn der Schlüssel kein List ist, wird false zurückgegeben.

Der Rückgabewert ist die Länge der Liste nach der Ausführung des lPushx-Befehls.

$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

Gibt die Elemente der Liste innerhalb des angegebenen Bereichs zurück, wobei der Bereich durch die Offsets START und END angegeben wird. Dabei bedeutet 0 das erste Element der Liste, 1 das zweite Element usw. Du kannst auch negative Indizes verwenden, wobei -1 das letzte Element der Liste, -2 das vorletzte Element usw. darstellt.

Gibt ein Array mit den angegebenen Elementen zurück. Wenn der Schlüssel kein List ist, wird false zurückgegeben.

$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

Entfernt in der Liste die Elemente, die dem Parameter VALUE entsprechen, basierend auf dem Wert von COUNT.

Die Werte von COUNT können wie folgt sein:

• count > 0 : Durchsucht die Liste vom Kopf bis zum Schwanz und entfernt die Elemente, die dem VALUE entsprechen, in der Menge von COUNT.
• count < 0 : Durchsucht die Liste vom Schwanz bis zum Kopf und entfernt die Elemente, die VALUE entsprechen, in der Menge von COUNT in absoluter Größe.
• count = 0 : Entfernt alle Werte, die in der Liste dem VALUE entsprechen.

Es wird die Anzahl der entfernten Elemente zurückgegeben. Die Liste existiert nicht, gibt 0 zurück. Wenn der Schlüssel kein List ist, wird false zurückgegeben.

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

lSet

Ändert den Wert eines Elements durch den Index.

Erfolgt erfolgreich, gibt true zurück. Wenn der Indexparameter außerhalb des Bereichs liegt oder auf einer leeren Liste eine LSET-Operation durchgeführt wird, wird false zurückgegeben.

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

lTrim

Schneidet eine Liste so, dass nur die Elemente im angegebenen Bereich beibehalten werden, während alle anderen Elemente im angegebenen Bereich gelöscht werden.

Der Index 0 bedeutet das erste Element der Liste, 1 bedeutet das zweite Element usw. Du kannst auch negative Indizes verwenden, wobei -1 das letzte Element der Liste, -2 das vorletzte Element usw. darstellt.

Erfolgt erfolgreich, gibt true zurück. Bei Misserfolg 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

Entfernt das letzte Element der Liste und gibt es zurück.

Wenn die Liste nicht existiert, wird null zurückgegeben.

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

rPopLPush

Entfernt das letzte Element der Liste und fügt es einer anderen Liste hinzu und gibt es zurück.

$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

Fügt einen oder mehrere Werte am Ende der Liste hinzu (rechts) und gibt die Länge der Liste nach dem Hinzufügen zurück.

Wenn die Liste nicht existiert, wird eine leere Liste erstellt und die RPUSH-Operation wird durchgeführt. Wenn die Liste existiert, aber kein List-Typ ist, wird false zurückgegeben.

Hinweis: Ab der Redis-Version 2.4 akzeptiert der RPUSH-Befehl nur einen einzelnen Wert.

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

rPushX

Fügt einen Wert am Ende einer bereits existierenden Liste hinzu (rechts) und gibt die Länge der Liste nach dem Hinzufügen zurück. Wenn die Liste nicht existiert, wird keine Aktion durchgeführt, und es wird 0 zurückgegeben. Wenn die Liste existiert, aber kein List-Typ ist, wird false zurückgegeben.

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

lLen

Gibt die Länge der Liste zurück. Wenn der Listen-Schlüssel nicht existiert, wird der Schlüssel als leere Liste interpretiert und gibt 0 zurück. Wenn der Schlüssel kein List-Typ ist, wird false zurückgegeben.

$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

Fügt ein oder mehrere Mitgliedselemente zum Set hinzu. Mitgliedselemente, die bereits im Set vorhanden sind, werden ignoriert.

Wenn der Set-Schlüssel nicht existiert, wird ein Set erstellt, das nur das hinzugefügte Element als Mitglied enthält.

Wenn der Set-Schlüssel kein Set ist, wird false zurückgegeben.

Hinweis: In Redis-Version 2.4 akzeptiert SADD nur einen einzelnen Mitgliedswert.

$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

Gibt die Anzahl der Elemente im Set zurück. Wenn der Set-Schlüssel nicht existiert, wird 0 zurückgegeben.

$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

Gibt die Unterschiede zwischen dem ersten Set und anderen Sets zurück, was auch bedeutet, dass die Elemente, die nur im ersten Set enthalten sind. Nicht existierende Set-Schlüssel werden als leere Menge betrachtet.

$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

Speichert die Differenz zwischen den angegebenen Mengen in dem angegebenen Set. Wenn das angegebene Set bereits existiert, wird es überschrieben.

$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

Gibt die Schnittmenge aller angegebenen Mengen zurück. Nicht existierende Set-Schlüssel werden als leere Menge betrachtet. Wenn eine der angegebenen Mengen leer ist, ist das Ergebnis ebenfalls eine leere Menge.

$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

Speichert die Schnittmenge der angegebenen Sets in dem angegebenen Set und gibt die Anzahl der Elemente im gespeicherten Set zurück. Wenn das angegebene Set bereits existiert, wird es überschrieben.

$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

Überprüft, ob das Mitgliedselement ein Mitglied des Sets ist.

Wenn das Mitgliedselement ein Mitglied des Sets ist, wird 1 zurückgegeben. Wenn das Mitgliedselement kein Mitglied des Sets ist oder der Schlüssel nicht existiert, wird 0 zurückgegeben. Wenn der Schlüssel kein Set ist, wird false zurückgegeben.

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

sMembers

Gibt alle Mitglieder des Sets zurück. Nicht existierende Set-Schlüssel werden als leere Menge betrachtet.

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

sMove

Bewegt das angegebene Mitgliedselement von der Quellmenge zur Zielmenge.

SMOVE ist eine atomare Operation.

Wenn die Quellmenge nicht existiert oder das angegebene Mitgliedselement nicht enthält, führt der SMOVE-Befehl keine Operation durch und gibt lediglich 0 zurück. Andernfalls wird das Mitgliedselement aus der Quellmenge entfernt und zur Zielmenge hinzugefügt.

Wenn die Zielmenge das Mitgliedselement bereits enthält, wird wiederum nur das Mitgliedselement aus der Quellmenge entfernt.

Wenn die Quell- oder Zielmenge kein Set ist, wird false zurückgegeben.

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

sPop

Entfernt ein oder mehrere zufällige Elemente aus dem angegebenen Schlüssel des Sets und gibt die entfernten Elemente zurück.

Wenn das Set nicht existiert oder leer ist, wird null zurückgegeben.

$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

Der Redis Srandmember-Befehl gibt ein zufälliges Element aus dem Set zurück.

Seit der Redis-Version 2.6 akzeptiert der Srandmember-Befehl einen optionalen count-Parameter:

• Wenn count eine positive Zahl ist und kleiner als die Basis des Sets, gibt der Befehl ein Array mit count-Elementen zurück, die alle unterschiedlich sind. Wenn count größer oder gleich der Basis des Sets ist, wird das gesamte Set zurückgegeben.
• Wenn count eine negative Zahl ist,则返回 berücksichtigen, dass elemente der array array, die elemente, die der absolute wert von count sind.

Diese Operation ähnelt SPOP, aber SPOP entfernt zufällige Elemente aus dem Set und gibt sie zurück, während Srandmember nur zufällige Elemente zurückgibt, ohne das Set zu verändern.

$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

Entfernt ein oder mehrere Mitglieder des Sets und ignoriert nicht existierende Mitglieder.

Gibt die Anzahl der erfolgreich entfernten Mitglieder zurück, ohne die ignorierten Mitglieder mit zu zählen.

Wenn der Schlüssel nicht vom Typ Set ist, wird false zurückgegeben.

In Redis-Version 2.4 akzeptiert SREM nur einen einzelnen Mitgliedswert.

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

sUnion

Der Befehl gibt die Vereinigung der angegebenen Sets zurück. Nicht existierende Set-Schlüssel werden als leere Menge betrachtet.

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

sUnionStore

Speichert die Vereinigung der angegebenen Sets in dem angegebenen Zielset und gibt die Anzahl der Elemente zurück. Wenn das Zielset bereits existiert, wird es überschrieben.

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