Checks if a particular key exists in a given request query.

@param string $input
@param string $key
@return bool
192003
public static function exists(string $input, string $key) : bool
    {
        return isset(self::getVariable($input, null)[$key]);
    }
929216
public function input($inputVars)
    {
        foreach ($inputVars as $key => $val) {
            if (empty($this->allowed_fields[$key])) {
                echo "Invalid input $key - perhaps misspelled field?\n";
                return false;
            }
            $this->queries[$key] = urlencode($this->filter_field($key, $val));
        }
        $this->queries['clientAPI'] = self::API_VERSION;
    }
763988
function has($key)
    {
        $key = $this->_normalizeKey($key);
        return array_key_exists($key, $this->_referDataArrayReference());
    }
523120
public static function attempt($input)
    {
        $userModel = Config::get('user');
        $model = new $userModel();

        $count = 0;

        foreach ($input as $field => $value) {
            if ($field == '_') {
                unset($input[$field]);
            } else {
                $count++;
            }
            if ($count == 1) {
                $primary = $field;
            }
        }

        if (!empty($input)) {
            $user = $model->where($primary, $input[$primary])->first();

            if (! empty($user) && Hash::check($input['password'], $user->password)) {
                Session::set('user', $user->id);
                return true;
            }

            return false;
        }
    }
609952
public function has($key)
    {
        if ($this->needParser()) {
            $this->treatPutRequest();

            return array_key_exists($key, $_REQUEST);
        }

        return parent::has($key);
    }
1130789
protected static function hasClassIdentifierKey(array $input)
    {
        if (!empty($input[Serializer::CLASS_IDENTIFIER_KEY])) {
            return true;
        }

        $foundIdentifierKey = false;
        if (!empty($input[Serializer::SCALAR_VALUE]) && !empty($input[Serializer::MAP_TYPE])) {
            $input = $input[Serializer::SCALAR_VALUE];
            if (\is_array($input)) {
                foreach ($input as $value) {
                    if (\is_array($value)) {
                        $foundIdentifierKey = $foundIdentifierKey || self::hasClassIdentifierKey($value);
                    }
                }
            }
        }

        return $foundIdentifierKey;
    }
301211
function has($key)
    {
        return (array_key_exists($key, $this->properties)) && $this->properties[$key] !== null;
    }
171341
public function encrypt($input, $key = '')
    {
        if (empty($input)) return $input;
        if (empty($key)) $key = md5($this->key);
        $chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.";
        $ikey ="-x6g6ZWm2G9g_vr0Bo.pOq3kRIxsZ6rm";
        $nh1 = rand(0,64);
        $nh2 = rand(0,64);
        $nh3 = rand(0,64);
        $ch1 = $chars{$nh1};
        $ch2 = $chars{$nh2};
        $ch3 = $chars{$nh3};
        $nhnum = $nh1 + $nh2 + $nh3;
        $knum = 0;$i = 0;
        while(isset($key{$i})) $knum +=ord($key{$i++});
        $mdKey = substr(md5(md5(md5($key.$ch1).$ch2.$ikey).$ch3),$nhnum%8,$knum%8 + 16);
        $input = base64_encode(time().'_'.$input);
        $input = str_replace(array('+','/','='),array('-','_','.'),$input);
        $tmp = '';
        $j=0;$k = 0;
        $tlen = strlen($input);
        $klen = strlen($mdKey);
        for ($i=0; $i<$tlen; $i++) {
            $k = $k == $klen ? 0 : $k;
            $j = ($nhnum+strpos($chars,$input{$i})+ord($mdKey{$k++}))%64;
            $tmp .= $chars{$j};
        }
        $tmplen = strlen($tmp);
        $tmp = substr_replace($tmp,$ch3,$nh2 % ++$tmplen,0);
        $tmp = substr_replace($tmp,$ch2,$nh1 % ++$tmplen,0);
        $tmp = substr_replace($tmp,$ch1,$knum % ++$tmplen,0);
        return $tmp;
    }
881691
protected function input($key = null)
	{
		$transformed = $this->fluentInput($key);

		if (is_array($key) || $key === null) {
			return $transformed->toArray();
		} else {
			return isset($transformed[$key]) ? $transformed[$key] : null;
		}
	}
1107365
protected function isPresent(string $key) : bool
    {
        if (!array_key_exists($key, $this->param)) {
            $this->errors[$key.self::ERROR] = $this->convertToFieldName($key).' not exists in given inputs.';
            return false;
        }

        return true;
    }
800768
private function feedbackExistsForKey( $key )
	{
		return (isset($this->feedbacks[ $key ]) && ($this->feedbacks[ $key ] instanceof FormFeedback));
	}
350421
public function has($key): bool
    {
        return $this->post->has($key) ?: $this->query->has($key) ?: false;
    }
1037200
private function exists($key)
    {
        $data = Query::from($this->table)->where('name', '=', $key)->get();

        return  count($data) > 0;
    }
972765
protected function checkKeyExists($data, $key)
    {
        if (!$data->has($key)) {
            $this->output->writeln("<error>The key $key does not exist.");

            return false;
        }

        return true;
    }
627849
public function input($key, $value = null)
    {
        if (is_null($value)) {
            return Arr::get($this->inputs, $key);
        }

        return Arr::set($this->inputs, $key, $value);
    }
720766
public function has($key)
    {
        // For performance, we can use isset,
        // but it will not match if value == 0
        return isset($this->values[$key]) || array_key_exists($key, $this->values);
    }
1339046
public function hasQuery($key)
    {
        $arrayKeys = array_keys($_GET);
        $keys = is_array($key) ? $key : func_get_args();

        foreach ($keys as $value) {
            if (!in_array($value, $arrayKeys) || trim((string)$_GET[$value]) === '') {
                return false;
            }
        }

        return true;
    }