PHP 8.1.30 Released!

count

(PHP 4, PHP 5, PHP 7, PHP 8)

countConta gli elementi in una variabile, o le proprietà in un oggetto

Descrizione

count(mixed $var, int $mode = ?): int

Restituisce il numero di elementi in var, la quale è di norma un array, dal momento che qualsiasi altro oggetto avrà un elemento.

Per gli oggetti, se SPL è installato, è possibile agganciarsi a count() implementando l'interfaccia Countable. L'interfaccia ha esattamente un metodo, count(), che ritorna il valore restituito dalla funzione count().

Se var non è un array o un oggetto con l'interfaccia Countable implementata, verrà restituito 1 C'è una eccezione, se var è null, verrà restituito 0.

Nota: Il parametro opzionale mode è disponibile da PHP 4.2.0.

Se il parametro opzionale mode è impostato a COUNT_RECURSIVE (o 1), count() conterà ricorsivamente l'array. Questo è utile in particolare per contare tutti gli elementi di un array multidimensionale. Il valore di default per mode è 0. count() non identifica le ricorsioni infinite.

Attenzione

count() può restituire 0 per una variabile che non è impostata, ma può anche restituire 0 per una variabile che è stata inizializzata con un array vuoto. Usare isset() per verificare se una variabile è impostata.

Vedere la sezione Array nel manuale per una spiegazione dettagliata di come gli array siano implementati ed usati in PHP.

Example #1 esempio di count()

<?php
$a
[0] = 1;
$a[1] = 3;
$a[2] = 5;
$risultato = count($a);
//$risultato == 3

$b[0] = 7;
$b[5] = 9;
$b[10] = 11;
$risultato = count($b);
// $risultato == 3;

$result = count(null);
// $result == 0

$result = count(false);
// $result == 1
?>

Example #2 esempio di count() ricorsiva (PHP >= 4.2.0)

<?php
$cibo
= array('frutta' => array('arancia', 'banana', 'mela'),
'verdura' => array('carota', 'zucchina', 'piselli'));

// conteggio ricorsivo
echo count($cibp,COUNT_RECURSIVE); // output 8

// conteggio normale
echo count($cibo); // output 2

?>

Vedere anche is_array(), isset() e strlen().

add a note

User Contributed Notes 13 notes

up
141
onlyranga at gmail dot com
10 years ago
[Editor's note: array at from dot pl had pointed out that count() is a cheap operation; however, there's still the function call overhead.]

If you want to run through large arrays don't use count() function in the loops , its a over head in performance, copy the count() value into a variable and use that value in loops for a better performance.

Eg:

// Bad approach

for($i=0;$i<count($some_arr);$i++)
{
// calculations
}

// Good approach

$arr_length = count($some_arr);
for($i=0;$i<$arr_length;$i++)
{
// calculations
}
up
4
lucasfsmartins at gmail dot com
5 years ago
If you are on PHP 7.2+, you need to be aware of "Changelog" and use something like this:

<?php
$countFruits
= is_array($countFruits) || $countFruits instanceof Countable ? count($countFruits) : 0;
?>

You can organize your code to ensure that the variable is an array, or you can extend the Countable so that you don't have to do this check.
up
3
Anonymous
4 years ago
For a Non Countable Objects

$count = count($data);
print "Count: $count\n";

Warning: count(): Parameter must be an array or an object that implements Countable in example.php on line 159

#Quick fix is to just cast the non-countable object as an array..

$count = count((array) $data);
print "Count: $count\n";

Count: 250
up
13
danny at dannymendel dot com
17 years ago
I actually find the following function more useful when it comes to multidimension arrays when you do not want all levels of the array tree.

// $limit is set to the number of recursions
<?php
function count_recursive ($array, $limit) {
$count = 0;
foreach (
$array as $id => $_array) {
if (
is_array ($_array) && $limit > 0) {
$count += count_recursive ($_array, $limit - 1);
} else {
$count += 1;
}
}
return
$count;
}
?>
up
4
pied-pierre
9 years ago
A function of one line to find the number of elements that are not arrays, recursively :

function count_elt($array, &$count=0){
foreach($array as $v) if(is_array($v)) count_elt($v,$count); else ++$count;
return $count;
}
up
9
alexandr at vladykin dot pp dot ru
17 years ago
My function returns the number of elements in array for multidimensional arrays subject to depth of array. (Almost COUNT_RECURSIVE, but you can point on which depth you want to plunge).

