PHP Redis::exists方法代碼示例

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

 public function testExists()
 {
     $key = 'key' . rand();
     $this->assertFalse($this->redis->exists($key));
     $this->redis->add($key, 'val');
     $this->assertTrue($this->redis->exists($key));
 }

 /**
  * @param $key
  * @return Option
  */
 public static function getMy($key)
 {
     $hash = self::hash($key);
     if (self::$redis->exists(self::myPrefix() . ":" . $hash)) {
         return Option::Some(unserialize(self::$redis->get(self::myPrefix() . ":" . $hash)));
     } else {
         return Option::None();
     }
 }

 /**
  * Returns a list of all affected hashes for a given set of tags.
  *
  * @param array $tags
  *
  * @return array
  */
 private function getHashes(array $tags)
 {
     $hashes = [];
     foreach ($tags as $tag) {
         $tag = $this->redis->prefix($tag);
         if (!$this->redis->exists($tag)) {
             continue;
         }
         $hashes = array_merge($hashes, $this->redis->smembers($tag));
     }
     return array_unique($hashes);
 }

 /**
  * Try to get an item, and if missed call the fallback method to produce the value and store it.
  *
  * @param string $key
  * @param callable $fallback
  * @param int|\DateInterval|\DateTime|callback $validity Number of seconds this is valid for (if int)
  * @return mixed
  */
 function getWithFallback($key, callable $fallback, $validity = null)
 {
     $value = $this->connection->get($key);
     if (!$value && !$this->connection->exists($key)) {
         $value = $fallback();
         if (is_callable($validity)) {
             $validity = call_user_func($validity, $value);
         }
         $this->set($key, $value, $validity);
         return $value;
     }
     return $value;
 }

 /**
  * Tells if this backend is frozen.
  *
  * @return boolean
  */
 public function isFrozen()
 {
     if (null === $this->frozen) {
         $this->frozen = $this->redis->exists($this->buildKey('frozen'));
     }
     return $this->frozen;
 }

 /**
  * @param string $digest
  * @param string $nonce
  * @param string $created
  * @param string $secret
  *
  * @return bool
  * @throws \Symfony\Component\Security\Core\Exception\NonceExpiredException
  */
 protected function validateDigest($digest, $nonce, $created, $secret)
 {
     /*
      * закомментили 7.01.2014 из-за проблемы возможного расхождения с клиентским временем
      *
     // Check created time is not in the future
     if (strtotime($created) > time()) {
         return false;
     }
     
     // Expire timestamp after 5 minutes
     if (time() - strtotime($created) > self::TTL) {
         return false;
     }
     */
     // Validate nonce is unique within 5 minutes
     if ($this->redis->exists(self::PREFIX . ':' . $nonce)) {
         if (null !== $this->logger) {
             $this->logger->debug(sprintf('Previously used nonce detected: %s', base64_decode($nonce)));
         }
         throw new NonceExpiredException('Previously used nonce detected');
     }
     $this->redis->setex(self::PREFIX . ':' . $nonce, self::TTL, time());
     // Validate Secret
     $expected = base64_encode(sha1(base64_decode($nonce) . $created . $secret, true));
     if (null !== $this->logger) {
         $this->logger->debug(sprintf('[+] %s, [=] %s (created: %s, nonce: %s, secret: %s)', $digest, $expected, $created, base64_decode($nonce), $secret));
     }
     return $digest === $expected;
 }

 public function _display_cache(&$CFG, &$URI)
 {
     $cache_path = $CFG->item('cache_path') === '' ? APPPATH . 'cache/' : $CFG->item('cache_path');
     $uri = $CFG->item('base_url') . $CFG->item('index_page') . $URI->uri_string;
     if ($CFG->item('cache_query_string') && !empty($_SERVER['QUERY_STRING'])) {
         $uri .= '?' . $_SERVER['QUERY_STRING'];
     }
     $filepath = $cache_path . md5($uri);
     $redis = new Redis();
     $host = $CFG->item("redis_host");
     $port = $CFG->item("redis_port");
     $redis->connect($host, $port);
     if ($redis->exists($filepath)) {
         $cache = $redis->get($filepath);
         if (!preg_match('/^(.*)ENDCI--->/', $cache, $match)) {
             return false;
         }
     } else {
         return false;
     }
     $cache_info = unserialize($match[1]);
     $expire = $cache_info['expire'];
     $last_modified = $cache_info["last_modified"];
     $this->set_cache_header($last_modified, $expire);
     foreach ($cache_info['headers'] as $header) {
         $this->set_header($header[0], $header[1]);
     }
     $this->_display(substr($cache, strlen($match[0])));
     log_message('debug', 'Cache is current. Sending it to browser.');
     return TRUE;
 }

 /**
  * {@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;
 }

 public function testExists()
 {
     $this->redis->delete('key');
     $this->assertFalse($this->redis->exists('key'));
     $this->redis->set('key', 'val');
     $this->assertEquals(True, $this->redis->exists('key'));
 }

	/**
	 * key是否存在，存在返回ture
	 * @param string $cache_id KEY名稱
	 */
	public function exists($cache_id) {
		try {
			return $this->_redis->exists($cache_id);
		} catch (Exception $e) {
			$this->_error = $e->getMessage();
			return false;
		}
	}

 /**
  * Appends data to an existing item on the Redis server.
  *
  * @param  string $key
  * @param  string $value
  * @param  int    $expiration
  * @return bool
  */
 protected function appendValue($key, $value, $expiration = 0)
 {
     if ($this->redis->exists($key)) {
         $this->redis->append($key, $value);
         return $this->redis->expire($key, $expiration);
     }
     return $this->redis->setex($key, $expiration, $value);
 }

 /**
  * 摧毀SESSION
  *
  * @param int $id key
  *
  * @return bool true/false
  */
 public function destroy($id)
 {
     $id = 'sess_' . $id;
     if ($this->redis->exists($id)) {
         return $this->redis->delete($id);
     }
     return true;
 }

 /**
  * {@inheritDoc}
  */
 public function find($storageName, $key)
 {
     $key = $this->getKeyName($key);
     if (!$this->client->exists($key)) {
         throw new NotFoundException();
     }
     return json_decode($this->client->get($key), true);
 }

 /**
  * 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;
 }