PHP count_chars() Function

What You’ll Learn

The count_chars() function analyzes a string at the byte level, counting how often each value from 0 to 255 appears. With five modes, it can return full frequency tables, compact maps, or strings of unique characters—ideal for validation, puzzles, and text analysis.

Definition and Usage

In PHP, count_chars() scans every byte in a string and records how many times each byte value occurs. Array keys are numeric ASCII/byte values (use chr() to convert them to characters). Mode 1 is the most practical—it returns only bytes that actually appear, keeping the result small and readable.

📝 Syntax

The count_chars() function accepts a string and an optional mode:

array|string count_chars(string $string, int $mode = 0)

Parameters

• $string — the string to analyze.
• $mode (optional, default 0) — controls the return format. See the mode table below.

Return Value by Mode

• Mode 0 — array with all 256 byte values (0–255) as keys and their frequencies as values.
• Mode 1 — same as mode 0, but only bytes with a frequency greater than zero are included. Most commonly used.
• Mode 2 — same as mode 0, but only bytes with a frequency equal to zero (bytes not present in the string).
• Mode 3 — a string containing all unique characters used, ordered by ascending byte value.
• Mode 4 — a string containing all byte characters not used in the string (can be very long).

Examples Gallery

Run these examples in PHP 7+. Each demonstrates a common pattern beginners encounter with count_chars().

<?php
$string = "CodeToFun";
$counts = count_chars($string, 1);

print_r($counts);
?>

Array
(
    [67] => 1
    [70] => 1
    [84] => 1
    [100] => 1
    [101] => 1
    [110] => 1
    [111] => 2
    [117] => 1
)

<?php
$data = "Two Ts and one F.";

foreach (count_chars($data, 1) as $byte => $count) {
    echo "There were $count instance(s) of \"" . chr($byte) . "\" in the string.\n";
}
?>

There were 4 instance(s) of " " in the string.
There were 1 instance(s) of "." in the string.
There were 1 instance(s) of "F" in the string.
There were 2 instance(s) of "T" in the string.
There were 1 instance(s) of "a" in the string.
There were 1 instance(s) of "d" in the string.
There were 1 instance(s) of "e" in the string.
There were 2 instance(s) of "n" in the string.
There were 2 instance(s) of "o" in the string.
There were 1 instance(s) of "s" in the string.
There were 1 instance(s) of "w" in the string.

<?php
$string = "Mississippi";
$all    = count_chars($string, 0);

echo "Total bytes:     " . array_sum($all) . "\n";
echo "Letter 'i' count: " . $all[ord('i')] . "\n";
echo "Letter 's' count: " . $all[ord('s')] . "\n";
echo "Letter 'M' count: " . $all[ord('M')] . "\n";
echo "Array size:      " . count($all) . " keys (always 256)\n";
?>

Total bytes:     11
Letter 'i' count: 4
Letter 's' count: 4
Letter 'M' count: 1
Array size:      256 keys (always 256)

<?php
$words = ["hello", "world", "php"];

foreach ($words as $word) {
    $unique = count_chars($word, 3);
    echo "$word => unique: \"$unique\" (" . strlen($unique) . " chars)\n";
}
?>

hello => unique: "ehlo" (4 chars)
world => unique: "dlorw" (5 chars)
php => unique: "hp" (2 chars)

<?php
function isAnagram(string $a, string $b): bool
{
    return count_chars($a, 1) === count_chars($b, 1);
}

$pairs = [
    ["act", "cat"],
    ["listen", "silent"],
    ["hello", "world"],
];

foreach ($pairs as [$w1, $w2]) {
    $result = isAnagram($w1, $w2) ? "yes" : "no";
    echo "$w1 / $w2 => anagram: $result\n";
}
?>

act / cat => anagram: yes
listen / silent => anagram: yes
hello / world => anagram: no

🚀 Common Use Cases

• Password validation — require a minimum number of unique characters with count(count_chars($pass, 1)).
• Anagram puzzles — compare frequency maps to check if two words use the same letters.
• Input validation — verify a string contains only allowed ASCII characters (modes 2 or 4).
• Text analysis — find the most frequent letters in a corpus or log file.
• Palindrome helpers — analyze character counts when building palindrome checkers.

📝 Notes

• count_chars() analyzes bytes, not Unicode code points. Multibyte UTF-8 characters are split into separate byte counts.
• Uppercase and lowercase letters are counted separately (A ≠ a).
• Mode 0 always returns 256 keys—avoid print_r() on large mode 0 arrays in production logs; use mode 1 instead.
• Mode 4 can return a string with hundreds of characters (all bytes not in the input).
• For counting one specific substring, use substr_count() instead.

💡 Best Practices