Checks if the conditions contains an index key.

@return bool|mixed The key if found, false otherwise.
431626
protected function conditionsContainIndexKey()
    {
        if (empty( $this->where )) {
            return false;
        }
        foreach ($this->dynamoDbIndexKeys as $key => $name) {
            if (isset( $this->where[$key] )) {
                return $key;
            }
        }

        return false;
    }
417126
public function has($key)
    {
        $keys = explode('.', (string)$key);
        $data = &$this->data;
        foreach ($keys as $key) {
            if (!isset($data[$key])) {
                return false;
            }
            $data = &$data[$key];
        }

        return true;
    }
600816
public function has(string $key)
    {
        if (array_key_exists($key, $this->input)) {
            return true;
        }

        try {
            $this->find($this->input, $key);
            return true;
        } catch (\Exception $e) {
            return false;
        }
    }
148906
public function has($key)
    {
        $result = array_key_exists($key, $this->data);
        if (!$result && $this->isDotNotation($key)) {
            $result = true;
            $keys = explode('.', $key);
            $data = $this->data;

            foreach ($keys as $key) {
                if (!is_array($data) || !array_key_exists($key, $data)) {
                    $result = false;
                    break;
                }

                $data = $data[$key];
            }
        }

        return $result;
    }
1313898
public function hasIndex($indexName)
    {
        $indexName = $this->normalizeIdentifier($indexName);

        return isset($this->_indexes[$indexName]);
    }
165895
public function has($key)
    {
        $keys = is_array($key) ? $key : func_get_args();

        $input = $this->all();

        foreach ($keys as $value) {
            if (! Arr::has($input, $value)) {
                return false;
            }
        }

        return true;
    }
1259685
public function has($key): bool
    {
        return ArrayUtility::dotRead($this->data, $this->getNormalizedKey($key)) !== null;
    }
365621
public function exists()
    {
        $indexValue = $this->getFieldValue($this->getIndex());
        if ($indexValue) {
            return $this->get($indexValue)->count() > 0;
        }
        return false;
    }
557431
public function has($key)
    {
        if (!$this->checkExtraColumns()) {
            return false;
        }

        $this->load();

        return Arr::has($this->data, $key);
    }
100092
public function containsKey($key)
    {
        if (strpos($key, ".") !== false) {
            //we have a dot, we need to split the ket by the dot and check
            //individual string if they are part of the nestes array
            $keys = explode('.', $key);
            $keysCount = count($keys);
            
            
            $tmpArray = $this->properties;
            foreach ($keys as $index=>$subKey) {
             
                
                if (empty($tmpArray) || empty($subKey))
                {
                    return false;
                } 
                else if ($index+1 < $keysCount)
                {
                    //arizzini: if the current $index is not the last $subKey
                    //we want to check is the $tmpArray is an array
                    $tmpArray = $this->getArrayObject($tmpArray, $subKey);
                }
                else {
//                  echo "checking if subkey=$subKey exists";
//                  print_r($tmpArray);
                    //
                    return $this->getArrayObject($tmpArray, $subKey) !== null;
                    //return array_key_exists($subKey, $tmpArray);
                    
                }
            }
        } else {
            return $this->getArrayObject($this->properties, $key) !== null;
            
        }
        
    }
950098
public boolean containsKey(final long key) {
        int index = longHash(key, mask);
        while (null != values[index]) {
            if (key == keys[index]) {
                return true;
            }
            index = ++index & mask;
        }
        return false;
    }
108303
public function hasItem($key)
    {
        if (!$this->getOptions()->getEnabled()) {
            return false;
        }

        $this->normalizeKey($key);

        $result = false;
        try {
            $result = $this->internalHasItem($key);
        } catch (\Exception $e) {
        }

        return $result;
    }
863025
public function has($key): bool
    {
        $key = $this->getKeyword($key)->getSlug();

        return ! empty($key) && \in_array($key, $this->items);
    }
1075553
public function has($key): bool
    {
        $this->checkKey($key);
        return (bool) $this->getRedis()->keys($this->filterKey($key));
    }
890379
private boolean containsKey(final int key, final int index) {
        return (key != 0 || states[index] == FULL) && keys[index] == key;
    }
350421
public function has($key): bool
    {
        return $this->post->has($key) ?: $this->query->has($key) ?: false;
    }
233023
public function has( $key = null )
	{
		$keys = is_array( $key ) ? $key : func_get_args();

		foreach ( $keys as $key )
		{
			if ( $this->first( $key ) === '' )
			{
				return false;
			}
		}

		return true;
	}