PHP Redis

<span> 1</span> <?php <span>if</span> (!<span>definiert</span>('BASEPATH')) <span>exit</span>('Keine direkte Skriptzugriff erlaubt'<span>); 
</span><span>2</span><span>Klasse</span><span>Myredis
</span><span>3</span><span>{
</span><span> 4</span><span>//</span><span>redis所有已知命令：
</span><span> 5</span><span> //append,auth,bgrewriteaof,bgsave,bitcount,bitop,blpop,brpop,brpoplpush,client-kill,client-list,client-getname, client-setname,config -get,config-set,config-resetstat,dbsize,debug-object,debug-segfault,decr,decrby,del,discard, dump,echo,eval,evalsha,exec,exists,expire,expireat,flushall,flushdb,get ,getbit,getrange,getset,hdel,hexists,hget, hgetall,hincrby,hincrbyfloat,hkeys,hlen,hmget,hmset,hset,hsetnx,hvals,incr,incrby,incrbyfloat,info,keys,lastsave, lindex,linsert,llen ,lpop,lpush,lpushx,lrange,lrem,lset,ltrim,mget,migrate,monitor,move,mset,msetnx,multi,object, persist,pexpire,pexpireat,pfadd,pfcount,pfmerge,ping,psetex,psubscribe,pttl ,publish,punsubscribe,quit,randomkey,rename,renamenx,restore, rpop,rpoplpush,rpush,rpushx,sadd,save,scard,script-exists,script-flush,script-kill,script-load,sdiff,sdiffstore, select ,set,setbit,setex,setnx,setrange,shutdown,sinter,sinterstore,sismember,slaveof,slowlog,smembers,smove,sort, spop,srandmember,srem,strlen,subscribe,sunion,sunionstore,sync,time,ttl,type ,unsubscribe,unwatch,watch,zadd,zcard, zcount,zincrby,zinterstore,zrange,zrangebyscore,zrank,zrem,zremrangebyrank,zremrangebyscore,zrevrange, zrevrangebyscore,zrevrank,zscore,zunionstore,pubsub,config-rewrite,client-pause,hscan ,scan,sscan,zscan</span><span> 6</span><span> 7</span><span>privat</span><span>statisch</span><span>$redis</span><span>;
</span><span> 8</span><span> 9</span><span>public</span><span>function</span> __construct(<span>$arConfig</span> = <span>array</span>( 'host'=>'127.0.0.1', 'port'=> 6379<span>))
</span><span> 10</span><span> {
</span><span> 11</span><span>$this</span>->host = <span>$arConfig</span>['host'<span>];
</span><span> 12</span><span>$this</span>->port = <span>$arConfig</span>['port'<span>];
</span><span> 13</span> self::<span>$redis</span> = <span>new</span><span> Redis();
</span><span> 14</span> self::<span>$redis</span>->connect(<span>$this</span>->host, <span>$this</span>-> <span>Port);
</span><span> 15</span><span>return</span> self::<span>$redis</span><span>;
</span><span>16</span><span> }
</span><span> 17</span><span> 18</span><span>public</span><span>function</span> __call(<span>$sMethod</span>, <span>$arParam</span> <span>)
</span><span>19</span><span> {
</span><span> 20</span><span>return</span><span>call_user_func_array</span>(<span>array</span>(self::<span>$redis</span>, <span>$sMethod </span>), <span>$arParam</span><span>);
</span><span>21</span><span> }
</span><span>22</span><span>23</span><span>/*</span><span>******************** Schlüssel *** *****************</span><span>*/</span><span> 24</span><span> 25</span><span>/*</span> <span>*
</span><span> 26</span><span> * 查找所有符合给定模式 Muster 的 Taste 。
</span><span> 27</span><span> * KEYS * 匹配数据库中所有 key 。
</span><span> 28</span><span> * SCHLÜSSEL h?llo 匹配 hallo, hallo 和 hxllo 等。
</span><span> 29</span><span> * SCHLÜSSEL h*llo 匹配 hllo 和 heeeeello 等。
</span><span> 30</span><span> * SCHLÜSSEL h[ae]llo 匹配 hello 和 hallo ，但不匹配hillo 。
</span><span> 31</span><span> * 特殊符号用 隔开.
</span><span> 32</span><span> * @author zhaoyingnan 2015-10-16 17:33
</span><span> 33</span><span> * @param string $sPattern 匹配模式
</span><span> 34</span><span> * @return-Array
</span><span> 35</span><span> *</span><span>*/</span><span> 36</span><span>öffentliche</span><span>Funktionstasten</span>(<span>$sPattern</span> = '*'<span>)
</span><span> 37</span><span> {
</span><span> 38</span><span>//</span><span>echo $sPattern;</span><span> 39</span><span>return</span> self::<span>$redis </span>->keys(<span>$sPattern</span><span>);
</span><span>40</span><span> }
</span><span>41</span><span>42</span><span>/*</span><span>*
</span><span> 43</span><span> * 返回key是否存在.</span><span> 44</span><span> * @author zhaoyingnan 2015-10-16 17:40
</span><span> 45</span><span> * @param string $sKey Schlüssel, der erkannt werden soll
</span><span> 46</span><span> * @return bool
</span><span> 47</span><span> *</span><span>*/</span><span> 48</span><span>öffentliche</span><span>Funktion</span> existiert(<span>$sKey</span><span>)
</span><span> 49</span><span> {
</span><span> 50</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 51</span><span>return</span> self::<span>$redis</span>->exists(<span>$sKey</span><span>);
</span><span> 52</span><span> }
</span><span> 53</span><span> 54</span><span>/*</span><span>*
</span><span> 55</span><span> * Legen Sie die Ablaufzeit des Schlüssels fest. Wenn der Schlüssel abgelaufen ist, wird er automatisch gelöscht. Ein Schlüssel mit einer festgelegten Ablaufzeit wird als flüchtig bezeichnet.
</span><span> 56</span><span> * Sie können die Ablaufzeit des Schlüssels erneut aktualisieren, bevor er abläuft, oder Sie können den Befehl PERSIST verwenden, um die Ablaufzeit des Schlüssels zu löschen.
</span><span> 57</span><span> * @author zhaoyingnan 2015-10-16 17:46
</span><span> 58</span><span> * @param string $sKey Schlüssel
</span><span> 59</span><span> * @param int $iSecond Lebensdauer (Sekunden)
</span><span> 60</span><span> * @return bool
</span><span> 61</span><span> *</span><span>*/</span><span> 62</span><span>öffentliche</span><span>Funktion</span> ablaufen(<span>$sKey</span>, <span>$iSecond</span> = 60<span>)
</span><span> 63</span><span> {
</span><span> 64</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 65</span><span>return</span> self::<span>$redis</span>->expire(<span>$sKey</span>, <span>$iSecond</span> <span>);
</span><span> 66</span><span> }
</span><span>67</span><span>68</span><span>/*</span><span>*
</span><span> 69</span><span> * Dieser Befehl ähnelt dem EXPIRE-Befehl, legt jedoch die Überlebenszeit des Schlüssels in Millisekunden fest, nicht in Sekunden wie der EXPIRE-Befehl.
</span><span> 70</span><span> * @author zhaoyingnan 2015-10-19 16:00
</span><span> 71</span><span> * @param string $sKey Schlüssel
</span><span> 72</span><span> * @param int $iSecond Lebensdauer (Sekunden)
</span><span> 73</span><span> * @return bool
</span><span> 74</span><span> *</span><span>*/</span><span> 75</span><span>public</span><span>function</span> pexpire(<span>$sKey</span>, <span>$iMilliseconds</span> = 60000<span>)
</span><span> 76</span><span> {
</span><span> 77</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 78</span><span>return</span> self::<span>$redis</span>->pexpire(<span>$sKey</span>, <span>$iMilliseconds</span> <span>);
</span><span> 79</span><span> }
</span><span>80</span><span>81</span><span>/*</span><span>*
</span><span> 82</span><span> * Die Funktion von EXPIREAT ist ähnlich wie EXPIRE, beide werden verwendet, um die Überlebenszeit für den Schlüssel festzulegen. Der Unterschied besteht darin, dass der vom Befehl EXPIREAT akzeptierte Zeitparameter der UNIX-Zeitstempel ist.
</span><span> 83</span><span> * @author zhaoyingnan 2015-10-16 18:03
</span><span> 84</span><span> * @param string $sKey Schlüssel
</span><span> 85</span><span> * @param int $iUnixtimestamp UNIX-Zeitstempel (Sekunden)
</span><span> 86</span><span> * @return bool
</span><span> 87</span><span> *</span><span>*/</span><span> 88</span><span>öffentliche</span><span>Funktion</span> Expireat(<span>$sKey</span>, <span>$iUnixtimestamp</span><span>)
</span><span> 89</span><span> {
</span><span> 90</span><span>if</span>(!<span>$sKey</span> || !<span>$iUnixtimestamp</span>)<span>return</span><span>FALSE </span><span>;
</span><span> 91</span><span>return</span> self::<span>$redis</span>->expireat(<span>$sKey</span>, <span>$iUnixtimestamp</span> <span>);
</span><span> 92</span><span> }
</span><span>93</span><span>94</span><span>/*</span><span>*
</span><span> 95</span><span> * PEXPIREAT Dieser Befehl ähnelt dem EXPIREAT-Befehl, setzt jedoch den Unix-Zeitstempel für den Ablauf des Schlüssels in Millisekunden statt in Sekunden wie EXPIREAT.
</span><span> 96</span><span> * Die Funktion von EXPIREAT ähnelt der von EXPIRE, beide werden verwendet, um die Überlebenszeit für den Schlüssel festzulegen. Der Unterschied besteht darin, dass der vom Befehl EXPIREAT akzeptierte Zeitparameter der UNIX-Zeitstempel ist.</span><span> 97</span><span> * @author zhaoyingnan 2015-10-16 18:03
</span><span> 98</span><span> * @param string $sKey Schlüssel
</span><span> 99</span><span> * @param int $iMilliseconds UNIX-Zeitstempel (Millisekunden)
</span><span> 100</span><span> * @return bool
</span><span> 101</span><span> *</span><span>*/</span><span> 102</span><span>public</span><span>function</span> pexpireat(<span>$sKey</span>, <span>$iMilliseconds</span><span>)
</span><span> 103</span><span> {
</span><span> 104</span><span>if</span>(!<span>$sKey</span> || !<span>$iMilliseconds</span>)<span>return</span><span>FALSE </span><span>;
</span><span> 105</span><span>return</span> self::<span>$redis</span>->pexpireat(<span>$sKey</span>, <span>$iMilliseconds</span> <span>);
</span><span> 106</span><span> }
</span><span> 107</span><span> 108</span><span>/*</span><span>*
</span><span> 109</span><span> * Gibt die verbleibende Überlebenszeit (TTL, Time to Live) des angegebenen Schlüssels in Sekunden zurück.
</span><span> 110</span><span> * @author zhaoyingnan 2015-10-16 17:52
</span><span> 111</span><span> * @param string $sKey Schlüssel
</span><span> 112</span><span> * @return int Wenn der Schlüssel nicht existiert, geben Sie -2 zurück. Wenn der Schlüssel existiert, aber keine verbleibende Lebensdauer festgelegt ist, wird -1 zurückgegeben. Andernfalls wird die verbleibende Lebensdauer des Schlüssels in Sekunden zurückgegeben.
</span><span> 113</span><span> *</span><span>*/</span><span> 114</span><span>public</span><span>function</span> ttl(<span>$sKey</span><span>)
</span><span> 115</span><span> {
</span><span> 116</span><span>if</span>(!<span>$sKey</span>)<span>return</span> -2<span>;
</span><span> 117</span><span>return</span> self::<span>$redis</span>->ttl(<span>$sKey</span><span>);
</span><span> 118</span><span> }
</span><span> 119</span><span> 120</span><span>/*</span><span>*
</span><span> 121</span><span> * Dieser Befehl ähnelt dem TTL-Befehl, gibt jedoch die verbleibende Lebensdauer des Schlüssels in Millisekunden zurück und nicht in Sekunden wie der TTL-Befehl.
</span><span> 122</span><span> * @author zhaoyingnan 2015-10-19 16:06
</span><span> 123</span><span> * @param string $sKey Schlüssel
</span><span> 124</span><span> * @return int Wenn der Schlüssel nicht existiert, geben Sie -2 zurück. Wenn der Schlüssel existiert, aber keine verbleibende Lebensdauer festgelegt ist, wird -1 zurückgegeben. Andernfalls wird die verbleibende Lebensdauer des Schlüssels in Sekunden zurückgegeben.
</span><span> 125</span><span> *</span><span>*/</span><span> 126</span><span>public</span><span>function</span> pttl(<span>$sKey</span><span>)
</span><span> 127</span><span> {
</span><span> 128</span><span>if</span>(!<span>$sKey</span>)<span>return</span> -2<span>;
</span><span> 129</span><span>return</span> self::<span>$redis</span>->pttl(<span>$sKey</span><span>);
</span><span> 130</span><span> }
</span><span> 131</span><span> 132</span><span>/*</span><span>*
</span><span> 133</span><span> * Übertragen Sie den Schlüssel atomar von der aktuellen Instanz in die angegebene Datenbank der Zielinstanz. Sobald die Übertragung erfolgreich ist, wird der Schlüssel garantiert auf der Zielinstanz angezeigt Der Schlüssel der aktuellen Instanz wird gelöscht.
</span><span> 134</span><span> * Dieser Befehl ist eine atomare Operation. Wenn er ausgeführt wird, blockiert er die beiden Migrationsinstanzen, bis eines der folgenden Ergebnisse eintritt: Migration erfolgreich, Migration fehlgeschlagen oder Zeitüberschreitung.
</span><span> 135</span><span> * @author zhaoyingnan 2015-10-16 18:24
</span><span> 136</span><span> * @param string $sHost-Ziel-IP
</span><span> 137</span><span> * @param int $iPort-Port
</span><span> 138</span><span> * @param string $sKey Der zu bedienende Schlüssel
</span><span> 139</span><span> * @param int $iDb Die Nummer der Datenbank der Zielinstanz
</span><span> 140</span><span> * @param int $iTimeout Der Timeout-Parameter liegt im Millisekundenformat vor und gibt das maximale Intervall zwischen der Kommunikation zwischen der aktuellen Instanz und der Zielinstanz an. Dies bedeutet, dass der Vorgang nicht innerhalb der Timeout-Millisekunden abgeschlossen werden muss, es bedeutet lediglich, dass die Zeit für die Datenübertragung diese Timeout-Zahl nicht überschreiten darf.</span><span> 141</span><span> * @return bool Hinweis: Wenn der angegebene Schlüssel in der angegebenen Datenbank der Zielinstanz vorhanden ist, wird FALS zurückgegeben. Der Schlüssel in der aktuellen Instanz wurde nicht gelöscht und auch nicht gelöscht Wenn er in die Zielinstanz verschoben wurde, ist der Schlüssel auf der Zielinstanz immer noch der Originalschlüssel
</span><span> 142</span><span> *</span><span>*/</span><span> 143</span><span>öffentliche</span><span>Funktion</span> migrate(<span>$sHost</span>, <span>$iPort</span>, <span>$sKey</span>, <span>$iDb</span>, <span>$iTimeout</span><span>)
</span><span> 144</span><span> {
</span><span> 145</span><span>if</span>(!<span>$sHost</span> || !<span>$iPort</span> || !<span>$sKey</span> | |. !<span>$iDb</span> ||. !<span>$iTimeout</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 146</span><span>return</span> self::<span>$redis</span>->migrate(<span>$sHost</span>, <span>$iPort</span> , <span>$sKey</span>, <span>$iDb</span>, <span>$iTimeout</span><span>);
</span><span> 147</span><span> }
</span><span> 148</span><span> 149</span><span>/*</span><span>*
</span><span> 150</span><span> * Verschieben Sie den Schlüssel der aktuellen Datenbank in die angegebene Datenbank-Datenbank.
</span><span> 151</span><span> * Wenn die aktuelle Datenbank (Quelldatenbank) und die angegebene Datenbank (Zieldatenbank) einen bestimmten Schlüssel mit demselben Namen haben oder der Schlüssel in der aktuellen Datenbank nicht vorhanden ist, dann hat MOVE keine Wirkung.
</span><span> 152</span><span> * @author zhaoyingnan 2015-10-19 15:42
</span><span> 153</span><span> * @param string $sKey Schlüssel
</span><span> 154</span><span> * @param int $iDb Zur angegebenen Datenbank-ID verschieben
</span><span> 155</span><span> * @return bool
</span><span> 156</span><span> *</span><span>*/</span><span> 157</span><span>public</span><span>function</span> move(<span>$sKey</span>, <span>$iDb</span><span>)
</span><span> 158</span><span> {
</span><span> 159</span><span>if</span>(!<span>$sKey</span> || !<span>$iDb</span>)<span>return</span><span>FALSE </span><span>;
</span><span> 160</span><span>return</span> self::<span>$redis</span>->move(<span>$sKey</span>, <span>$iDb</span> <span>);
</span><span> 161</span><span> }
</span><span> 162</span><span> 163</span><span>/*</span><span>*
</span><span> 164</span><span> * Entfernen Sie die Lebensdauer des angegebenen Schlüssels und konvertieren Sie diesen Schlüssel von „volatil“ (Schlüssel mit Lebensdauer) in „persistent“ (Schlüssel ohne Lebensdauer), einem Schlüssel, der niemals abläuft) .
</span><span> 165</span><span> * @author zhaoyingnan 2015-10-19 15:55
</span><span> 166</span><span> * @param string $sKey Schlüssel
</span><span> 167</span><span> * @return bool Wenn die Überlebenszeit erfolgreich entfernt wurde, geben Sie 1 zurück. Wenn der Schlüssel nicht existiert oder für den Schlüssel keine Überlebenszeit festgelegt ist, geben Sie 0 zurück
</span><span> 168</span><span> *</span><span>*/</span><span> 169</span><span>public</span><span>function</span> persist(<span>$sKey</span><span>)
</span><span> 170</span><span> {
</span><span> 171</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 172</span><span>return</span> self::<span>$redis</span>->persist(<span>$sKey</span><span>);
</span><span> 173</span><span> }
</span><span> 174</span><span> 175</span><span>/*</span><span>*
</span><span> 176</span><span> * Gibt einen zufälligen Schlüssel aus der aktuellen Datenbank zurück.
</span><span> 177</span><span> * @author zhaoyingnan 2015-10-19 16:08
</span><span> 178</span><span> * @return string Wenn die Datenbank keinen Schlüssel hat, geben Sie Null zurück, andernfalls geben Sie einen zufälligen Schlüssel zurück.    
</span><span> 179</span><span> *</span><span>*/</span><span> 180</span><span>öffentliche</span><span>Funktion</span><span> Zufallsschlüssel ()
</span><span> 181</span><span> {
</span><span> 182</span><span>return</span> self::<span>$redis</span>-><span>randomkey();
</span><span> 183</span><span> }
</span><span> 184</span><span> 185</span><span>/*</span><span>*
</span><span> 186</span><span> * Schlüssel in Newkey umbenennen. Wenn Schlüssel mit Newkey identisch ist, wird ein Fehler zurückgegeben. Wenn newkey bereits existiert, wird der Wert überschrieben.</span><span> 187</span><span> * @author zhaoyingnan 2015-10-19 16:12
</span><span> 188</span><span> * @param string $sKey Schlüssel
</span><span> 189</span><span> * @param string $sNewKey Der Schlüsselwert nach dem Umbenennen
</span><span> 190</span><span> * @return bool
</span><span> 191</span><span> *</span><span>*/</span><span> 192</span><span>öffentliche</span><span>Funktion</span><span>umbenennen </span>(<span>$sKey</span>, <span>$sNewKey</span><span>)
</span><span> 193</span><span> {
</span><span> 194</span><span>if</span>(!<span>$sKey</span> || !<span>$sNewKey</span>)<span>return</span><span>FALSE </span><span>;
</span><span> 195</span><span>return</span> self::<span>$redis</span>-><span>rename</span>(<span>$sKey</span>, <span>$sNewKey</span><span>);
</span><span> 196</span><span> }
</span><span> 197</span><span> 198</span><span>/*</span><span>*
</span><span> 199</span><span> * Schlüssel nur dann in Newkey umbenennen, wenn Newkey nicht existiert. Wenn der Schlüssel nicht vorhanden ist, wird ein Fehler zurückgegeben.
</span><span> 200</span><span> * @author zhaoyingnan 2015-10-19 16:16
</span><span> 201</span><span> * @param string $sKey Schlüssel
</span><span> 202</span><span> * @param string $sNewKey Der Schlüsselwert nach dem Umbenennen
</span><span> 203</span><span> * @return bool
</span><span> 204</span><span> *</span><span>*/</span><span> 205</span><span>public</span><span>function</span> rebenenx(<span>$sKey</span>, <span>$sNewKey</span><span>)
</span><span> 206</span><span> {
</span><span> 207</span><span>if</span>(!<span>$sKey</span> || !<span>$sNewKey</span>)<span>return</span><span>FALSE </span><span>;
</span><span> 208</span><span>return</span> self::<span>$redis</span>->renamenx(<span>$sKey</span>, <span>$sNewKey</span> <span>);
</span><span> 209</span><span> }
</span><span>210</span><span>211</span><span>/*</span><span>*
</span><span> 212</span><span> * Gibt den Typ des im Schlüssel gespeicherten Werts zurück.
</span><span> 213</span><span> * @author zhaoyingnan 2015-10-19 16:25
</span><span> 214</span><span> * @param string $sKey Schlüssel
</span><span> 215</span><span> * @return string none (Schlüssel existiert nicht) string (string) list (list) set (set) zset (ordered set) hash (hash table)
</span><span> 216</span><span> *</span><span>*/</span><span> 217</span><span>public</span><span>function</span> type(<span>$sKey</span><span>)
</span><span> 218</span><span> {
</span><span> 219</span><span>return</span> self::<span>$redis</span>->type(<span>$sKey</span><span>);
</span><span> 220</span><span> }
</span><span> 221</span><span> 222</span><span>/*</span><span>******************** string *** ** ***************</span><span>*/</span><span> 223</span><span> 224</span><span>/*</span> <span>*
</span><span> 225</span><span> * Übereinstimmung von Schlüssel und Wert. Wenn der Schlüssel bereits vorhanden ist, wird er unabhängig von seinem Typ überschrieben.
</span><span> 226</span><span> * @author zhaoyingnan 2015-10-19 16:35
</span><span> 227</span><span> * @param string $sKey Schlüssel
</span><span> 228</span><span> * @param string $sValue Schlüssel entsprechender Wert
</span><span> 229</span><span> * @return bool
</span><span> 230</span><span> *</span><span>*/</span><span> 231</span><span>public</span><span>function</span> set(<span>$sKey</span>, <span>$sValue</span><span>)
</span><span> 232</span><span> {
</span><span> 233</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 234</span><span>return</span> self::<span>$redis</span>->set(<span>$sKey</span>, <span>$sValue</span> <span>);
</span><span> 235</span><span> }
</span><span>236</span><span>237</span><span>/*</span><span>*
</span><span> 238</span><span> * Legen Sie den Schlüssel fest, der dem Zeichenfolgenwert entspricht, und stellen Sie den Schlüssel auf Timeout und Ablauf nach den angegebenen Sekunden ein.</span><span> 239</span><span> * @author zhaoyingnan 2015-11-03 11:25
</span><span> 240</span><span> * @param string $sKey Der zu bedienende Schlüssel
</span><span> 241</span><span> * @param int $iSecond Lebenszyklus (Sekunden)
</span><span> 242</span><span> * @param string $sValue Schlüssel entsprechender Wert
</span><span> 243</span><span> * @return bool
</span><span> 244</span><span> *</span><span>*/</span><span> 245</span><span>public</span><span>function</span> setex(<span>$sKey</span>, <span>$iSecond</span>, <span>$sValue</span><span>)
</span><span> 246</span><span> {
</span><span> 247</span><span>if</span>(!<span>$sKey</span> || !<span>$sValue</span>)<span>return</span><span>FALSE </span><span>;
</span><span> 248</span><span>$iSecond</span> = <span>$iSecond</span> ? <span>abs</span>((<span>intval</span>(<span>$iSecond </span>))) : 30<span>;
</span><span> 249</span><span>return</span> self::<span>$redis</span>->setex(<span>$sKey</span>, <span>$iSecond</span> , <span>$sValue</span><span>);
</span><span>250</span><span> }
</span><span>251</span><span>252</span><span>/*</span><span>*
</span><span> 253</span><span> * Legen Sie den Schlüssel fest, der dem Zeichenfolgenwert entspricht, und stellen Sie den Schlüssel auf Timeout und Ablauf nach der angegebenen Millisekundenzeit ein.
</span><span> 254</span><span> * @author zhaoyingnan 2015-11-03 11:25
</span><span> 255</span><span> * @param string $sKey Der zu bedienende Schlüssel
</span><span> 256</span><span> * @param int $iMillSecond Lebenszyklus (Millisekunden)
</span><span> 257</span><span> * @param string $sValue Schlüssel entsprechender Wert
</span><span> 258</span><span> * @return bool
</span><span> 259</span><span> *</span><span>*/</span><span> 260</span><span>public</span><span>function</span> psetex(<span>$sKey</span>, <span>$iMilliseconds</span> , <span>$sValue</span><span>)
</span><span> 261</span><span> {
</span><span> 262</span><span>if</span>(!<span>$sKey</span> || !<span>$sValue</span>)<span>return</span><span>FALSE </span><span>;
</span><span> 263</span><span>$iMilliseconds</span> = <span>$iMilliseconds</span> ? <span>abs</span>((<span>intval</span>(<span>$iMilliseconds </span>))) : 30<span>;
</span><span> 264</span><span>return</span> self::<span>$redis</span>->psetex(<span>$sKey</span>, <span>$iMilliseconds</span> , <span>$sValue</span><span>);
</span><span> 265</span><span> }
</span><span>266</span><span>267</span><span>/*</span><span>*
</span><span> 268</span><span> * Ordnen Sie den Schlüssel automatisch dem Wert zu und geben Sie den Wert zurück, der dem Originalschlüssel entspricht. Wenn der Schlüssel vorhanden ist, der entsprechende Wert jedoch keine Zeichenfolge ist, wird ein Fehler zurückgegeben.
</span><span> 269</span><span> * @author zhaoyingnan 2015-10-19 18:10
</span><span> 270</span><span> * @param string $sKey Schlüssel
</span><span> 271</span><span> * @param string $sValue Der neue Wertsatz
</span><span> 272</span><span> * @return string
</span><span> 273</span><span> *</span><span>*/</span><span> 274</span><span>public</span><span>function</span> getset(<span>$sKey</span>, <span>$sValue</span><span>)
</span><span> 275</span><span> {
</span><span> 276</span><span>if</span>(!<span>$sKey</span>)<span>return</span> ''<span>;
</span><span> 277</span><span>return</span> self::<span>$redis</span>->getset(<span>$sKey</span>, <span>$sValue</span> <span>);
</span><span> 278</span><span> }
</span><span>279</span><span>280</span><span>/*</span><span>*
</span><span> 281</span><span> * Entsprechen den angegebenen Schlüsseln ihren entsprechenden Werten. MSET ersetzt den vorhandenen Wert durch den neuen Wert, genau wie der gewöhnliche SET-Befehl.
</span><span> 282</span><span> * Wenn Sie bestehende Werte nicht überschreiben möchten, sehen Sie sich bitte den Befehl MSETNX an.
</span><span> 283</span><span> * MSET ist atomar, daher werden alle angegebenen Schlüssel gleichzeitig festgelegt. Für den Client ist es unmöglich zu erkennen, dass einige Schlüssel aktualisiert werden, während andere unverändert bleiben.
</span><span> 284</span><span> * @author zhaoyingnan 2015-11-03 11:04
</span><span> 285</span><span> * @param array $arArray Das festzulegende assoziative Array
</span><span> 286</span><span> * @return bool
</span><span> 287</span><span> *</span><span>*/</span><span> 288</span><span>public</span><span>function</span> mset(<span>$arArray</span> = <span>array</span><span>())
</span><span> 289</span><span> {
</span><span> 290</span><span>if</span>(!<span>$arArray</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 291</span><span>return</span> self::<span>$redis</span>->mset(<span>$arArray</span><span>);
</span><span> 292</span><span> }
</span><span>293</span><span>294</span><span>/*</span><span>*
</span><span> 295</span><span> * Entsprechen den angegebenen Schlüsseln ihren entsprechenden Werten.
</span><span> 296</span><span> * Solange bereits ein Schlüssel vorhanden ist, führt MSETNX keinen einzigen Vorgang aus.</span><span> 297</span><span> * Aufgrund dieser Funktion kann MSETNX erreichen, dass entweder alle Vorgänge erfolgreich sind oder keine ausgeführt wird, was verwendet werden kann, um verschiedene Schlüssel festzulegen, um ein eindeutiges Objekt verschiedener Felder darzustellen.
</span><span> 298</span><span> * MSETNX ist atomar, daher werden alle angegebenen Schlüssel gleichzeitig festgelegt. Für den Client ist es unmöglich zu erkennen, dass einige Schlüssel aktualisiert werden, während andere unverändert bleiben.
</span><span> 299</span><span> * @author zhaoyingnan 2015-11-03 11:11
</span><span> 300</span><span> * @param array $arArray Das festzulegende assoziative Array
</span><span> 301</span><span> * @return bool TRUE Alle Schlüssel sind gesetzt, FALSE Es sind keine Schlüssel gesetzt (mindestens ein Schlüssel existiert)
</span><span> 302</span><span> *</span><span>*/</span><span> 303</span><span>public</span><span>function</span> msetnx(<span>$arArray</span> = <span>array</span><span>())
</span><span>304</span><span> {
</span><span> 305</span><span>if</span>(!<span>$arArray</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 306</span><span>return</span> self::<span>$redis</span>->msetnx(<span>$arArray</span><span>);
</span><span> 307</span><span> }
</span><span>308</span><span>309</span><span>/*</span><span>*
</span><span> 310</span><span> * Wenn der Schlüssel nicht vorhanden ist, legen Sie den dem Schlüssel entsprechenden Zeichenfolgewert fest.
</span><span> 311</span><span> * In diesem Fall ist der Befehl derselbe wie SET. Wenn der Schlüssel bereits vorhanden ist, wird kein Vorgang ausgeführt.
</span><span> 312</span><span> * SETNX ist „SET, wenn nicht vorhanden“.
</span><span> 313</span><span> * @author zhaoyingnan 2015-11-03 11:49
</span><span> 314</span><span> * @param string $sKey Schlüssel
</span><span> 315</span><span> * @param string $sValue-Wert
</span><span> 316</span><span> * @return bool TRUE-Taste ist gesetzt, FALSE-Taste ist nicht gesetzt
</span><span> 317</span><span> *</span><span>*/</span><span> 318</span><span>public</span><span>function</span> setnx(<span>$sKey</span>, <span>$sValue</span><span>)
</span><span> 319</span><span> {
</span><span> 320</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 321</span><span>return</span> self::<span>$redis</span>->setnx(<span>$sKey</span>, <span>$sValue</span> <span>);
</span><span> 322</span><span> }
</span><span>323</span><span>324</span><span>/*</span><span>*
</span><span> 325</span><span> * Gibt den Wert des Schlüssels zurück. Wenn der Schlüssel nicht existiert, wird der Sonderwert Null zurückgegeben. Wenn der Wert des Schlüssels kein String ist, wird ein Fehler zurückgegeben, da GET nur Werte vom Typ String verarbeitet.
</span><span> 326</span><span> * @author zhaoyingnan 2015-10-19 17:57
</span><span> 327</span><span> * @param string $sKey Schlüssel
</span><span> 328</span><span> * @return string
</span><span> 329</span><span> *</span><span>*/</span><span> 330</span><span>public</span><span>function</span> get(<span>$sKey</span><span>)
</span><span> 331</span><span> {
</span><span> 332</span><span>if</span>(!<span>$sKey</span>)<span>return</span> ''<span>;
</span><span> 333</span><span>return</span> self::<span>$redis</span>->get(<span>$sKey</span><span>);
</span><span> 334</span><span> }
</span><span>335</span><span>336</span><span>/*</span><span>*
</span><span> 337</span><span> * Gibt den Wert aller angegebenen Schlüssel zurück. Für jeden Schlüssel, der keiner Zeichenfolge entspricht oder nicht existiert, wird der Sonderwert Null zurückgegeben. Aus diesem Grund schlägt der Vorgang nie fehl.
</span><span> 338</span><span> * @author zhaoyingnan 2015-11-03 10:55
</span><span> 339</span><span> * @param array $arKey Array der abzurufenden Schlüssel
</span><span> 340</span><span> * @return array redis gibt ein Array mit der Nummer als <strong> index </strong> zurück. Was hier zurückgegeben wird, ist ein assoziatives Array
</span><span> 341</span><span> *</span><span>*/</span><span> 342</span><span>public</span><span>function</span> mget(<span>$arKey</span> = <span>array</span><span>())
</span><span> 343</span><span> {
</span><span> 344</span><span>if</span>(!<span>$arKey</span>)<span>return</span><span>array</span><span>();
</span><span> 345</span><span>$arResult</span> = self::<span>$redis</span>->mget(<span>$arKey</span><span>);
</span><span> 346</span><span>return</span><span>array_combine</span>(<span>$arKey</span>, <span>$arResult</span><span>);
</span><span> 347</span><span> }
</span><span>348</span><span>349</span><span>/*</span><span>*
</span><span> 350</span><span> * Wenn der Schlüssel bereits vorhanden ist und der Wert eine Zeichenfolge ist, hängt dieser Befehl den Wert an das Ende des ursprünglichen Werts (Wert) an.
</span><span> 351</span><span> * Wenn der Schlüssel nicht vorhanden ist, wird zunächst ein leerer Zeichenfolgenschlüssel erstellt und dann die Anhängeoperation ausgeführt. In diesem Fall ähnelt APPEND der SET-Operation.</span><span> 352</span><span> * @author zhaoyingnan 2015-10-19 16:34
</span><span> 353</span><span> * @param string $sKey Schlüssel
</span><span> 354</span><span> * @param string $sValue angehängter Wert
</span><span> 355</span><span> * @return int
</span><span> 356</span><span> *</span><span>*/</span><span> 357</span><span>public</span><span>function</span> append(<span>$sKey</span>, <span>$sValue</span><span>)
</span><span> 358</span><span> {
</span><span> 359</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 360</span><span>return</span> self::<span>$redis</span>->append(<span>$sKey</span>, <span>$sValue</span> <span>);
</span><span> 361</span><span> }
</span><span>362</span><span>363</span><span>/*</span><span>*
</span><span> 364</span><span> * Addiere 1 zur Zahl, die dem Schlüssel entspricht. Wenn der Schlüssel nicht vorhanden ist, wird der dem Schlüssel entsprechende Wert vor der Operation auf 0 gesetzt.
</span><span> 365</span><span> * Wenn der Schlüssel einen Wert vom falschen Typ hat oder eine Zeichenfolge ist, die nicht als Zahl dargestellt werden kann, wird ein Fehler zurückgegeben.
</span><span> 366</span><span> * Dieser Vorgang unterstützt bis zu 64-Bit-Ganzzahlen mit Vorzeichen.
</span><span> 367</span><span> * @author zhaoyingnan 2015-10-19 17:44
</span><span> 368</span><span> * @param string $sKey Schlüssel
</span><span> 369</span><span> * @return string
</span><span> 370</span><span> *</span><span>*/</span><span> 371</span><span>public</span><span>function</span> incr(<span>$sKey</span><span>)
</span><span> 372</span><span> {
</span><span> 373</span><span>if</span>(!<span>$sKey</span>)<span>return</span> ''<span>;
</span><span> 374</span><span>return</span> self::<span>$redis</span>->incr(<span>$sKey</span><span>);
</span><span> 375</span><span> }
</span><span>376</span><span>377</span><span>/*</span><span>*
</span><span> 378</span><span> * Dekrement zur Zahl hinzufügen, die dem Schlüssel entspricht. Wenn der Schlüssel nicht vorhanden ist, wird er vor der Operation auf 0 gesetzt.
</span><span> 379</span><span> * Wenn der Werttyp des Schlüssels falsch ist oder es sich um eine Zeichenfolge handelt, die nicht als Zahl dargestellt werden kann, wird ein Fehler zurückgegeben. Dieser Vorgang unterstützt bis zu 64-Bit-positive Zahlen mit Vorzeichen.
</span><span> 380</span><span> * @author zhaoyingnan 2015-10-19 17:44
</span><span> 381</span><span> * @param string $sKey Schlüssel
</span><span> 382</span><span> * @param int $iInkrementieren Sie den Schrittwert
</span><span> 383</span><span> * @return string
</span><span> 384</span><span> *</span><span>*/</span><span> 385</span><span>public</span><span>function</span> incrby(<span>$sKey</span>, <span>$iInkrement</span><span>)
</span><span> 386</span><span> {
</span><span> 387</span><span>if</span>(!<span>$sKey</span> || !<span>$iIncrement</span>)<span>return</span> ''<span>;
</span><span> 388</span><span>return</span> self::<span>$redis</span>->incrby(<span>$sKey</span>, <span>$iIncrement</span> <span>);
</span><span> 389</span><span> }
</span><span> 390</span><span> 391</span><span>/*</span><span>*
</span><span> 392</span><span> * Dekrement zur Zahl hinzufügen, die dem Schlüssel entspricht. Wenn der Schlüssel nicht vorhanden ist, wird er vor der Operation auf 0 gesetzt.
</span><span> 393</span><span> * Wenn der Werttyp des Schlüssels falsch ist oder es sich um eine Zeichenfolge handelt, die nicht als Zahl dargestellt werden kann, wird ein Fehler zurückgegeben. Dieser Vorgang unterstützt bis zu 64-Bit-positive Zahlen mit Vorzeichen.
</span><span> 394</span><span> * @author zhaoyingnan 2015-10-19 17:44
</span><span> 395</span><span> * @param string $sKey Schlüssel
</span><span> 396</span><span> * @param fload $floatIncrement Schrittwert
</span><span> 397</span><span> * @return string
</span><span> 398</span><span> *</span><span>*/</span><span> 399</span><span>public</span><span>function</span> incrbyfloat(<span>$sKey</span>, <span>$floatIncrement</span><span>)
</span><span> 400</span><span> {
</span><span> 401</span><span>if</span>(!<span>$sKey</span> || !<span>$floatIncrement</span>)<span>return</span> ''<span>;
</span><span> 402</span><span>return</span> self::<span>$redis</span>->incrbyfloat(<span>$sKey</span>, <span>$floatIncrement</span> <span>);
</span><span> 403</span><span> }
</span><span> 404</span><span> 405</span><span>/*</span><span>*
</span><span> 406</span><span> * Subtrahieren Sie 1 von der Zahl, die dem Schlüssel entspricht. Wenn der Schlüssel nicht vorhanden ist, wird der dem Schlüssel entsprechende Wert vor der Operation auf 0 gesetzt.
</span><span> 407</span><span> * Wenn der Schlüssel einen Wert vom falschen Typ hat oder eine Zeichenfolge ist, die nicht als Zahl dargestellt werden kann, wird ein Fehler zurückgegeben. Dieser Vorgang unterstützt bis zu 64-Bit-Ganzzahlen mit Vorzeichen.</span><span> 408</span><span> * @author zhaoyingnan 2015-10-19 17:44
</span><span> 409</span><span> * @param string $sKey Schlüssel
</span><span> 410</span><span> * @return string
</span><span> 411</span><span> *</span><span>*/</span><span> 412</span><span>public</span><span>function</span> decr(<span>$sKey</span><span>)
</span><span> 413</span><span> {
</span><span> 414</span><span>if</span>(!<span>$sKey</span>)<span>return</span> ''<span>;
</span><span> 415</span><span>return</span> self::<span>$redis</span>->decr(<span>$sKey</span><span>);
</span><span> 416</span><span> }
</span><span> 417</span><span> 418</span><span>/*</span><span>*
</span><span> 419</span><span> * Dekrementieren Sie die der Taste entsprechende Zahl durch Dekrementieren. Wenn der Schlüssel nicht vorhanden ist, wird er vor der Operation auf 0 gesetzt.
</span><span> 420</span><span> * Wenn der Werttyp des Schlüssels falsch ist oder es sich um eine Zeichenfolge handelt, die nicht als Zahl dargestellt werden kann, wird ein Fehler zurückgegeben. Dieser Vorgang unterstützt bis zu 64-Bit-positive Zahlen mit Vorzeichen.
</span><span> 421</span><span> * @author zhaoyingnan 2015-10-19 17:44
</span><span> 422</span><span> * @param string $sKey Schlüssel
</span><span> 423</span><span> * @param int $iInkrementieren Sie den Schrittwert
</span><span> 424</span><span> * @return string
</span><span> 425</span><span> *</span><span>*/</span><span> 426</span><span>public</span><span>function</span> decrby(<span>$sKey</span>, <span>$iInkrement</span><span>)
</span><span> 427</span><span> {
</span><span> 428</span><span>if</span>(!<span>$sKey</span> || !<span>$iIncrement</span>)<span>return</span> ''<span>;
</span><span> 429</span><span>return</span> self::<span>$redis</span>->decrby(<span>$sKey</span>, <span>$iIncrement</span> <span>);
</span><span> 430</span><span> }
</span><span> 431</span><span> 432</span><span>/*</span><span>*
</span><span> 433</span><span> * Dieser Befehl wurde in GETRANGE geändert und heißt in Redis-Versionen vor 2.0 SUBSTR. 
</span><span> 434</span><span> * Gibt den Teilstring des Stringwerts zurück, der dem Schlüssel entspricht. Dieser Teilstring wird durch die Start- und Endverschiebungen bestimmt (beide liegen innerhalb des Strings).
</span><span> 435</span><span> * Sie können eine negative Verschiebung verwenden, um den Index beginnend am Ende der Zeichenfolge darzustellen. Also ist -1 das letzte Zeichen, -2 das vorletzte Zeichen und so weiter.
</span><span> 436</span><span> * Wenn diese Funktion Anfragen außerhalb des Bereichs verarbeitet, begrenzt sie die Ergebnisse auf Zeichenfolgen.
</span><span> 437</span><span> * @author zhaoyingnan 2015-10-19 18:04
</span><span> 438</span><span> * @param string $sKey Schlüssel
</span><span> 439</span><span> * @pause int $iStart Startposition
</span><span> 440</span><span> * @pause int $iEnd Endposition
</span><span> 441</span><span> * @return string
</span><span> 442</span><span> *</span><span>*/</span><span> 443</span><span>public</span><span>function</span> getrange(<span>$sKey</span>, <span>$iStart</span> = 0, <span>$iEnd</span> = -1<span>)
</span><span> 444</span><span> {
</span><span> 445</span><span>if</span>(!<span>$sKey</span>)<span>return</span> ''<span>;
</span><span> 446</span><span>return</span> self::<span>$redis</span>->getrange(<span>$sKey</span>, <span>$iStart</span> , <span>$iEnd</span><span>);
</span><span> 447</span><span> }
</span><span> 448</span><span> 449</span><span>/*</span><span>*
</span><span> 450</span><span> * Gibt die Länge des Zeichenfolgentypwerts des Schlüssels zurück. Wenn der Schlüssel einem Nicht-String-Typ entspricht, wird ein Fehler zurückgegeben.
</span><span> 451</span><span> * @author zhaoyingnan 2015-11-03 11:40
</span><span> 452</span><span> * @param string $sKey
</span><span> 453</span><span> * @return
</span><span> 454</span><span> *</span><span>*/</span><span> 455</span><span>öffentliche</span><span>Funktion</span><span>strlen </span>(<span>$sKey</span><span>)
</span><span> 456</span><span> {
</span><span> 457</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 458</span><span>return</span> self::<span>$redis</span>-><span>strlen</span>(<span>$sKey</span><span> );
</span><span> 459</span><span> }
</span><span> 460</span><span> 461</span><span>/*</span><span>******************** Liste *** *******************</span><span>*/</span><span> 462</span><span> 463</span><span>/*</span> <span>*
</span><span> 464</span><span> * Fügen Sie alle angegebenen Werte in den Kopf der unter Schlüssel gespeicherten Liste ein. Wenn der Schlüssel nicht vorhanden ist, wird vor dem Push-Vorgang eine leere Liste erstellt. 
</span><span> 465</span><span> * Wenn der dem Schlüssel entsprechende Wert keine Liste ist, wird ein Fehler zurückgegeben.
</span><span> 466</span><span> * Sie können einen Befehl verwenden, um mehrere Elemente in die Liste zu verschieben. Fügen Sie einfach mehrere angegebene Parameter am Ende des Befehls hinzu.
</span><span> 467</span><span> * Elemente werden einzeln von ganz links nach ganz rechts in den Kopf der Liste eingefügt.Für dieses Befehlsbeispiel LPUSH mylist a b c lautet die zurückgegebene Liste also c als erstes Element, b als zweites Element und a als drittes Element.
</span><span> 468</span><span> * @author zhaoyingnan 2015-11-03 11:59
</span><span> 469</span><span> * @param string $sKey
</span><span> 470</span><span> * @param array $arValue Array von Werten, die auf den Schlüssel übertragen werden müssen
</span><span> 471</span><span> * @return int Die Länge der Liste nach dem Push-Vorgang.
</span><span> 472</span><span> *</span><span>*/</span><span> 473</span><span>public</span><span>function</span> lpush(<span>$sKey</span>, <span>$arValue</span> = <span>array</span><span>())
</span><span> 474</span><span> {
</span><span> 475</span><span>if</span>(!<span>$sKey</span> || !<span>$arValue</span>)<span>return</span> 0<span> ;
</span><span> 476</span><span>foreach</span>(<span>$arValue</span><span>as</span><span>$val</span><span>)
</span><span> 477</span> self::<span>$redis</span>->lpush(<span>$sKey</span>, <span>$val</span><span>);
</span><span> 478</span><span>return</span> self::llen(<span>$sKey</span><span>);
</span><span> 479</span><span> }
</span><span> 480</span><span> 481</span><span>/*</span><span>*
</span><span> 482</span><span> * Nur wenn der Schlüssel bereits existiert und eine Liste gespeichert ist, fügen Sie einen Wert in den Kopf der Liste unter diesem Schlüssel ein. 
</span><span> 483</span><span> * Im Gegensatz zu LPUSH wird keine Operation ausgeführt, wenn der Schlüssel nicht vorhanden ist.
</span><span> 484</span><span> * @author zhaoyingnan 2015-11-03 13:21
</span><span> 485</span><span> * @param string $sKey
</span><span> 486</span><span> * @param array $arValue Array von Werten, die auf die Taste gedrückt werden sollen
</span><span> 487</span><span> * @return int
</span><span> 488</span><span> *</span><span>*/</span><span> 489</span><span>public</span><span>function</span> lpushx(<span>$sKey</span>, <span>$arValue</span> = <span>array</span><span>())
</span><span> 490</span><span> {
</span><span> 491</span><span>if</span>(!<span>$sKey</span> || !<span>$arValue</span>)<span>return</span> 0<span> ;
</span><span> 492</span><span>foreach</span>(<span>$arValue</span><span>as</span><span>$val</span><span>)
</span><span> 493</span> self::<span>$redis</span>->lpushx(<span>$sKey</span>, <span>$val</span><span>);
</span><span> 494</span><span>return</span> self::llen(<span>$sKey</span><span>);
</span><span> 495</span><span> }
</span><span> 496</span><span> 497</span><span>/*</span><span>*
</span><span> 498</span><span> * Fügen Sie alle angegebenen Werte am Ende der im Schlüssel gespeicherten Liste ein. Wenn der Schlüssel nicht vorhanden ist, wird eine leere Liste erstellt und anschließend der Push-Vorgang ausgeführt. 
</span><span> 499</span><span> * Wenn der Schlüssel nicht als Liste gespeichert wird, wird ein Fehler zurückgegeben.
</span><span> 500</span><span> * Sie können einen Befehl verwenden, um mehrere Elemente in die <strong>Warteschlange</strong> zu stellen. Geben Sie einfach mehrere Parameter nach dem Befehl an.
</span><span> 501</span><span> * Elemente werden nacheinander vom Ende der Liste von links nach rechts eingefügt. Beispielsweise gibt der Befehl RPUSH mylist a b c eine Liste zurück, deren erstes Element a, das zweite Element b und das dritte Element c ist.
</span><span> 502</span><span> * @author zhaoyingnan 2015-11-03 12:15
</span><span> 503</span><span> * @param string $sKey
</span><span> 504</span><span> * @param array $arValue Array von Werten, die auf die Taste gedrückt werden sollen
</span><span> 505</span><span> * @return int Die Länge der Liste nach dem Push-Vorgang.
</span><span> 506</span><span> *</span><span>*/</span><span> 507</span><span>public</span><span>function</span> rpush(<span>$sKey</span>, <span>$arValue</span> = <span>array</span><span>())
</span><span> 508</span><span> {
</span><span> 509</span><span>if</span>(!<span>$sKey</span> || !<span>$arValue</span>)<span>return</span> 0<span> ;
</span><span> 510</span><span>foreach</span>(<span>$arValue</span><span>as</span><span>$val</span><span>)
</span><span> 511</span> self::<span>$redis</span>->lpush(<span>$sKey</span>, <span>$val</span><span>);
</span><span> 512</span><span>return</span> self::llen(<span>$sKey</span><span>);
</span><span> 513</span><span> }
</span><span> 514</span><span> 515</span><span>/*</span><span>*
</span><span> 516</span><span> * Wert value genau dann in das Ende des Listenschlüssels einfügen, wenn der Schlüssel existiert und eine Liste ist. 
</span><span> 517</span><span> * Im Gegensatz zum Befehl RPUSH führt der Befehl RPUSHX nichts aus, wenn der Schlüssel nicht vorhanden ist.
</span><span> 518</span><span> * @author zhaoyingnan 2015-11-03 13:23
</span><span> 519</span><span> * @param string $sKey
</span><span> 520</span><span> * @param array $arValue Array von Werten, die auf die Taste gedrückt werden sollen
</span><span> 521</span><span> * @return int Die Länge der Liste nach dem Push-Vorgang.</span><span> 522</span><span> *</span><span>*/</span><span> 523</span><span>public</span><span>function</span> rpushx(<span>$sKey</span>, <span>$arValue</span> = <span>array</span><span>())
</span><span> 524</span><span> {
</span><span> 525</span><span>if</span>(!<span>$sKey</span> || !<span>$arValue</span>)<span>return</span> 0<span> ;
</span><span> 526</span><span>foreach</span>(<span>$arValue</span><span>as</span><span>$val</span><span>)
</span><span> 527</span> self::<span>$redis</span>->rpushx(<span>$sKey</span>, <span>$val</span><span>);
</span><span> 528</span><span>return</span> self::llen(<span>$sKey</span><span>);
</span><span> 529</span><span> }
</span><span> 530</span><span> 531</span><span>/*</span><span>*
</span><span> 532</span><span> * Gibt die Länge der im Schlüssel gespeicherten Liste zurück. 
</span><span> 533</span><span> * @author zhaoyingnan 2015-11-03 12:12
</span><span> 534</span><span> * @param string $sKey
</span><span> 535</span><span> * @return bool Wenn der Schlüssel nicht existiert, wird er als leere Liste betrachtet und die zurückgegebene Länge ist 0. Wenn der im Schlüssel gespeicherte Wert keine Liste ist, wird ein Fehler zurückgegeben.
</span><span> 536</span><span> *</span><span>*/</span><span> 537</span><span>public</span><span>function</span> llen(<span>$sKey</span><span>)
</span><span> 538</span><span> {
</span><span> 539</span><span>if</span>(!<span>$sKey</span>)<span>return</span> 0<span>;
</span><span> 540</span><span>return</span> self::<span>$redis</span>->llen(<span>$sKey</span><span>);
</span><span> 541</span><span> }
</span><span> 542</span><span> 543</span><span>/*</span><span>*
</span><span> 544</span><span> * Gibt den Wert von <strong>index</strong> Index des Elements in der Liste zurück, das dem Schlüssel entspricht
</span><span> 545</span><span> * Der Index beginnt bei 0<strong>Index</strong>, also bedeutet 0 das erste Element, 1 das zweite Element und so weiter. 
</span><span> 546</span><span> * Negativer <strong>Index </strong> wird verwendet, um das Element ab dem Ende der Liste bei <strong>Index </strong> anzugeben. Bei diesem Ansatz stellt -1 das letzte Element dar, -2 das vorletzte Element und so weiter.
</span><span> 547</span><span> * Wenn der Wert der Schlüsselposition keine Liste ist, wird ein Fehler zurückgegeben.
</span><span> 548</span><span> * @author zhaoyingnan 2015-11-03 13:30
</span><span> 549</span><span> * @param string $sKey
</span><span> 550</span><span> * @param array $index key Der Index in der entsprechenden Liste <strong>Index</strong>
</span><span> 551</span><span> * @return mix
</span><span> 552</span><span> *</span><span>*/</span><span> 553</span><span>public</span><span>function</span> lindex(<span>$sKey</span>, <span>$index</span> = 0<span>)
</span><span> 554</span><span> {
</span><span> 555</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 556</span><span>return</span> self::<span>$redis</span>->lindex(<span>$sKey</span>, <span>intval</span>( <span>$index</span><span>));
</span><span> 557</span><span> }
</span><span> 558</span><span> 559</span><span>/*</span><span>*
</span><span> 560</span><span> * Setzen Sie den Wert des Listenelements an der Indexposition auf Wert.
</span><span> 561</span><span> * Der Index beginnt bei 0<strong>Index</strong>, also bedeutet 0 das erste Element, 1 das zweite Element und so weiter. 
</span><span> 562</span><span> * Es wird ein Fehler zurückgegeben, wenn der Index außerhalb des Bereichs liegt.
</span><span> 563</span><span> * @author zhaoyingnan 2015-11-03 14:27
</span><span> 564</span><span> * @param string $sKey
</span><span> 565</span><span> * @param int $index key Der entsprechende Index in der Liste ist index
</span><span> 566</span><span> * @param string $sValue Der festzulegende Wert
</span><span> 567</span><span> * @return
</span><span> 568</span><span> *</span><span>*/</span><span> 569</span><span>public</span><span>function</span> lset(<span>$sKey</span>, <span>$index</span>, <span>$sValue</span><span>)
</span><span> 570</span><span> {
</span><span> 571</span><span>if</span>(!<span>$sKey</span> || !<span>$sValue</span>)<span>return</span><span>FALSE </span><span>;
</span><span> 572</span><span>return</span> self::<span>$redis</span>->lset(<span>$sKey</span>, <span>$index</span> , <span>$sValue</span><span>);
</span><span> 573</span><span> }
</span><span> 574</span><span> 575</span><span>/*</span><span>*
</span><span> 576</span><span> * Wert in die im Schlüssel gespeicherte Liste vor oder nach dem Pivotwert einfügen.
</span><span> 577</span><span> * Wenn der Schlüssel nicht vorhanden ist, wird diese Liste als leere Liste betrachtet und es werden keine Vorgänge ausgeführt.
</span><span> 578</span><span> * Wenn der Schlüssel existiert, aber nicht als Liste gespeichert wird, wird ein Fehler zurückgegeben.</span><span> 579</span><span> * @author zhaoyingnan 2015-11-03 13:42
</span><span> 580</span><span> * @param string $sKey
</span><span> 581</span><span> * @param string $sPosion vor oder nach dem Basiswert (BEFORE oder AFTER)
</span><span> 582</span><span> * @param string $pivot Der Pivot-Wert in der Liste
</span><span> 583</span><span> * @param string $sValue Der eingefügte Wert
</span><span> 584</span><span> * @return mix Die Länge der Liste nach dem Einfügevorgang oder -1, wenn der Pivotwert nicht gefunden werden kann.
</span><span> 585</span><span> *</span><span>*/</span><span> 586</span><span>public</span><span>function</span> linsert(<span>$sKey</span>, <span>$sPosion</span>, <span>$pivot</span>, <span>$sValue</span><span>)
</span><span> 587</span><span> {
</span><span> 588</span><span>if</span>(!<span>$sKey</span> || !<span>$pivot</span> || !<span>$sValue</span>) <span>zurück</span><span>FALSCH</span><span>;
</span><span> 589</span><span>$sPosion</span> = <span>in_array</span>(<span>$sPosion</span>, <span>array</span>('BEFORE', 'AFTER ')) ? <span>strtoupper</span>(<span>$sPosion</span>) : 'BEFORE'<span>;
</span><span> 590</span><span>return</span> self::<span>$redis</span>->linsert(<span>$sKey</span>, <span>$sPosion</span> , <span>$pivot</span>, <span>$sValue</span><span>);
</span><span> 591</span><span> }
</span><span> 592</span><span> 593</span><span>/*</span><span>*
</span><span> 594</span><span> * Entfernen Sie die ersten Zählelemente, deren Wert value ist, aus der im Schlüssel gespeicherten Liste. Der Count-Parameter wirkt sich auf folgende Weise auf diesen Vorgang aus:
</span><span> 595</span><span> * count > 0: Elemente mit Wert von Anfang bis Ende entfernen.
</span><span> 596</span><span> * count < 0: Elemente mit Wert vom Ende zum Anfang entfernen.
</span><span> 597</span><span> * count = 0: Alle Elemente mit Wert entfernen.
</span><span> 598</span><span> * Beispielsweise entfernt LREM list -2 „hello“ die letzten beiden Vorkommen von „hello“ aus der in list gespeicherten Liste.
</span><span> 599</span><span> * Es ist zu beachten, dass, wenn der Schlüssel nicht in der Liste vorhanden ist, diese als leere Liste behandelt wird. Wenn der Schlüssel also nicht vorhanden ist, wird dieser Befehl zurückgegeben 0.
</span><span> 600</span><span> * @author zhaoyingnan 2015-11-03 13:53
</span><span> 601</span><span> * @param string $sKey
</span><span> 602</span><span> * @param int $iCount count > Elemente mit Wert von Anfang bis Ende entfernen. count < 0: Elemente mit Wert vom Ende zum Anfang entfernen. count = 0: Alle Elemente mit dem Wert value entfernen.
</span><span> 603</span><span> * @param string $sValue Der zu löschende Wert
</span><span> 604</span><span> * @return int
</span><span> 605</span><span> *</span><span>*/</span><span> 606</span><span>//</span><span>public function lremu($sKey, $iCount, $sValue)
</span><span> 607</span><span> //{
</span><span> 608</span><span> // var_dump($sValue);
</span><span> 609</span><span> // if(!$sKey || !$sValue)return FALSE;
</span><span> 610</span><span> // return self::$redis->lrem($sKey, intval($iCount), $sValue);
</span><span> 611</span><span> //}</span><span> 612</span><span> 613</span><span>/*</span><span>*
</span><span> 614</span><span> * Trimmen Sie eine vorhandene Liste, sodass die Liste nur die angegebenen Elemente im angegebenen Bereich enthält.
</span><span> 615</span><span> * Start und Stopp beginnen beide mit dem Zählen bei 0, wobei 0 das erste Element in der Liste (Kopfzeile) und 1 das zweite Element ist, also Analogie.
</span><span> 616</span><span> * @author zhaoyingnan 2015-11-03 14:45
</span><span> 617</span><span> * @param string $sKey
</span><span> 618</span><span> * @param int $iStart Die Startposition innerhalb des angegebenen Bereichs
</span><span> 619</span><span> * @param int $iEnd gibt die Endposition innerhalb des Bereichs an
</span><span> 620</span><span> * @return bool
</span><span> 621</span><span> *</span><span>*/</span><span> 622</span><span>öffentliche</span><span>Funktion</span><span>ltrim </span>(<span>$sKey</span>, <span>$iStart</span>, <span>$iEnd</span><span>)
</span><span> 623</span><span> {
</span><span> 624</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 625</span><span>return</span> self::<span>$redis</span>-><span>ltrim</span>(<span>$sKey</span>, <span>intval</span>(<span>$iStart</span>), <span>intval</span>(<span>$iEnd</span><span>));
</span><span> 626</span><span> }
</span><span> 627</span><span> 628</span><span>/*</span><span>*
</span><span> 629</span><span> * Gibt die Elemente im angegebenen Bereich zurück, der in der Schlüsselliste gespeichert ist.
</span><span> 630</span><span> * Der Start- und Endoffset sind beide 0-basierte Indizes, d. h. das erste Element der Liste ist 0 (der Kopf der Liste) und das zweite Element ist 0 Der Index ist 1 und so weiter.</span><span> 631</span><span> * Der Offset kann auch eine negative Zahl sein, was angibt, dass der Offset ab dem Ende der Liste gezählt wird. Beispielsweise ist -1 das letzte Element der Liste, -2 das vorletzte und so weiter.
</span><span> 632</span><span> * @author zhaoyingnan 2015-11-03 14:54
</span><span> 633</span><span> * @param string $sKey
</span><span> 634</span><span> * @param int $iStart Startposition
</span><span> 635</span><span> * @param int $iEnd Endposition
</span><span> 636</span><span> * @return-Array
</span><span> 637</span><span> *</span><span>*/</span><span> 638</span><span>public</span><span>function</span> lrange(<span>$sKey</span>, <span>$iStart</span>, <span>$iEnd</span><span>)
</span><span> 639</span><span> {
</span><span> 640</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 641</span><span>return</span> self::<span>$redis</span>->lrange(<span>$sKey</span>, <span>intval</span>( <span>$iStart</span>), <span>intval</span>(<span>$iEnd</span><span>));
</span><span> 642</span><span> }
</span><span> 643</span><span> 644</span><span>/*</span><span>*
</span><span> 645</span><span> * Entfernen Sie das erste Element der Liste, das dem Schlüssel entspricht, und geben Sie es zurück.
</span><span> 646</span><span> * @author zhaoyingnan 2015-11-03 21:49
</span><span> 647</span><span> * @param string $sKey
</span><span> 648</span><span> * @return bool
</span><span> 649</span><span> *</span><span>*/</span><span> 650</span><span>public</span><span>function</span> lpop(<span>$sKey</span><span>)
</span><span> 651</span><span> {
</span><span> 652</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 653</span><span>return</span> self::<span>$redis</span>->lpop(<span>$sKey</span><span>);
</span><span> 654</span><span> }
</span><span>655</span><span>656</span><span>/*</span><span>*
</span><span> 657</span><span> * Entfernen Sie das letzte Element der unter Schlüssel gespeicherten Liste und geben Sie es zurück.</span><span> 658</span><span> * @author zhaoyingnan 2015-11-03 21:49
</span><span> 659</span><span> * @param string $sKey
</span><span> 660</span><span> * @return bool
</span><span> 661</span><span> *</span><span>*/</span><span> 662</span><span>public</span><span>function</span> rpop(<span>$sKey</span><span>)
</span><span> 663</span><span> {
</span><span> 664</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 665</span><span>return</span> self::<span>$redis</span>->rpop(<span>$sKey</span><span>);
</span><span> 666</span><span> }
</span><span> 667</span><span> 668</span><span>/*</span><span>******************** set *** *****************</span><span>*/</span><span> 669</span><span> 670</span><span>/*</span> <span>*
</span><span> 671</span><span> * Fügen Sie ein oder mehrere angegebene Mitgliedselemente zum Schlüssel der Sammlung hinzu.
</span><span> 672</span><span> * Wenn ein oder mehrere angegebene Elementmitglieder bereits im Sammlungsschlüssel vorhanden sind, werden sie ignoriert.
</span><span> 673</span><span> * Wenn der Sammlungsschlüssel nicht vorhanden ist, erstellen Sie einen neuen Sammlungsschlüssel und fügen Sie das Mitgliedselement zum Sammlungsschlüssel hinzu.
</span><span> 674</span><span> * Gibt einen Fehler zurück, wenn der Schlüsseltyp keine Sammlung ist.
</span><span> 675</span><span> * @author zhaoyingnan 2015-11-03 21:55
</span><span> 676</span><span> * @param string $sKey
</span><span> 677</span><span> * @param array $arMember Array von Elementen, die hinzugefügt werden sollen
</span><span> 678</span><span> * @return int Gibt die Anzahl der neu erfolgreich zur Sammlung hinzugefügten Elemente zurück, mit Ausnahme von Elementen, die bereits in der Sammlung vorhanden sind.
</span><span> 679</span><span> *</span><span>*/</span><span> 680</span><span>public</span><span>function</span> sadd(<span>$sKey</span>, <span>$arMember</span> = <span>array</span><span>())
</span><span> 681</span><span> {
</span><span> 682</span><span>if</span>(!<span>$sKey</span>)<span>return</span><span>FALSE</span><span>;
</span><span> 683</span><span>$iCount</span> = 0<span>;
</span><span> 684</span><span>foreach</span>(<span>$arMember</span><span>as</span><span>$val</span><span>)
</span><span> 685</span><span> {
</span><span> 686</span><span>if</span>(self::<span>$redis</span>->sadd(<span>$sKey</span>, <span>$val</span><span>))
</span><span> 687</span><span>$iCount</span> <span>;
</span><span> 688</span><span> }
</span><span>689</span><span>return</span><span>$iCount</span><span>;
</span><span> 690</span><span> }
</span><span> 691</span><span> 692</span><span>/*</span><span>*
</span><span> 693</span><span> * Gibt die Kardinalität des in der Sammlung gespeicherten Schlüssels zurück (die Anzahl der Sammlungselemente).
</span><span> 694</span><span> * @author zhaoyingnan 2015-11-03 22:09
</span><span> 695</span><span> * @param string $sKey
</span><span> 696</span><span> * @return int
</span><span> 697</span><span> *</span><span>*/</span><span> 698</span><span>öffentliche</span><span>Funktion</span> Scard(<span>$sKey</span><span>)
</span><span> 699</span><span> {
</span><span> 700</span><span>if</span>(!<span>$sKey</span>)<span>return</span> 0<span>;
</span><span> 701</span><span>return</span> self::<span>$redis</span>->scard(<span>$sKey</span><span>);
</span><span> 702</span><span> }
</span><span>703</span><span>704</span><span>/*</span><span>*
</span><span> 705</span><span> * Gibt die Elemente der Differenz zwischen einer Menge und der gegebenen Menge zurück.
</span><span> 706</span><span> * @author zhaoyingnan 2015-11-03 22:13
</span><span> 707</span><span> * @param array $arKey
</span><span> 708</span><span> * @return-Array
</span><span> 709</span><span> *</span><span>*/</span><span> 710</span><span>public</span><span>function</span> sdiff(<span>$arKey</span><span>)
</span><span>711</span><span> {
</span><span> 712</span><span>if</span>(!<span>$arKey</span>)<span>return</span><span>array</span><span>();
</span><span> 713</span><span>return</span> self::<span>$redis</span>->sdiff(<span>$arKey</span><span>);
</span><span> 714</span><span> }</span><span> 715</span><span> 716</span><span>/*</span><span>*
</span><span> 717</span><span> * Dieser Befehl ähnelt SDIFF, mit der Ausnahme, dass dieser Befehl keinen Ergebnissatz zurückgibt, sondern die Ergebnisse in der Zielsammlung speichert.
</span><span> 718</span><span> * Wenn das Ziel bereits existiert, überschreiben Sie es.
</span><span> 719</span><span> * @author zhaoyingnan 2015-11-04 10:16
</span><span> 720</span><span> * @param string $sNewKey
</span><span> 721</span><span> * @param array $arKey
</span><span> 722</span><span> * @return int Die Anzahl der Elemente im Ergebnissatz.
</span><span> 723</span><span> *</span><span>*/</span><span> 724</span><span>public</span><span>function</span> sdiffstore(<span>$sNewKey</span>, <span>$arKey</span><span>)
</span><span> 725</span><span> {
</span><span> 726</span><span>if</span>(!<span>$arKey</span> || !<span>$sNewKey</span>)<span>return</span> 0<span> ;
</span><span> 727</span><span>if</span>(<span>$arResult</span> = self::<span>$redis</span>->sdiff(<span>$arKey</span><span>))
</span><span> 728</span><span>return</span><span>$this</span>->sadd(<span>$sNewKey</span>, <span>$arResult</span><span> );
</span><span> 729</span><span>zurück</span> 0<span>;
</span><span> 730</span><span> }
</span><span> 731</span><span> 732</span><span>/*</span><span>*
</span><span> 733</span><span> * Gibt die Schnittmenge aller Mitglieder der angegebenen Menge zurück.
</span><span> 734</span><span> * @author zhaoyingnan 2015-11-04 10:18
</span><span> 735</span><span> * @param array $arKey
</span><span> 736</span><span> * @return-Array
</span><span> 737</span><span> *</span><span>*/</span><span> 738</span><span>öffentliche</span><span>Funktion</span> Sinter(<span>$arKey</span><span>)
</span><span> 739</span><span> {
</span><span> 740</span><span>if</span>(!<span>$arKey</span>)<span>return</span><span>array</span><span>();
</span><span> 741</span><span>return</span> self::<span>$redis</span>->sinter(<span>$arKey</span><span>);
</span><span> 742</span><span> }
</span><span> 743</span><span> 744</span><span>/*</span><span>*
</span><span> 745</span><span> * Dieser Befehl ähnelt dem SINTER-Befehl, gibt die Ergebnismenge jedoch nicht direkt zurück, sondern speichert das Ergebnis in der Zielsammlung.
</span><span> 746</span><span> * Wenn die Zielsammlung vorhanden ist, wird sie überschrieben.
</span><span> 747</span><span> * @author zhaoyingnan 2015-11-04 10:23
</span><span> 748</span><span> * @param string $sNewKey
</span><span> 749</span><span> * @param array $arKey
</span><span> 750</span><span> * @return int Die Anzahl der Elemente im Ergebnissatz.
</span><span> 751</span><span> *</span><span>*/</span><span> 752</span><span>public</span><span>function</span> sinterstore(<span>$sNewKey</span>, <span>$arKey</span><span>)
</span><span> 753</span><span> {
</span><span> 754</span><span>if</span>(!<span>$arKey</span> || !<span>$sNewKey</span>)<span>return</span> 0<span> ;
</span><span> 755</span><span>if</span>(<span>$arResult</span> = self::<span>$redis</span>->sinter(<span>$arKey</span><span>))
</span><span> 756</span><span>return</span><span>$this</span>->sadd(<span>$sNewKey</span>, <span>$arResult</span><span> );
</span><span> 757</span><span>zurück</span> 0<span>;
</span><span> 758</span><span> }
</span><span>759</span><span>760</span><span>/*</span><span>*
</span><span> 761</span><span> * Gibt zurück, ob Mitglied Mitglied Mitglied des gespeicherten Sammlungsschlüssels ist.
</span><span> 762</span><span> * @author zhaoyingnan 2015-11-04 10:25
</span><span> 763</span><span> * @param string $sKey
</span><span> 764</span><span> * @param string $member
</span><span> 765</span><span> * @return int Wenn das Mitgliedselement Mitglied des Set-Schlüssels ist, wird 1 zurückgegeben, wenn das Mitgliedselement kein Mitglied des Schlüssels ist oder der Set-Schlüssel dies nicht tut existieren, geben 0 zurück
</span><span> 766</span><span> *</span><span>*/</span><span> 767</span><span>public</span><span>function</span> sismember(<span>$sKey</span>, <span>$member</span><span>)
</span><span> 768</span><span> {
</span><span>769</span><span>if</span>(!