Why can't objects in an array be counted?

M66 2025-06-07

PHP is a widely used server-side programming language that provides powerful array processing capabilities, where the array_count_values function is a very common and useful function. The function of the array_count_values function is to count the frequency of occurrence of all elements in the array. It returns an array where the key is the element in the original array and the value is the number of occurrences of the element. However, when dealing with arrays containing objects, you may encounter some unexpected behavior, resulting in inaccurate statistical results, especially for arrays of objects.

1. How the array_count_values function works

The basic function of the array_count_values function is to iterate through the array and count the number of occurrences of each element, and the result is returned in the form of key-value pairs. For example, suppose we have a simple array:

 $array = ['apple', 'banana', 'apple', 'orange', 'banana', 'banana'];
$result = array_count_values($array);
print_r($result);

The output will be:

 Array
(
    [apple] => 2
    [banana] => 3
    [orange] => 1
)

As you can see, array_count_values correctly counts the number of occurrences of each element.

2. Why do objects in an array cause inaccurate counting?

When we store objects in a PHP array, the array_count_values function may not behave as expected. This is because objects are passed by reference, while objects in PHP are compared by their memory address (not their value). This means that even if two objects look the same, their memory addresses are different and therefore they will be considered different objects.

Let's look at a simple example:

 class Fruit {
    public $name;
    public function __construct($name) {
        $this->name = $name;
    }
}

$apple1 = new Fruit('apple');
$apple2 = new Fruit('apple');

$array = [$apple1, $apple2, $apple1];
$result = array_count_values($array);
print_r($result);

The output result is:

 Array
(
    Object(Fruit)#1 => 2
    Object(Fruit)#2 => 1
)

Although we have two apple objects with the same name, since they are two different instances (i.e., different memory addresses), array_count_values treats them as different elements and counts them separately.

3. The specific impact of array_count_values and object array

When we try to process an array containing objects using array_count_values , it counts the memory address of each object, not the actual content of the object. This can lead to the following problems:

If you have multiple instances of the object with the same content, they will be counted as different terms, resulting in inaccurate counting results.
If you use multiple object instances of the same class, array_count_values will not treat them as the same elements even if the properties of these objects are exactly the same.

4. How to solve this problem?

In order to correctly process an array containing objects, the following methods can be taken:

Rewrite the __toString method :

If the object has a unique string representation (such as the object's property value), you can override the object's __toString method to convert the object into a string, so that array_count_values can be counted based on the string.

 class Fruit {
    public $name;
    public function __construct($name) {
        $this->name = $name;
    }
    public function __toString() {
        return $this->name;
    }
}

$apple1 = new Fruit('apple');
$apple2 = new Fruit('apple');
$array = [$apple1, $apple2, $apple1];
$result = array_count_values($array);
print_r($result);

The output result will be:

 Array
(
    [apple] => 3
)

This allows you to correctly count objects of the same name.

Use array_map and serialize :
If you want to not rely on the __toString method, you can use serialize to convert the object to a string and then use array_count_values for counting.
```
 $array = [serialize($apple1), serialize($apple2), serialize($apple1)];
$result = array_count_values($array);
print_r($result);
```
The output will be:
```
 Array
(
    [O:6:"Fruit:..."] => 3
)
```
In this method, we convert the object into a unique string by serialize , so that array_count_values can correctly calculate the number of times the same object.

5. Summary

When you use array_count_values to process an array containing objects, array_count_values may not correctly count objects with the same content because objects are compared by memory addresses. This problem can be effectively solved by overwriting the __toString method or using the serialize method, and array_count_values correctly counts elements in the object array.

array_count_values