mb_convert_encoding - PHP code example

The php Function mb_Convert_Encoding

The php function mb_convert_encoding converts a string from one character encoding to another. The function takes in three parameters: the string to convert, the encoding to convert to and the encoding from which to convert. The function can take in an array and recursively convert all strings within the array. The function will return the encoded string if successful, else it will return false.

This function is a very useful tool when working with web pages and databases that require you to convert text from different encodings. However, it can also lead to bugs and erroneous output if used incorrectly.

mb_convert_encoding allows characters to pass that would otherwise be rejected by other PHP functions, such as mb_check_encoding() and mb_detect_encoding(). This means that high Unicode code points outside of the Basic Multilingual Plane and characters composed of four or more bytes (such as hieroglyhps and cuneiform) can get through to your database or other web services. It also allows multi-byte sequences that exceed the maximum number of allowed bytes in a UTF-8 sequence (which is not the same as the total amount of bytes allowed for a string, see here).

The solution to this problem is to use mb_convert_encoding with the flag mb_multibyte enabled and with the option translit set to true. With this option, the function will attempt to translate all non-ASCII characters into their ASCII equivalents in 7bit format. This will remove many of the problems that can occur such as German umlauted characters (à, ç, é, î etc) being rendered as ß in 7bit context and Dutch ligatures like ÿ.

mb_convert_encoding example

/** * Class constructor * * @param string $selector Selector string * @param array $options Options array. See Query class * documentation for available options */
    public function __construct($selector, $options = array())
    {
        $encoding = isset($options["encoding"]) ? $options["encoding"] : null;
        if ($encoding && !preg_match("/UTF-?8/i", $encoding)) {
            $selector = mb_convert_encoding($selector, "UTF-8", $encoding);
        }
        $this->selector = $selector;
        $this->length = strlen($selector);
    }

    /** * Starts the parsing and returns the parsed selector * * @param bool $filter True if the selector must be used for a filter * * @return Node\Selector * * @throws Exception */

if ($output === 'Windows-31J')
        {
            $output = 'SJIS';
        }

        // Check that the encoding is supported         if (!in_array($input, mb_list_encodings()))
        {
            return false;
        }

        if (@mb_convert_encoding("\x80", 'UTF-16BE', $input) === "\x00\x80")
        {
            return false;
        }

        // Let's do some conversion         if ($return = @mb_convert_encoding($data, $output, $input))
        {
            return $return;
        }

        return false;
    }

