PHP count(): Get the Length of an Array

count($arr) returns the number of elements in an array: count(['red', 'green', 'blue']) is 3. PHP arrays have no length property, so count() is how you get an array's length or size.

<?php
$fruits = ['apple', 'banana', 'cherry'];
echo count($fruits), "\n";

$fruits[] = 'date';
echo count($fruits), "\n";

echo count([]), "\n";                          // empty array
echo count(['a' => 1, 'b' => 2]), "\n";        // keys of any kind

count() is fast: PHP stores the size inside the array, so counting a million elements costs the same as counting three.

Count a multidimensional array

By default count() counts only the top level. Pass COUNT_RECURSIVE (or 1) as the second argument to count every element at every depth. The nested arrays themselves are counted too, which is why the total is often larger than the number of leaf values.

<?php
$teams = [
    'red'  => ['Ada', 'Linus'],
    'blue' => ['Grace', 'Margaret', 'Alan'],
];

echo count($teams), "\n";                    // 2 teams
echo count($teams, COUNT_RECURSIVE), "\n";   // 2 teams + 5 names

// Only the leaf values
echo count($teams, COUNT_RECURSIVE) - count($teams), "\n";
echo array_sum(array_map('count', $teams)), "\n";

Both shortcuts assume exactly two levels. For deeper nesting in a multidimensional array, count the leaves with array_walk_recursive(): $n = 0; array_walk_recursive($arr, function () use (&$n) { $n++; });.

count vs sizeof

sizeof() is an alias of count(): same arguments, same result. Use count(). It is what almost all PHP code and documentation uses, and sizeof suggests a size in bytes to anyone who knows C.

<?php
$items = [1, 2, 3, 4];

echo count($items), "\n";
echo sizeof($items), "\n";
echo sizeof($items) === count($items) ? "same\n" : "different\n";

Count values that match a condition

count() has no condition argument. Filter first, then count: array_filter() keeps the elements your callback accepts. To count how many times each value appears, use array_count_values().

<?php
$scores = [45, 82, 67, 91, 38, 74];

$passed = count(array_filter($scores, fn($s) => $s >= 50));
echo "$passed of ", count($scores), " passed\n";

$answers = ['yes', 'no', 'yes', 'maybe', 'yes'];
$tally = array_count_values($answers);
print_r($tally);
echo $tally['yes'], "\n";

Count characters in a string

count() is for arrays. For a string, use strlen() for bytes or mb_strlen() for characters; they differ as soon as the text has accents or Japanese. The strlen page covers the difference. To count words, split first.

<?php
$text = 'naïve café au lait';

echo strlen($text), "\n";             // bytes: ï and é take two each
echo mb_strlen($text), "\n";          // characters
echo str_word_count($text), "\n";     // words (ASCII letters only)
echo count(explode(' ', $text)), "\n"; // pieces split on spaces

str_word_count() treats non-ASCII letters as separators, so naïve counts as two words. Splitting on spaces is more predictable for real text.

count() on null or a string throws

Since PHP 8, count() accepts only arrays and objects that implement Countable. Anything else throws a TypeError, where PHP 7.2 to 7.4 returned 0 (for null) or 1 (for a string or number) with a warning. The usual cause is a variable that is sometimes null, such as a missing key or a function that returned nothing.

<?php
// This throws a TypeError on purpose
$tags = null;
echo count($tags);

Default the value to an empty array with ??, and the count is 0:

<?php
$post = ['title' => 'Hello'];        // no 'tags' key

echo count($post['tags'] ?? []), "\n";

$tags = null;
echo count($tags ?? []), "\n";

echo is_countable($tags) ? count($tags) : 0, "\n";

Check if an array is empty

To ask "does this array have anything in it", compare with an empty array or use empty(). count($arr) === 0 works too, but only when $arr is certainly an array.

<?php
$cart = [];

if ($cart === []) {
    echo "Your cart is empty\n";
}

var_dump(empty($cart));
var_dump(count($cart) > 0);

$cart[] = 'book';
var_dump(empty($cart));

empty($x) never throws, even when $x is undefined or null, which makes it the safer check for a value that might not be an array. Its other rules (an empty string and "0" are empty too) are on the empty page.