PHP Redis::del方法代码示例

 public function del($key)
 {
     if (!$this->isConnected()) {
         return false;
     }
     return (bool) $this->redis->del($key);
 }

 public function get($key, $top = 10)
 {
     $result_key = $this->result_prefix . $key;
     $this->redis->zInter($result_key, [$this->key_prefix . $key, $this->word_prefix], [1, 1]);
     $result = $this->redis->zRevRange($result_key, 0, $top, true);
     $this->redis->del($result_key);
     return $result;
 }

 /**
  * {@inheritdoc}
  */
 public function releaseLock($name)
 {
     if (isset($this->locks[$name]) && $this->redis->del($name)) {
         $this->clearLock($name);
         return true;
     }
     return false;
 }

 public function clear()
 {
     $this->redis->setOption(\Redis::OPT_SERIALIZER, \Redis::SERIALIZER_NONE);
     $prefix = $this->redis->getOption(\Redis::OPT_PREFIX);
     $offset = strlen($prefix);
     $keys = $this->redis->keys('*');
     foreach ($keys as $key) {
         $this->redis->del(substr($key, $offset));
     }
 }

 /**
  * Disable a dark launch feature
  * @param $feature string - The name of the feature
  */
 public function disable_feature($feature_name)
 {
     $multi = $this->redis->multi();
     $this->redis->del("{$this->feature_namespace()}:feature:{$feature_name}");
     $this->redis->srem("{$this->feature_namespace()}:features", $feature_name);
     $multi->exec();
 }

 /**
  * Delete the keys that were added to the database during the test
  */
 public function tearDown()
 {
     parent::tearDown();
     Redis::del($this->testingResource->testModelHashId);
     Redis::del($this->testingResource->testModelSearchableId);
     Redis::del("testmodels");
 }

 /**
  * Releases a given lock if the owner information matches.
  *
  * @see cache_is_lockable
  * @param string $key Name of the lock to release.
  * @param string $ownerid Owner information to use.
  * @return bool True if the lock is released, false if it is not.
  */
 public function release_lock($key, $ownerid)
 {
     if ($this->check_lock_state($key, $ownerid)) {
         return $this->redis->del($key) !== false;
     }
     return false;
 }

 public function unlock()
 {
     try {
         $this->rd->del($this->k);
     } catch (\RedisException $e) {
     }
 }

 private function unlock()
 {
     if ($this->locked) {
         $this->redis->del($this->lockKey);
         $this->locked = false;
     }
 }

 /**
  * {@inheritDoc}
  */
 public function removeWord($language, $word)
 {
     $word = mb_strtolower($word, mb_detect_encoding($word));
     if ($this->redis->exists($word)) {
         $languages = unserialize($this->redis->get($word));
         if (false !== ($index = array_search($language, $languages))) {
             unset($languages[$index]);
             if (!count($languages)) {
                 $this->redis->del($word);
             } else {
                 $this->redis->set($word, serialize($languages));
             }
         }
     }
     return $this;
 }

 /**
  * Deletes all items from cache.
  *
  * This should only be used for maintenance purposes (slow performance).
  */
 public function flush()
 {
     $keys = $this->redis->keys($this->redis->prefix('*'));
     foreach ($keys as $key) {
         $this->redis->del($key);
     }
 }

 public function testUnserialize()
 {
     $vals = array(1, 1.5, 'one', array('this', 'is', 'an', 'array'));
     $serializers = array(Redis::SERIALIZER_PHP);
     if (defined('Redis::SERIALIZER_IGBINARY')) {
         $serializers[] = Redis::SERIALIZER_IGBINARY;
     }
     foreach ($serializers as $mode) {
         $vals_enc = array();
         // Pass them through redis so they're serialized
         foreach ($vals as $key => $val) {
             $this->redis->setOption(Redis::OPT_SERIALIZER, $mode);
             $key = "key" . ++$key;
             $this->redis->del($key);
             $this->redis->set($key, $val);
             // Clear serializer, get serialized value
             $this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
             $vals_enc[] = $this->redis->get($key);
         }
         // Run through our array comparing values
         for ($i = 0; $i < count($vals); $i++) {
             // reset serializer
             $this->redis->setOption(Redis::OPT_SERIALIZER, $mode);
             $this->assertTrue($vals[$i] == $this->redis->_unserialize($vals_enc[$i]));
             $this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
         }
     }
 }

 /**
  * Destroy a session.
  * Expects a session id.
  * @param string $sessionId
  * @return boolean
  */
 public function destroy($sessionId = '')
 {
     if ($sessionId !== '' && $this->_redis->exists($this->_key($sessionId))) {
         $this->_redis->del($this->_key($sessionId));
     }
     session_destroy();
     return true;
 }

 public function remove()
 {
     if (!$this->id) {
         return false;
     }
     Redis::del($this->key());
     Redis::zrem(get_class($this), $this->id);
 }

 protected static function clear(\Redis $redis)
 {
     $prefix = $redis->getOption(\Redis::OPT_PREFIX);
     $offset = strlen($prefix);
     $keys = $redis->keys('*');
     foreach ($keys as $key) {
         $redis->del(substr($key, $offset));
     }
 }