Checks whether post parameter exists or the whole array isn't empty

@param string $key, [...]
@return boolean
18930
public function hasPost()
    {
        if (func_num_args() == 0) {
            return !empty($this->post);
        }

        foreach (func_get_args() as $key) {
            if (!$this->hasParam($this->post, $key)) {
                return false;
            }
        }

        return true;
    }
1041803
public function has($key)
    {
        $keys = (func_num_args() > 1) ? func_get_args() : (array) $key;

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

        return true;
    }
1086491
public function has($key)
    {
        $key = trim($key, '.');
        if (strpos($key, '.') !== false) {
            $array =& $this->_items;
            foreach (explode('.', $key) as $v) {
                if (!isset($array[$v]))
                    return false;
                else
                    $array =& $array[$v];
            }
            return true;
        } else {
            return array_key_exists($key, $this->_items);
        }
    }
30863
public function containsKey(int $key): bool {
        $array = $this->array;
        $array = \array_filter($array, function ($value, $key) {
            return $value !== null;
        }, \ARRAY_FILTER_USE_BOTH);
        return array_key_exists($key, $array);
    }
763988
function has($key)
    {
        $key = $this->_normalizeKey($key);
        return array_key_exists($key, $this->_referDataArrayReference());
    }
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;
    }
609952
public function has($key)
    {
        if ($this->needParser()) {
            $this->treatPutRequest();

            return array_key_exists($key, $_REQUEST);
        }

        return parent::has($key);
    }
577738
public function containsKey($key): bool {
        /**
         * @var string $arrayIndex
         * @var SinglyLinkedList $list
         */
        foreach ($this->bucket as $arrayIndex => $list) {
            if (null === $list) {
                continue;
            }
            /* $list is the first element in the bucket. The bucket
             * can contain max $maxSize entries and each entry has zero
             * or one nodes which can have zero, one or multiple
             * successors.
             */
            if ($list->containsKey($key)) {
                return true;
            }
        }
        /*
         * If no bucket contains the value then return false because
         * the searched value is not in the list.
         */
        return false;
    }
364032
public function offsetExists($key)
    {
        return isset($this->data[$key]) || array_key_exists($key, $this->data);
    }
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;
    }
180833
public function has( $key )
	{
		if( empty( $key ) )																		//  no Key given
			throw new InvalidArgumentException( 'Key must not be empty.' );						//  throw Exception
		if( isset( $this->pairs[$key] ) )														//  Key is set on its own
			return TRUE;
		else																					//  Key has not been found
		{
			$key		.= $this->divider;														//  prepare Prefix Key to seach for
			foreach( $this->pairs as $pairKey => $pairValue )									//  iterate all stores Pairs
			{
				if( $pairKey[0] !== $key[0] )													//  precheck for Performance
					continue;																	//  skip Pair
				if( strpos( $pairKey, $key ) === 0 )											//  Prefix Key is found
					return TRUE;
			}
		}
		return FALSE;
	}
1003905
public static function post($key = ""){
		
		if($key){
			$v = self::getRequest()->post($key);
		}else{
			$v = self::getRequest()->post();
		}
		return $v;
	}
53796
public function isEmpty($key = null)
    {
        if ($key === null) {
            return empty($this->data);
        }
        return empty($this->data[$key]);
    }
1219550
public function issetItem($key) {
		if (is_array($key)) {
			$key = $this->arrayHashFunction($key);
		}
		
		return isset($this->_data[$key]);
	}
1105983
public function has(string $key) : bool
    {
        return isset($this->collection[$this->useKey($key)]);
    }
732938
public function isUploadField($key)
    {
        return array_key_exists($key, $this->uploadGetKeys) || array_key_exists($key, $this->uploadSetKeys);
    }
635966
public function has($key)
    {
        return isset($this->data[$key]) && is_array($this->data[$key]);
    }