mb_check_encoding - PHP code example

Using the PHP Function mb_check_encoding

With the release of PHP 5.0, the mbstring extension introduced a new way to handle multibyte strings. As well as iconv, this has a number of functions that are used to determine whether a sequence of characters is valid for the given encoding scheme and others that perform search oriented operations on such string sequences.

One of these is the mb_check_encoding function. It accepts two parameters, the encoding and the string to check for. It returns either a list of all the matching characters or FALSE if the string is not valid for the given encoding. This is similar to the strlen() function that is used in conjunction with the iconv functions to get a list of all the characters in a string.

As you might imagine, it is very useful to be able to use this function to validate UTF-8 sequences of characters, as they do not necessarily behave as expected when they are converted from other encodings. For example, they might fail to be correctly translated by JSON, or they might not be valid if the string is being used as an input into a database.

Another interesting mb_check_encoding function is mb_stripos. This function takes the string to look for, the needle, and a haystack string to search for it in, and return the position of the first occurrence of the needle within the haystack string. This function works in a very different manner to standard case folding functions, such as strtolower and strtoupper, as it uses Unicode character properties rather than alphabetic ordering.

mb_check_encoding example

if (!function_exists('mb_language')) {
    function mb_language($language = null) { return p\Mbstring::mb_language($language); }
}
if (!function_exists('mb_list_encodings')) {
    function mb_list_encodings() { return p\Mbstring::mb_list_encodings(); }
}
if (!function_exists('mb_encoding_aliases')) {
    function mb_encoding_aliases($encoding) { return p\Mbstring::mb_encoding_aliases($encoding); }
}
if (!function_exists('mb_check_encoding')) {
    function mb_check_encoding($value = null, $encoding = null) { return p\Mbstring::mb_check_encoding($value, $encoding); }
}
if (!function_exists('mb_detect_encoding')) {
    function mb_detect_encoding($string, $encodings = null, $strict = false) { return p\Mbstring::mb_detect_encoding($string, $encodings, $strict); }
}
if (!function_exists('mb_detect_order')) {
    function mb_detect_order($encoding = null) { return p\Mbstring::mb_detect_order($encoding); }
}
if (!function_exists('mb_parse_str')) {
    function mb_parse_str($string, &$result = []) { parse_str($string, $result); return (bool) $result; }
}
if (!function_exists('mb_strlen')) {

if (!\is_scalar($value) && !$value instanceof \Stringable) {
            throw new UnexpectedValueException($value, 'string');
        }

        $stringValue = (string) $value;

        if (null !== $constraint->normalizer) {
            $stringValue = ($constraint->normalizer)($stringValue);
        }

        try {
            $invalidCharset = !@mb_check_encoding($stringValue, $constraint->charset);
        } catch (\ValueError $e) {
            if (!str_starts_with($e->getMessage(), 'mb_check_encoding(): Argument #2 ($encoding) must be a valid encoding')) {
                throw $e;
            }

            $invalidCharset = true;
        }

        $length = $invalidCharset ? 0 : match ($constraint->countUnit) {
            Length::COUNT_BYTES => \strlen($stringValue),
            Length::COUNT_CODEPOINTS => mb_strlen($stringValue, $constraint->charset),

    protected function checkEncoding($value)
    {
        if (is_array($value)) {
            array_map([$this, 'checkEncoding'], $value);

            return $value;
        }

        if (mb_check_encoding($value, 'UTF-8')) {
            return $value;
        }

        throw SecurityException::forInvalidUTF8Chars($this->source, $value);
    }

    /** * Check for the presence of control characters except line breaks and tabs. * * @param array|string $value * * @return array|string */

/** * Normalizes a cache ID in order to comply with database limitations. * * @param string $cid * The passed in cache ID. * * @return string * An ASCII-encoded cache ID that is at most 255 characters long. */
  protected function normalizeLockName($cid) {
    // Nothing to do if the ID is a US ASCII string of 255 characters or less.     $cid_is_ascii = mb_check_encoding($cid, 'ASCII');
    if (strlen($cid) <= 255 && $cid_is_ascii) {
      return $cid;
    }
    // Return a string that uses as much as possible of the original cache ID     // with the hash appended.     $hash = Crypt::hashBase64($cid);
    if (!$cid_is_ascii) {
      return $hash;
    }
    return substr($cid, 0, 255 - strlen($hash)) . $hash;
  }

/** * Normalizes a lock name in order to comply with database limitations. * * @param string $name * The passed in lock name. * * @return string * An ASCII-encoded lock name that is at most 255 characters long. */
  protected function normalizeName($name) {
    // Nothing to do if the name is a US ASCII string of 255 characters or less.     $name_is_ascii = mb_check_encoding($name, 'ASCII');

    if (strlen($name) <= 255 && $name_is_ascii) {
      return $name;
    }
    // Return a string that uses as much as possible of the original name with     // the hash appended.     $hash = Crypt::hashBase64($name);

    if (!$name_is_ascii) {
      return $hash;
    }

/** * Normalizes a cache ID in order to comply with database limitations. * * @param string $cid * The passed in cache ID. * * @return string * An ASCII-encoded cache ID that is at most 255 characters long. */
  protected function normalizeCid($cid) {
    // Nothing to do if the ID is a US ASCII string of 255 characters or less.     $cid_is_ascii = mb_check_encoding($cid, 'ASCII');
    if (strlen($cid) <= 255 && $cid_is_ascii) {
      return $cid;
    }
    // Return a string that uses as much as possible of the original cache ID     // with the hash appended.     $hash = Crypt::hashBase64($cid);
    if (!$cid_is_ascii) {
      return $hash;
    }
    return substr($cid, 0, 255 - strlen($hash)) . $hash;
  }

if (!function_exists('mb_language')) {
    function mb_language(?string $language = null): string|bool { return p\Mbstring::mb_language($language); }
}
if (!function_exists('mb_list_encodings')) {
    function mb_list_encodings(): array { return p\Mbstring::mb_list_encodings(); }
}
if (!function_exists('mb_encoding_aliases')) {
    function mb_encoding_aliases(?string $encoding): array { return p\Mbstring::mb_encoding_aliases((string) $encoding); }
}
if (!function_exists('mb_check_encoding')) {
    function mb_check_encoding(array|string|null $value = null, ?string $encoding = null): bool { return p\Mbstring::mb_check_encoding($value, $encoding); }
}
if (!function_exists('mb_detect_encoding')) {
    function mb_detect_encoding(?string $string, array|string|null $encodings = null, ?bool $strict = false): string|false { return p\Mbstring::mb_detect_encoding((string) $string, $encodings, (bool) $strict); }
}
if (!function_exists('mb_detect_order')) {
    function mb_detect_order(array|string|null $encoding = null): array|bool { return p\Mbstring::mb_detect_order($encoding); }
}
if (!function_exists('mb_parse_str')) {
    function mb_parse_str(?string $string, &$result = []): bool { parse_str((string) $string, $result); return (bool) $result; }
}
if (!function_exists('mb_strlen')) {

/** * Converts emoji to a static img element. * * @since 4.2.0 * * @param string $text The content to encode. * @return string The encoded content. */
function wp_staticize_emoji( $text ) {
    if ( ! str_contains( $text, '&#x' ) ) {
        if ( ( function_exists( 'mb_check_encoding' ) && mb_check_encoding( $text, 'ASCII' ) ) || ! preg_match( '/[^\x00-\x7F]/', $text ) ) {
            // The text doesn't contain anything that might be emoji, so we can return early.             return $text;
        } else {
            $encoded_text = wp_encode_emoji( $text );
            if ( $encoded_text === $text ) {
                return $encoded_text;
            }

            $text = $encoded_text;
        }
    }

    protected function check_ascii( $input_string ) {
        if ( function_exists( 'mb_check_encoding' ) ) {
            if ( mb_check_encoding( $input_string, 'ASCII' ) ) {
                return true;
            }
        } elseif ( ! preg_match( '/[^\x00-\x7F]/', $input_string ) ) {
            return true;
        }

        return false;
    }

    /** * Checks if the query is accessing a collation considered safe on the current version of MySQL. * * @since 4.2.0 * * @param string $query The query to check. * @return bool True if the collation is safe, false if it isn't. */

public function punyencodeAddress($address)
    {
        //Verify we have required functions, CharSet, and at-sign.         $pos = strrpos($address, '@');
        if (
            !empty($this->CharSet) &&
            false !== $pos &&
            static::idnSupported()
        ) {
            $domain = substr($address, ++$pos);
            //Verify CharSet string is a valid one, and domain properly encoded in this CharSet.             if ($this->has8bitChars($domain) && @mb_check_encoding($domain, $this->CharSet)) {
                //Convert the domain from whatever charset it's in to UTF-8                 $domain = mb_convert_encoding($domain, self::CHARSET_UTF8, $this->CharSet);
                //Ignore IDE complaints about this line - method signature changed in PHP 5.4                 $errorcode = 0;
                if (defined('INTL_IDNA_VARIANT_UTS46')) {
                    //Use the current punycode standard (appeared in PHP 7.2)                     $punycode = idn_to_ascii(
                        $domain,
                        \IDNA_DEFAULT | \IDNA_USE_STD3_RULES | \IDNA_CHECK_BIDI |
                            \IDNA_CHECK_CONTEXTJ | \IDNA_NONTRANSITIONAL_TO_ASCII,
                        \INTL_IDNA_VARIANT_UTS46
                    );