ctype_xdigit - PHP code example

What is the php Function Ctype_XDigit?

You will have seen ctype_xdigit() function in your PHP scripts, but you might not know what it does. It is one of the many string functions that come with php and you can use it to check if a string has certain characters.

php ctype_xdigit function checks if every character in the input string is hexadecimal digit (or something else) and return TRUE or FALSE. if any hexadecimal digit or char from [A-F] is present then it will return true else it will return false.

The ctype_xdigit method takes a single parameter called text which is the string to be checked. The string will be internally converted to an int (or something else), and then it will be checked if all the values of that int are valid hexadecimal digits or not.

Note: ctype_xdigit is an EXPERIMENTAL function. The behaviour of this function, its name, and anything else documented about it may change in a future version of PHP without notice.

The ctype_xdigit function comes bundled with the other string and char type functions as part of the Ctype extension which is enabled by default in your PHP installation. However, some hosting providers might disable it for some crazy reason. In that case, you would need to ask them to enable it for your website.

ctype_xdigit example

        } else {
            $this->variant = $variant;
            $this->r = (int) $this->r;
            $this->g = (int) $this->g;
            $this->b = (int) $this->b;
            $this->a = (float) $this->a;
        }
    }

    protected function setValuesFromHex(string $hex): ?int
    {
        if (!\ctype_xdigit($hex)) {
            return null;
        }

        switch (\strlen($hex)) {
            case 3:
                $variant = self::COLOR_HEX_3;
                break;
            case 6:
                $variant = self::COLOR_HEX_6;
                break;
            case 4:

if (!ctype_print($temp[1]) || strpos($temp[1], ':') !== false) {
            return false;
        } else {
            $data['realm'] = $temp[1];
        }
        $temp = null;

        $ret = preg_match('/nonce="([^"]+)"/', $header, $temp);
        if (!$ret || empty($temp[1])) {
            return false;
        }
        if (!ctype_xdigit($temp[1])) {
            return false;
        } else {
            $data['nonce'] = $temp[1];
        }
        $temp = null;

        $ret = preg_match('/uri="([^"]+)"/', $header, $temp);
        if (!$ret || empty($temp[1])) {
            return false;
        }
        // Section 3.2.2.5 in RFC 2617 says the authenticating server must

if (!function_exists('ctype_punct')) {
    function ctype_punct(mixed $text): bool { return p\Ctype::ctype_punct($text); }
}
if (!function_exists('ctype_space')) {
    function ctype_space(mixed $text): bool { return p\Ctype::ctype_space($text); }
}
if (!function_exists('ctype_upper')) {
    function ctype_upper(mixed $text): bool { return p\Ctype::ctype_upper($text); }
}
if (!function_exists('ctype_xdigit')) {
    function ctype_xdigit(mixed $text): bool { return p\Ctype::ctype_xdigit($text); }
}

if (!function_exists('ctype_punct')) {
    function ctype_punct($text) { return p\Ctype::ctype_punct($text); }
}
if (!function_exists('ctype_space')) {
    function ctype_space($text) { return p\Ctype::ctype_space($text); }
}
if (!function_exists('ctype_upper')) {
    function ctype_upper($text) { return p\Ctype::ctype_upper($text); }
}
if (!function_exists('ctype_xdigit')) {
    function ctype_xdigit($text) { return p\Ctype::ctype_xdigit($text); }
}

if (strtolower($headers['transfer-encoding']) == 'chunked') {

                do {
                    $line  = @fgets($this->socket);
                    $this->_checkSocketReadTimeout();

                    $chunk = $line;

                    // Figure out the next chunk size                     $chunksize = trim($line);
                    if (! ctype_xdigit($chunksize)) {
                        $this->close();
                        throw new Zend_Http_Client_Adapter_Exception('Invalid chunk size "' .
                            $chunksize . '" unable to read chunked body');
                    }

                    // Convert the hexadecimal value to plain integer                     $chunksize = hexdec($chunksize);

                    // Read next chunk                     $read_to = ftell($this->socket) + $chunksize;

public function decimal(?string $str = null): bool
    {
        // @see https://regex101.com/r/HULifl/2/         return (bool) preg_match('/\A[-+]?\d{0,}\.?\d+\z/', $str ?? '');
    }

    /** * String of hexidecimal characters */
    public function hex(?string $str = null): bool
    {
        return ctype_xdigit($str ?? '');
    }

    /** * Integer */
    public function integer(?string $str = null): bool
    {
        return (bool) preg_match('/\A[\-+]?\d+\z/', $str ?? '');
    }

    /** * Is a Natural number (0,1,2,3, etc.) */

continue;
            }

            // Missing hyphens are ignored             if ($i === $h) {
                $h += 4;
                --$l;
            }

            // Check characters             if (!ctype_xdigit($trimmed[$i])) {
                $this->context->buildViolation($constraint->message)
                    ->setParameter('{{ value }}', $this->formatValue($value))
                    ->setCode(Uuid::INVALID_CHARACTERS_ERROR)
                    ->addViolation();

                return;
            }
        }

        // Check length again         if (isset($trimmed[$i])) {

    public function isValid($value)
    {
        if (!is_string($value) && !is_int($value)) {
            $this->_error(self::INVALID);
            return false;
        }

        $this->_setValue($value);
        if (!ctype_xdigit((string) $value)) {
            $this->_error(self::NOT_HEX);
            return false;
        }

        return true;
    }

}