Has

@param string $key
@param array $tags

@return bool
966728
public function has(string $key, array $tags): bool 
    {
        return $this->cache->tags($tags)->has($key);
    }
1116179
public static function has(array $array, ...$keys): bool
    {
        $key = array_shift($keys);

        if (!isset($array[$key])) {
            return false;
        }

        if (empty($keys)) {
            return isset($array[$key]);
        }

        if (!\is_array($array[$key])) {
            return false;
        }

        return self::has($array[$key], ...$keys);
    }
515020
public static function hasKey(Array $array, Array $keys)
    {
        foreach ($array as $key => $value) {
            if (in_array($key, $keys)) {
                return true;
            }
        }

        return false;
    }
1077463
public function has($key)
    {
        $flashMessages = $this->storage->get(self::FLASH_KEY);
        return isset($flashMessages[$key]);
    }
503684
public function hasTag($tag)
    {
        if ($this->isTopTag($tag)) {
            return true;
        }

        return isset($this->tags[$tag]) && is_array($this->tags[$tag]);
    }
1356659
function has($key) {
        if(\is_array($key) || \is_object($key)) {
            throw new \InvalidArgumentException('Key can not be an array or object');
        }
        
        $key = (string) $key;
        return parent::has($key);
    }
853401
public function has( $key ) {
		return isset( $this->fields[$key] ) || array_key_exists( $key, $this->fields );
	}
439755
public function has(string $key): bool
    {
        $key = $this->getKey($key, true);
        return isset($this->headers[$key]);
    }
401085
public function has($keys)
    {
        $keys = is_array($keys) ? $keys : func_get_args();

        $results = $this->payload();

        foreach ($keys as $value) {
            if ($this->hasValueAtKey($value, $results) === false) {
                return false;
            }
        }
        return true;
    }
445624
public static function has($array, $key)
    {
        if (empty($array) || null === $key) {
            return false;
        }

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

        foreach (explode('.', $key) as $segment) {
            if ((\is_array($array) && array_key_exists($segment, $array)) || ($array instanceof \ArrayAccess && $array->offsetExists($segment))) {
                $array = $array[$segment];
            } else {
                return false;
            }
        }

        return true;
    }
6039
public function has($key)
    {
        $result = $this->load($key);
        return Arr::has(static::$configs[$result[0]], $result[1]);
    }
646239
final public function delete(TagKey $key): bool
    {
        if (!\array_key_exists($key->getName(), $this->m)) {
            return false;
        }
        unset($this->m[$key->getName()]);
        return true;
    }
145639
public function has(string $name) : bool
    {
        foreach ($this->tags as $tag) {
            if ($tag->name == $name) {
                return true;
            }
        }

        return false;
    }
1340530
public function has($key)
	{
		if (count(func_get_args()) > 1)
		{
			foreach (func_get_args() as $value)
			{
				if ( ! $this->has($value)) return false;
			}

			return true;
		}

		if (is_bool($this->input($key)) || is_array($this->input($key)))
		{
			return true;
		}

		return trim((string) $this->input($key)) !== '';
	}
1294830
public function has($key)
    {
        $array = $this->array;

        if (empty($array) || is_null($key)) {
            return false;
        }

        if (array_key_exists($this->unescapeDotKey($key), $array)) {
            return true;
        }

        foreach (explode('.', $this->escapedDotKeyToUnderscore($key)) as $segment) {
            $segment = $this->underscoreDotKeyToDot($segment);

            if (is_array($array) === false || array_key_exists($segment, $array) === false) {
                return false;
            }

            $array = $array[$segment];
        }

        return true;
    }
1005396
protected function has($key)
    {
        if (!is_array($key)) {
            return (array_key_exists($key, $this->item));
        }

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

        return true;
    }
1230031
public function hasTag($tags): bool
    {
        // Single tag slug
        if (is_string($tags)) {
            return $this->tags->contains('slug', $tags);
        }

        // Single tag id
        if (is_int($tags)) {
            return $this->tags->contains('id', $tags);
        }

        // Single tag model
        if ($tags instanceof Tag) {
            return $this->tags->contains('slug', $tags->slug);
        }

        // Array of tag slugs
        if (is_array($tags) && isset($tags[0]) && is_string($tags[0])) {
            return ! $this->tags->pluck('slug')->intersect($tags)->isEmpty();
        }

        // Array of tag ids
        if (is_array($tags) && isset($tags[0]) && is_int($tags[0])) {
            return ! $this->tags->pluck('id')->intersect($tags)->isEmpty();
        }

        // Collection of tag models
        if ($tags instanceof Collection) {
            return ! $tags->intersect($this->tags->pluck('slug'))->isEmpty();
        }

        return false;
    }