if ($exportBehavior->batchMode()) {
                break;
            }
        }
        $content .= $this->seoUrlPlaceholderHandler->replace($body, $productExport->getSalesChannelDomain()->getUrl(), $context);

        if ($exportBehavior->generateFooter()) {
            $content .= $this->productExportRender->renderFooter($productExport, $context);
        }

        $encodingEvent = $this->eventDispatcher->dispatch(
            new ProductExportChangeEncodingEvent($productExport, $content, mb_convert_encoding($content, $productExport->getEncoding()))
        );

        $this->translator->resetInjection();

        $this->connection->delete('sales_channel_api_context', ['token' => $contextToken]);

        if (empty($content)) {
            return null;
        }

        return new ProductExportResult(

/** * Format snippet for export * * @param string $string * @param string $encoding * * @return string */
    protected function getFormatSnippetForExport($string, $encoding = 'utf-8')
    {
        if ($encoding !== 'utf-8') {
            $string = mb_convert_encoding($string, $encoding, 'UTF-8');
        }

        return $string;
    }

    /** * Format snippet for save * * @param string $string * * @return string */

use Symfony\Polyfill\Mbstring as p;

if (!function_exists('mb_convert_encoding')) {
    function mb_convert_encoding(array|string|null $string, ?string $to_encoding, array|string|null $from_encoding = null): array|string|false { return p\Mbstring::mb_convert_encoding($string ?? '', (string) $to_encoding, $from_encoding); }
}
if (!function_exists('mb_decode_mimeheader')) {
    function mb_decode_mimeheader(?string $string): string { return p\Mbstring::mb_decode_mimeheader((string) $string); }
}
if (!function_exists('mb_encode_mimeheader')) {
    function mb_encode_mimeheader(?string $string, ?string $charset = null, ?string $transfer_encoding = null, ?string $newline = "\r\n", ?int $indent = 0): string { return p\Mbstring::mb_encode_mimeheader((string) $string, $charset, $transfer_encoding, (string) $newline, (int) $indent); }
}
if (!function_exists('mb_decode_numericentity')) {
    function mb_decode_numericentity(?string $string, array $map, ?string $encoding = null): string { return p\Mbstring::mb_decode_numericentity((string) $string, $map, $encoding); }
}
if (!function_exists('mb_encode_numericentity')) {

    protected function getType(&$value): int
    {
        $encoded = $value;

        if (mb_detect_encoding($value, 'auto', true) !== 'UTF-8') {
            $encoded = mb_convert_encoding($value, 'UTF-8', 'Windows-1252');
        }

        if ($this->isValid($encoded)) {
            return $this->charValue[$encoded];
        }

        if ($this->isNullType($encoded)) {
            return self::C_NUL;
        }

        if ($this->isInvalidChar($encoded)) {

/** * get Content-Disposition Header string. */
    private function getContentDisposition(): string
    {
        $downloadFilename = $this->getDownloadFileName();

        $utf8Filename = $downloadFilename;

        if (strtoupper($this->charset) !== 'UTF-8') {
            $utf8Filename = mb_convert_encoding($downloadFilename, 'UTF-8', $this->charset);
        }

        $result = sprintf('attachment; filename="%s"', $downloadFilename);

        if ($utf8Filename) {
            $result .= '; filename*=UTF-8\'\'' . rawurlencode($utf8Filename);
        }

        return $result;
    }

/** * Converts a non UTF-8 string into an UTF-8 string * * @param string|array $data * @param string $encoding * * @return string|array */
    protected function convertToUtf8($data, $encoding)
    {
        if (\is_string($data)) {
            $data = mb_convert_encoding($data, 'UTF-8', $encoding);
        } elseif (\is_array($data)) {
            foreach ($data as $key => $value) {
                $data[$this->convertToUtf8($key, $encoding)] = $this->convertToUtf8($value, $encoding);
            }
        }

        return $data;
    }

    /** * Embedded a JSON object into a callback function * * @param string $data * @param string $callback * * @return string */

    static public function stringToUTF8Array($str, $strictEncoding = true)
    {
        if ($str === "") {
            return array();
        }
        $ret = preg_split('//u', $str, -1, PREG_SPLIT_NO_EMPTY);
        if (preg_last_error() === PREG_BAD_UTF8_ERROR) {
            if (!$strictEncoding) {
                $str = mb_convert_encoding($str, 'UTF-8', 'UTF-8');
                $ret = self::stringToUTF8Array($str, false);
            } else {
                throw new EncodingException("String contains invalid UTF-8");
            }
        }
        return $ret;
    }

    /** * Converts an unicode code point to UTF-8 * * @param int $num Unicode code point * * @return string * * @codeCoverageIgnore */

if (null === $toEncoding || $toEncoding === $fromEncoding = $this instanceof AbstractUnicodeString || preg_match('//u', $b->string) ? 'UTF-8' : 'Windows-1252') {
            $b->string = $this->string;

            return $b;
        }

        set_error_handler(static function D$t, $m) { throw new InvalidArgumentException($m); });

        try {
            try {
                $b->string = mb_convert_encoding($this->string, $toEncoding, 'UTF-8');
            } catch (InvalidArgumentException $e) {
                if (!\function_exists('iconv')) {
                    throw $e;
                }

                $b->string = iconv('UTF-8', $toEncoding, $this->string);
            }
        } finally {
            restore_error_handler();
        }

$progress->addProcessedRecords(1);

                $afterRecord = new ImportExportAfterImportRecordEvent($result, $record, $row, $config, $context);
                $this->eventDispatcher->dispatch($afterRecord);
            } catch (\Throwable $exception) {
                $event = new ImportExportExceptionImportRecordEvent($exception, $record, $row, $config, $context);
                $this->eventDispatcher->dispatch($event);

                $exception = $event->getException();

                if ($exception) {
                    $record['_error'] = mb_convert_encoding($exception->getMessage(), 'UTF-8', 'UTF-8');
                    $failedRecords[] = $record;
                }
            }

            if ($this->logEntity->getActivity() === ImportExportLogEntity::ACTIVITY_DRYRUN) {
                $this->connection->rollBack();
            }

            $this->importExportService->saveProgress($progress);

            $overallResults = $this->logResults($overallResults, $result, $this->repository->getDefinition()->getEntityName());

return $u;
            }
        } finally {
            restore_error_handler();
        }

        if (!$validEncoding) {
            throw new InvalidArgumentException(sprintf('Invalid "%s" string.', $fromEncoding ?? 'Windows-1252'));
        }

        $u->string = mb_convert_encoding($this->string, 'UTF-8', $fromEncoding ?? 'Windows-1252');

        return $u;
    }

    public function trim(string $chars = " \t\n\r\0\x0B\x0C"): static
    {
        $str = clone $this;
        $str->string = trim($str->string, $chars);

        return $str;
    }