<?php
function getArrCount ($arr, $depth=1) {
if (!
is_array($arr) || !$depth) return 0;

$res=count($arr);

foreach (
$arr as $in_ar)
$res+=getArrCount($in_ar, $depth-1);

return
$res;
}
?>
up
0
olja dot fb at gmail dot com
1 year ago
In example #3, given as:

<?php
$food
= array('fruits' => array('orange', 'banana', 'apple'),
'veggie' => array('carrot', 'collard', 'pea'));

// recursive count
var_dump(count($food, COUNT_RECURSIVE));
?>

with the output given as int(8), it may have some readers mistaken, as I was at first: one might take it as keys being counted as well as the inner array entries:

<?php
// NO:
'fruits', 'orange', 'banana', 'apple',
'veggie', 'carrot', 'collard', 'pea'
?>

But actually keys are not counted in count function, and why it is still 8 - because inner arrays are counted as entries as well as their inner elements:

<?php
// YES:
array('orange', 'banana', 'apple'), 'orange', 'banana', 'apple',
array(
'carrot', 'collard', 'pea'), 'carrot', 'collard', 'pea'
?>
up
-1
php_count at cubmd dot com
7 years ago
All the previous recursive count solutions with $depth option would not avoid infinite loops in case the array contains itself more than once.
Here's a working solution:

<?php
/**
* Recursively count elements in an array. Behaves exactly the same as native
* count() function with the $depth option. Meaning it will also add +1 to the
* total count, for the parent element, and not only counting its children.
* @param $arr
* @param int $depth
* @param int $i (internal)
* @return int
*/
public static function countRecursive(&$arr, $depth = 0, $i = 0) {
$i++;
/**
* In case the depth is 0, use the native count function
*/
if (empty($depth)) {
return
count($arr, COUNT_RECURSIVE);
}
$count = 0;
/**
* This can occur only the first time when the method is called and $arr is not an array
*/
if (!is_array($arr)) {
return
count($arr);
}

// if this key is present, it means you already walked this array
if (isset($arr['__been_here'])) {
return
0;
}

$arr['__been_here'] = true;

foreach (
$arr as $key => &$value) {
if (
$key !== '__been_here') {
if (
is_array($value) && $depth > $i) {
$count += self::countRecursive($value, $depth, $i);
}

$count++;
}
}

// you need to unset it when done because you're working with a reference...
unset($arr['__been_here']);
return
$count;
}
?>
up
-1
asma mechtaba
2 years ago
count and sizeof are aliases, what work for one works for the other.
up
-2
Christoph097
2 years ago
Empty values are counted:
<?php
$ar
[] = 3;
$ar[] = null;
var_dump(count($ar)); //int(2)
?>
up
-5
buyatv at gmail dot com
7 years ago
You can not get collect sub array count when there is only one sub array in an array:

$a = array ( array ('a','b','c','d'));
$b = array ( array ('a','b','c','d'), array ('e','f','g','h'));

echo count($a); // 4 NOT 1, expect 1
echo count($b); // 2, expected
up
-5
vojtaripa at gmail dot com
4 years ago
To get the count of the inner array you can do something like:

$inner_count = count($array[0]);
echo ($inner_count);
up
-4
max at schimmelmann dot org
4 years ago
In special situations you might only want to count the first level of the array to figure out how many entries you have, when they have N more key-value-pairs.

<?php

$data
= [
'a' => [
'bla1' => [
0 => 'asdf',
1 => 'asdf',
2 => 'asdf',
],
'bla2' => [
0 => 'asdf',
1 => 'asdf',
2 => 'asdf',
],
'bla3' => [
0 => 'asdf',
1 => 'asdf',
2 => 'asdf',
],
'bla4' => [
0 => 'asdf',
1 => 'asdf',
2 => 'asdf',
],
],
'b' => [
'bla1' => [
0 => 'asdf',
1 => 'asdf',
2 => 'asdf',
],
'bla2' => [
0 => 'asdf',
1 => 'asdf',
2 => 'asdf',
],
],
'c' => [
'bla1' => [
0 => 'asdf',
1 => 'asdf',
2 => 'asdf',
]
]
];
$count = array_sum(array_values(array_map('count', $data)));
// will return int(7)
var_dump($count);

// will return 31
var_dump(count($data, 1));
?>
To Top