Checks if the given cache key has an existing cache file that didn't exceed the given life-time

@param $key string The key that needs to be checked

@return bool
321332
public function exists($key)
    {

        $path = $this->getKeyPath($key);

        if (!file_exists($path) || empty($this->_lifeTimes[$key]))
            return false;

        if (time() - filemtime($path) > $this->_lifeTimes[$key])
            return false;

        return true;
    }
69348
public function has($key)
    {
        return $this->enabled && $this->filesystem->exists($this->cacheDir.$key);
    }
397235
public function has($key)
    {
        /* If $key is not valid string throws InvalidArgumentException */
        if (!$this->isString($key)) {
            throw new InvalidArgumentException('Cache key must be not empty string');
        }

        if ($this->getRaw($key)) {
            return true;
        }

        return false;
    }
1362107
public function read(string $key)
    {
        $file = $this->cacheFile($key);

        if (is_file($file)) {
            // Cache exists
            $data = include $file;
            $expire = (int)$data['ttl'];
            if ($expire === 0 || time() < $expire) {
                return unserialize($data['data']);
            }
            unlink($file);
        }

        return false;
    }
1075553
public function has($key): bool
    {
        $this->checkKey($key);
        return (bool) $this->getRedis()->keys($this->filterKey($key));
    }
659989
protected function exists($key)
    {
        $data = $this->read($key);
        if ($data === false) {
            return false;
        }

        $expire = $data[0];
        if ($expire !== 0 && $expire < time()) {
            // expired, don't keep it around
            $path = $this->path($key);
            $this->filesystem->delete($path);

            return false;
        }

        return true;
    }
690301
public function has($key)
	{
		if ( ! isset($this->jar[$key]) or $this->jar[$key]->isDeleted())
		{
			if ( ! $this->parentEnabled or ! $this->parent->has($key))
			{
				return false;
			}
		}

		return true;
	}
625021
public function purge($key)
    {
        $cacheFile = $this->getCachePath($key);

        clearstatcache(true, $cacheFile);
        if (file_exists($cacheFile)) {
            unset($cacheFile);

            return true;
        }

        return false;
    }
1207867
public function has(string $key): bool
    {
        $this->assertRead();

        return \array_key_exists($key, $this->data);
    }
372578
public function has($key)
        {
            if (!$this->enabled) return false;

            switch ($this->type) {
                case self::TYPE_APC:
                    $success = false;
                    apc_fetch($key, $success);
                    break;
                case self::TYPE_FILE:
                    $filename = $this->path . $key . '.cache';
                    $success = file_exists($filename);
                    break;
                case self::TYPE_DUMMY:
                default:
                    $success = false;
            }

            return $success;
        }
1105598
public static function has($key) {
        try {
            $b = self::getCache()->has($key);
            self::release();
            return $b;
        } catch (\RuntimeException $e) {
            self::release();
            throw $e;
        } catch (\Error $e) {
            self::release();
            throw $e;
        }
    }
379742
public function exists(string $key) : bool
    {
        $this->checkCallback();
        return isset($this->members[$key]);
    }
1105983
public function has(string $key) : bool
    {
        return isset($this->collection[$this->useKey($key)]);
    }
556221
public function has($key)
	{
		$this->memcached->get($key);
		if ($this->memcached->getResultCode() == Memcached::RES_NOTFOUND)
		{
			return false;
		}

		return true;
	}
288391
public function has(string $key){
        $data   = $this->status() === self::ACTIVE
            ? $_SESSION : $this->finishedData;
        
        return array_key_exists($key, $data);
    }
1024320
public function has($key = '')
    {
        try {
            if ($this->cacheInstance !== NULL && is_object($this->cacheInstance)) {
                /**
                 * @var $cache object
                 */
                $cache = $this->cacheInstance->getItem($key);
                if (!$cache->isHit()) {
                    return FALSE;
                } else {
                    return TRUE;
                }
            } else {
                $this->debug->error(__FUNCTION__, 'Unavailable cacheInstance');

                return FALSE;
            }
        }
        catch (\Exception $e) {
            $message = 'Error File: ' . $e->getFile() . ' - Line: ' . $e->getLine() . ' - Code: ' . $e->getCode() . ' - Message: ' . $e->getMessage();
            $this->debug->error(__FUNCTION__, $message);

            return $message;
        }
    }
1355053
public function has($key)
    {
        if (!$this->isEnabled()) {
            return false;
        }

        return (false !== $this->server->get($this->prefix . $key));
    }