public function testValidPassword()
    {
        $this->validator->validate(self::PASSWORD_NOT_LEAKED, new NotCompromisedPassword());

        $this->assertNoViolation();
    }

    public function testNonUtf8CharsetValid()
    {
        $validator = new NotCompromisedPasswordValidator($this->createHttpClientStub(), 'ISO-8859-5');
        $validator->validate(mb_convert_encoding(self::PASSWORD_NON_UTF8_NOT_LEAKED, 'ISO-8859-5', 'UTF-8'), new NotCompromisedPassword());

        $this->assertNoViolation();
    }

    public function testNonUtf8CharsetInvalid()
    {
        $constraint = new NotCompromisedPassword();

        $this->context = $this->createContext();

        $validator = new NotCompromisedPasswordValidator($this->createHttpClientStub(), 'ISO-8859-5');

function _wp_json_convert_string( $input_string ) {
    static $use_mb = null;
    if ( is_null( $use_mb ) ) {
        $use_mb = function_exists( 'mb_convert_encoding' );
    }

    if ( $use_mb ) {
        $encoding = mb_detect_encoding( $input_string, mb_detect_order(), true );
        if ( $encoding ) {
            return mb_convert_encoding( $input_string, 'UTF-8', $encoding );
        } else {
            return mb_convert_encoding( $input_string, 'UTF-8', 'UTF-8' );
        }
    } else {
        return wp_check_invalid_utf8( $input_string, true );
    }
}

/** * Prepares response data to be serialized to JSON. * * This supports the JsonSerializable interface for PHP 5.2-5.3 as well. * * @ignore * @since 4.4.0 * @deprecated 5.3.0 This function is no longer needed as support for PHP 5.2-5.3 * has been dropped. * @access private * * @param mixed $data Native representation. * @return bool|int|float|null|string|array Data ready for `json_encode()`. */

if (null === $toEncoding || $toEncoding === $fromEncoding = $this instanceof AbstractUnicodeString || preg_match('//u', $b->string) ? 'UTF-8' : 'Windows-1252') {
            $b->string = $this->string;

            return $b;
        }

        set_error_handler(static fn ($t, $m) => throw new InvalidArgumentException($m));

        try {
            try {
                $b->string = mb_convert_encoding($this->string, $toEncoding, 'UTF-8');
            } catch (InvalidArgumentException $e) {
                if (!\function_exists('iconv')) {
                    throw $e;
                }

                $b->string = iconv('UTF-8', $toEncoding, $this->string);
            }
        } finally {
            restore_error_handler();
        }