To safely shorten a UTF-8 string in PHP with multibyte characters, use mbstring functions like mb_substr() with explicit UTF-8 encoding instead of substr(), avoid falling back unless input is ASCII-only, handle byte-length truncation carefully by backtracking to valid UTF-8 boundaries using functions like safe_truncate_bytes(), and for visual integrity, consider grapheme_substr() from the Intl extension for handling grapheme clusters such as emojis with modifiers.

When you need to shorten a UTF-8 string in PHP, especially one that might contain multibyte characters like emojis or characters from non-Latin alphabets (e.g., Chinese, Japanese, Cyrillic), doing it the wrong way can result in broken characters or invalid strings. The key is to use functions that understand multibyte encodings rather than assuming each character is a single byte.

Use mbstring Functions Instead of Default String Functions

PHP’s default string manipulation functions like substr() assume each character is exactly one byte, which isn’t true for many UTF-8 characters. For example, an emoji like ? takes up 4 bytes in UTF-8. Using substr() on such a string could cut it off mid-byte-sequence and leave you with garbage.

Instead, always use the mb_ prefixed functions from the mbstring extension, particularly mb_substr():

mb_substr($text, 0, $length, 'UTF-8');

Make sure to specify 'UTF-8' as the encoding parameter — don't rely on defaults, especially if your code might run in different environments.

• Always check if mbstring is enabled using function_exists('mb_substr')
• Avoid falling back to substr() unless you're certain the input is ASCII-only

Be Careful with Byte Length vs Character Length

Sometimes, you might want to truncate based on byte size instead of character count — for example, when storing data in a field with a byte limit. In that case, you have to be extra cautious not to split multibyte sequences.

One safe approach is to start truncating at a byte position slightly below your limit and then backtrack until you find a valid UTF-8 start byte:

function safe_truncate_bytes($str, $maxBytes) {
    if (strlen($str) <= $maxBytes) return $str;

    $head = substr($str, 0, $maxBytes);
    $lastValidPos = mb_strlen($head, 'UTF-8');

    while ($lastValidPos > 0) {
        $candidate = mb_substr($str, 0, $lastValidPos, 'UTF-8');
        if (mb_check_encoding($candidate, 'UTF-8')) {
            return $candidate;
        }
        $lastValidPos--;
    }

    return '';
}

This ensures that even if you cut off part of a multibyte character, you roll back to the last complete character.

Handle Edge Cases Like Emojis and Grapheme Clusters

Even with mb_substr(), there are cases where what appears to be one character is actually made up of multiple Unicode code points — for example, skin tone modifiers or flag emojis. These aren't handled correctly by mbstring.

If you really need to preserve visual character integrity (like cutting by visible graphemes), consider using the Intl extension and grapheme_substr():

if (function_exists('grapheme_substr')) {
    $shortened = grapheme_substr($text, 0, $charLimit);
}

This is more accurate for user-facing display truncation but comes with heavier dependencies.

So yes, safely truncating a UTF-8 string in PHP involves more than just slicing it. It means respecting multibyte boundaries, being aware of encoding, and sometimes thinking about how characters are visually composed. Once you get these basics right, it's not too bad — just make sure you test with some real-world examples like emojis, accented letters, and non-Latin scripts.

The above is the detailed content of How to safely truncate a multibyte UTF-8 string in PHP. For more information, please follow other related articles on the PHP Chinese website!