Returns true if the store contains records for any of the given keys.

@param array $keys
@return bool
545768
public function has_any(array $keys) {
        $maxtime = 0;
        if ($this->ttl != 0) {
            $maxtime = cache::now() - $this->ttl;
        }

        foreach ($keys as $key) {
            if (isset($this->store[$key]) && ($this->ttl == 0 || $this->store[$key][1] >= $maxtime)) {
                return true;
            }
        }
        return false;
    }
216478
private function validateKeys(array $keys)
    {
        foreach ($keys as $key) {
            $key = (string)$key;
            $this->validateKey($key);
        }
    }
1060139
public function wasModified($keys = null)
    {
        $modified = $this->getModifiedData();
        $removedKeys = $this->getRemovedKeys();

        if (!$keys) {
            return (bool)$modified || (bool)$removedKeys;
        }

        $keys = is_array($keys) ? $keys : func_get_args();

        foreach ($keys as $key) {

            if (array_key_exists($key, $modified)) {
                return true;
            }

            if (in_array($key, $removedKeys)) {
                return true;
            }
        }

        return false;
    }
1020151
public static function has($array, $keys)
	{
		if(is_null($keys) || ! $array)
		{
			return false;
		}

		$keys = (array) $keys;
		if($keys === [])
		{
			return false;
		}

		foreach($keys as $key)
		{
			if(static::exists($array, $key))
			{
				continue;
			}

			if( strpos($key, ".") !== false )
			{
				$subKeyArray = $array;
				for($i = 0, $map = explode('.', $key), $len = count($map); $i < $len; $i++)
				{
					$segment = $map[$i];
					if( ($i < 1 || static::accessible($subKeyArray)) && static::exists($subKeyArray, $segment) )
					{
						if( $i + 1 < $len )
						{
							$subKeyArray = $subKeyArray[$segment];
						}
					}
					else
					{
						return false;
					}
				}
			}
		}

		return true;
	}
301770
private function getRecord(array $keys)
    {
        $keys['_timeout'] = ['$gt' => time()];

        $results = $this->getCollection()->find($keys);

        if ($results->hasNext()) {
            return $results->getNext();
        }
    }
942779
public static function keysExist ($array, $keys)
		{
			if (!is_array($array))
				return null;

			if (!is_array($keys))
				$keys = [ $keys ];

			foreach ($keys as $key)
				if (!array_key_exists($key, $array))
					return false;

			return true;
		}
729544
public function has_any(array $keys) {
        foreach ($keys as $arraykey => $key) {
            $keys[$arraykey] = $this->prepare_key($key);
        }
        $result = apcu_exists($keys);
        return count($result) > 0;
    }
900802
private function isKeyRange($key, Array $keys)
    {
        if (empty($keys)) {
            return false;
            
        }
        return \reset($keys)->getKey() <= $key
            && \end($keys)->getKey() >= $key;
    }
754694
public function wasLoaded($keys = null)
    {
        if (!$keys) {
            return !$this->isNew();
        }

        if ($this->isNew()) {
            return false;
        }

        $keys = is_array($keys) ? $keys : func_get_args();

        foreach ($keys as $key) {
            if (!array_key_exists($key, $this->originalAttributes)) {
                return false;
            }
        }

        return true;
    }
786065
public function contains(... $items) : bool
    {
        $values = $this->getValues();
        foreach($items as $item)
        {
            if (!in_array($item, $values, true))
            {
                return false;
            }
        }
        return true;
    }
1179362
public function has($key)
    {
        $keys = explode('.', $key);
        $cKeys = count($keys);
        $config = $this->_arr;

        for ($i = 0; $i < $cKeys; ++$i) {
            if (is_array($config)) {
                if (array_key_exists($keys[$i], $config)) {
                    $config = $config[$keys[$i]];
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }

        return true;
    }
220977
public function containsKey($key)
    {
        if (!$this->enabled)
            return false;

        $has_key = array_key_exists($this->key($key), $this->cache);

        // $this->Logger->debug("Cache contains {$key}? " . (($has_key) ? 'TRUE' : 'FALSE'));

        return $has_key;
    }
1125809
public function hasAny( $keys = [] )
	{
		foreach ( $keys as $key )
		{
			if ( $this->has( $key ) )
			{
				return true;
			}
		}

		return false;
	}
374110
public function detach($keys): bool
    {
        if ($keys instanceof Arrayable) {
            $keys = $keys->toArray();
        }

        foreach ($keys as $key) {
            $this->remove($key);
        }

        return true;
    }
571823
public function deleteMultiple($keys): bool
    {
        $this->checkIterable($keys);
        $return = true;
        foreach ($keys as $key) {
            $return = $return && $this->delete($key);
        }
        return $return;
    }
1149768
public static function keysExist(array $collection, array $keys)
    {
        $collection = array_flip($collection);

        foreach ($keys as $key) {
            if (!in_array($key, $collection)) {
                return false;
            }
        }

        return true;
    }
230605
public function containsKey($key): bool {
        $node = $this->getHead();
        while (null !== $node) {
            if (Comparator::equals($node->getKey(), $key)) {
                return true;
            }
            $node = $node->getNext();
        }
        return false;
    }