Characters and bytes are not the same in PHP because UTF-8 encoding uses 1 to 4 bytes per character, so functions like strlen() and substr() can miscount or break strings; 1. always use mb_strlen($str, 'UTF-8') for accurate character count; 2. use mb_substr($str, 0, 3, 'UTF-8') to safely extract substrings without corrupting multibyte characters; 3. replace strpos() and strrpos() with mb_strpos() and mb_strrpos() for proper Unicode support; 4. enable the mbstring extension and set mb_internal_encoding('UTF-8') to ensure consistent handling of international text, especially with user input or non-ASCII content, preventing garbled output and ensuring reliable string operations.

When working with strings in PHP, many developers assume that a "character" and a "byte" are the same thing. This assumption can lead to subtle bugs, especially when dealing with non-ASCII text like emojis, accented characters, or languages such as Chinese, Arabic, or Russian. Understanding the difference between characters and bytes is essential for robust string manipulation in PHP.

Why Characters ≠ Bytes in PHP

A byte is a unit of data that holds 8 bits. In contrast, a character is a single symbol in a written language (like 'A', '?', or '中'). In ASCII, each character fits into one byte, so the two concepts align. But with modern multibyte encodings like UTF-8, one character can take 1 to 4 bytes.

For example:

• 'A' → 1 character, 1 byte (ASCII)
• '?' → 1 character, 2 bytes in UTF-8
• '?' → 1 character, 4 bytes in UTF-8

PHP’s default string functions (like strlen(), substr()) operate on bytes, not characters. This means they can break multibyte characters in half, leading to garbled output or incorrect lengths.

The Problem with Byte-Based Functions

Consider this code:

echo strlen('café'); // Returns 5, not 4

Even though 'café' has 4 characters, strlen() returns 5 because the 'é' uses 2 bytes in UTF-8.

Now imagine using substr():

echo substr('café', 0, 3); // May return 'caf' (safe)
echo substr('café', 0, 4); // Could return 'caf' — broken byte sequence

If you're slicing in the middle of a multibyte character, you end up with invalid UTF-8 — often displayed as (replacement character).

Use Multibyte Functions Instead

PHP provides the mbstring extension to handle strings correctly in UTF-8 and other encodings. Always use mb_* functions when dealing with user-generated or international text.

Common replacements:

• strlen() → mb_strlen($str, 'UTF-8')
• substr() → mb_substr($str, 0, 3, 'UTF-8')
• strpos() → mb_strpos($str, 'needle', 0, 'UTF-8')
• strrpos() → mb_strrpos($str, 'needle', 'UTF-8')

Example:

echo mb_strlen('café', 'UTF-8');     // 4
echo mb_substr('café', 0, 3, 'UTF-8'); // 'caf'

These functions treat the string as a sequence of characters, not bytes, and respect UTF-8 encoding boundaries.

When to Be Extra Careful

You should always use multibyte-safe functions in these scenarios:

• Handling user input (names, messages, comments)
• Working with non-English content
• Processing URLs, JSON, or API responses that may contain Unicode
• Any string slicing, counting, or searching involving dynamic or external data

Also, ensure mbstring is enabled in your PHP installation (extension=mbstring in php.ini), and consider setting the internal encoding:

mb_internal_encoding('UTF-8');

This sets the default encoding for all mb_* functions, reducing the need to specify it repeatedly.

Basically, the key takeaway is: don’t trust default string functions with Unicode. Characters and bytes aren’t interchangeable once you step outside ASCII. Use mbstring functions consistently, and your PHP string handling will be far more reliable — especially in a globalized application.

The above is the detailed content of Character vs. Byte: The Critical Distinction in PHP String Manipulation. For more information, please follow other related articles on the PHP Chinese website!