Php где может использоваться count

count

Подсчитывает все элементы в массиве при использовании с массивом. При использовании с объектом, реализующим интерфейс Countable , он возвращает возвращаемое значение метода Countable :: count () .

Parameters

Массив или счетный объект.

Если необязательный параметр mode установлен в COUNT_RECURSIVE (или 1), count () будет рекурсивно подсчитывать массив. Это особенно полезно для подсчета всех элементов многомерного массива.

count () может обнаруживать рекурсию, чтобы избежать бесконечного цикла, но будет E_WARNING каждый раз (в случае, если массив содержит себя более одного раза) и возвращать счетчик больше, чем можно было ожидать.

Return Values

Возвращает количество элементов в value . До PHP 8.0.0, если параметр не был ни массивом , ни объект , который реализует счетные интерфейс, 1 будет возвращено, если value не было null , и в этом случае 0 будет возвращено.

Changelog

Examples

Пример # 1 отсчет () Пример

Выводится приведенный выше пример:

Пример # 2 count () non Countable | пример массива (плохой пример — не делайте этого)

Выводится приведенный выше пример:

Вывод приведенного выше примера в PHP 7.2:

Вывод приведенного выше примера в PHP 8:

Пример # 3 Рекурсивный подсчет () Пример

PHP count() function with examples

PHP count() function is an in-built function available in PHP, which counts and returns the number of elements in an array. It also counts the number of properties in an object.

The count() function may return 0 for the variable, which has been declared with an empty array or for the variable which is not set.

PHP Version

count() function is compatible with PHP version 4 or above

Parameter:

Define the mode of the function; Possible values can be 0 or 1

0: Default value. Does not count all the elements of the multi-dimensional array

count

Подсчитывает все элементы в массиве, если используется массив. Если используется объект, который реализует интерфейс Countable , функция возвращает результат выполнения метода Countable::count() .

Список параметров

Массив или объект, реализующий Countable .

Если необязательный параметр mode установлен в COUNT_RECURSIVE (или 1), count() будет рекурсивно подсчитывать количество элементов массива. Это особенно полезно для подсчёта всех элементов многомерных массивов.

count() умеет определять рекурсию для избежания бесконечного цикла, но при каждом обнаружении выводит ошибку уровня E_WARNING (в случае, если массив содержит себя более одного раза) и возвращает большее количество, чем могло бы ожидаться.

Возвращаемые значения

Возвращает количество элементов в value . До PHP 8.0.0, если параметр не был ни массивом ( array ), ни объектом ( object ), реализующим интерфейс Countable , возвращалось 1 , если значение параметра value не было null , в этом случае возвращалось 0 .

Список изменений

Примеры

Пример #1 Пример использования count()

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

$b [ 0 ] = 7 ;
$b [ 5 ] = 9 ;
$b [ 10 ] = 11 ;
var_dump ( count ( $b ));
?>

Результат выполнения данного примера:

Пример #2 Пример использования count() с неисчисляемым типом (плохой пример — не делайте так)

<?php
$b [ 0 ] = 7 ;
$b [ 5 ] = 9 ;
$b [ 10 ] = 11 ;
var_dump ( count ( $b ));

var_dump ( count ( null ));

var_dump ( count ( false ));
?>

Результат выполнения данного примера:

Результат выполнения данного примера в PHP 7.2:

Результат выполнения данного примера в PHP 8:

Пример #3 Пример рекурсивного использования count()

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

// рекурсивный подсчёт
var_dump ( count ( $food , COUNT_RECURSIVE ));

// обычный подсчёт
var_dump ( count ( $food ));

Результат выполнения данного примера:

Пример #4 Объект, реализующий интерфейс Countable

<?php
class CountOfMethods implements Countable
<
private function someMethod ()
<
>

public function count (): int
<
return count ( get_class_methods ( $this ));
>
>

$obj = new CountOfMethods ();
var_dump ( count ( $obj ));
?>

Результат выполнения данного примера:

Смотрите также

• is_array() — Определяет, является ли переменная массивом
• isset() — Определяет, была ли установлена переменная значением, отличным от null
• empty() — Проверяет, пуста ли переменная
• strlen() — Возвращает длину строки
• is_countable() — Проверить, что содержимое переменной является счётным значением

User Contributed Notes 19 notes

[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.

$arr_length = count($some_arr);
for($i=0;$i<$arr_length;$i++)
<
// calculations
>

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.

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»;

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 ;
>
?>

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 );

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 );
>

// you need to unset it when done because you’re working with a reference.
unset( $arr [ ‘__been_here’ ]);
return $count ;
>
?>

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;
>

Get maxWidth and maxHeight of a two dimensional array.

Note:
1st dimension = Y (height)
2nd dimension = X (width)
e.g. rows and cols in database result arrays

<?php
$TwoDimensionalArray = array( 0 => array( ‘key’ => ‘value’ , . ), . );
?>

So for Y (maxHeight)
<?php
$maxHeight = count ( $TwoDimensionalArray )
?>

And for X (maxWidth)
<?php
$maxWidth = max ( array_map ( ‘count’ , $TwoDimensionalArray ) );
?>

Simple? 😉

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

As I see in many codes, don’t use count to iterate through array.
Onlyranga says you could declare a variable to store it before the for loop.
I agree with his/her approach, using count in the test should be used ONLY if you have to count the size of the array for each loop.

You can do it in the for loop too, so you don’t have to «search» where the variable is set.
e.g.
<?php
$array = [ 1 , 5 , ‘element’ ];
for( $i = 0 , $c = count ( $array ); $i < $c ; $i ++)
var_dump ( $array [ $i ]);
?>

to end the debate: count() is the same as empty()

test code below:

results on my computer:

count : double(0.81396999359131)
empty : double(0.81621310710907)

using isset($test[0]) is a bit slower than empty;
test without adding value to the array in function ****Test: still the same.

function average (array $test )
<
$sum = 0 ;
foreach( $test as $value ) <
$sum += $value ;
>

function countTest (array $test )
<
$i = 0 ;
while ( $i ++ < 1000000 ) <
count ( $test );
$test [ «lol $i » ] = «teset $i » ;
>
>

function emptyTest (array $test )
<
$i = 0 ;
while ( $i ++ < 1000000 ) <
empty( $test );
$test [ «lol $i » ] = «teset $i » ;
>
>

$test = [];
$i = 0 ;
while ( $i ++ < 20000000 ) <
$test [] = $i ;
>

$j = 10 ;
$value = $j ;
$count = [];
$isEmpty = [];
while ( $j —) <
$time = microtime ( true );
countTest ( $test );
$count [] = microtime ( true ) — $time ;

$time = microtime ( true );
emptyTest ( $test );
$isEmpty [] = microtime ( true ) — $time ;
>

var_dump ( average ( $count ) / $value );
var_dump ( average ( $isEmpty ) / $value );

You can not get collect sub array count when use the key on only one sub array in an array:

echo count($a[‘b’]); // 2 NOT 1, expect 1
echo count($b[‘b’]); // 3, expected

To get the count of the inner array you can do something like:

$inner_count = count($array[0]);
echo ($inner_count);

About 2d arrays, you have many way to count elements :

<?php
$MyArray = array ( array( 1 , 2 , 3 ),
1 ,
‘a’ ,
array( ‘a’ , ‘b’ , ‘c’ , ‘d’ ) );

// All elements
echo count ( $MyArray , COUNT_RECURSIVE ); // output 11 (9 values + 2 arrays)

// First level elements
echo count ( $MyArray ); // output 4 (2 values+ 2 arrays)

// Both level values, but only values
echo( array_sum ( array_map ( ‘count’ , $MyArray ))); //output 9 (9 values)

// Only second level values
echo ( count ( $MyArray , COUNT_RECURSIVE )- count ( $MyArray )); //output 7 ((all elements) — (first elements))
?>

Criada para contar quantos níveis um array multidimensional possui.

function count_multiLevel($matrix, $_LEVEL = 0)<

/* Variáveis de recursão */
$_COUNT = $_LEVEL;

/* Verifica se o ARRAY foi instanciado */
if (is_setVar($matrix))<

/* Verifica se a variável é um ARRAY */
if(is_array($matrix))<

/* Loop de elementos da matriz*/
foreach ($matrix as $elements => $value) <

/* Auxiliar para verificação posterior */
$_AUX = $_COUNT;

/* Verifiando os Nós */
if (is_array($matrix[$elements])) <
$_COUNT = count_multiLevel($matrix[$elements], $_LEVEL+1);
>
/* Cereja do bolo */
if($_AUX > $_COUNT)
$_COUNT = $_AUX;
>
/* Retorn do resultado da operação */
return $_COUNT;

>else <
/* Em casos que o valor passado não seja uma matriz/array */
return -1;
>
>
>

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.

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

If you want to know the sub-array containing the MAX NUMBER of values in a 3 dimensions array, here is a try (maybe not the nicest way, but it works):

function how_big_is_the_biggest_sub ($array) <
// we parse the 1st level
foreach ($array AS $key => $array_lvl2) <
//within level 2, we count the 3d levels max
$lvl2_nb = array_map( ‘count’, $array_lvl2) ;
$max_nb = max($lvl2_nb);
// we store the matching keys, it might be usefull
$max_key = array_search($max_nb, $lvl2_nb);
$max_nb_all[$max_key.’|’.$key] = $max_nb;
>
// now we want the max from all levels 2, so one more time
$real_max = max($max_nb_all);
$real_max_key = array_search($real_max, $max_nb_all);
list($real_max_key2, $real_max_key1) = explode(‘|’, $real_max_key);
// preparing result
$biggest_sub[‘max’] = $real_max;
$biggest_sub[‘key1’] = $real_max_key1;
$biggest_sub[‘key2’] = $real_max_key2;

return $biggest_sub;
>
/*
$cat_poids_max[‘M’][‘Juniors’][] = 55;
$cat_poids_max[‘M’][‘Juniors’][] = 61;
$cat_poids_max[‘M’][‘Juniors’][] = 68;
$cat_poids_max[‘M’][‘Juniors’][] = 76;
$cat_poids_max[‘M’][‘Juniors’][] = 100;

$cat_poids_max[‘M’][‘Seniors’][] = 55;
$cat_poids_max[‘M’][‘Seniors’][] = 60;
$cat_poids_max[‘M’][‘Seniors’][] = 67;
$cat_poids_max[‘M’][‘Seniors’][] = 75;
$cat_poids_max[‘M’][‘Seniors’][] = 84;
$cat_poids_max[‘M’][‘Seniors’][] = 90;
$cat_poids_max[‘M’][‘Seniors’][] = 100;
//.
$cat_poids_max[‘F’][‘Juniors’][] = 52;
$cat_poids_max[‘F’][‘Juniors’][] = 65;
$cat_poids_max[‘F’][‘Juniors’][] = 74;
$cat_poids_max[‘F’][‘Juniors’][] = 100;

$cat_poids_max[‘F’][‘Seniors’][] = 62;
$cat_poids_max[‘F’][‘Seniors’][] = 67;
$cat_poids_max[‘F’][‘Seniors’][] = 78;
$cat_poids_max[‘F’][‘Seniors’][] = 86;
$cat_poids_max[‘F’][‘Seniors’][] = 100;
*/
$biggest_sub = how_big_is_the_biggest_sub($cat_poids_max);
echo «<li> «.$biggest_sub[‘key1’].» ==> «.$biggest_sub[‘key2’].» ==> «.$biggest_sub[‘max’]; // displays : M ==> Seniors ==> 7

PHP count

By Afshan Banu

Introduction to PHP count

The PHP count() method is used to get the number of elements in an array. The PHP count() method is a built-in method in PHP. It performs the same task as the size() method does. Sometimes we need to know the number of an element present in an array or object, so for this purpose PHP provides the count() method. It may also return 0 value for an array or object that has no element in it or if it is an empty array and also for an array or object which is not set.

Syntax:

Web development, programming languages, Software testing & others

Parameters:

• array: This is not an optional parameter, that specifies the array whose elements are to be count.
• mode: This is an optional parameter, that specifies the mode of the method. There are two possible values for this parameter that are 0 and 1. The 0 indicates not to count the elements of an array recursively and this is the default value of this parameter. The 1 value indicates to count the elements of an array reclusively, which is used to count the elements of an array recursively for a multidimensional array.
• return value: The return value of this method is the number of elements present in an object or array.

Working of PHP count() Method

• The PHP count() method uses on the array or objects to get the number of elements present in the particular array. The array can be single dimensional or multidimensional.
• When the count() method is called and pass the name of array to it, the count() method calculates how many elements are present in it and return this count as a result.

Examples of PHP count

Given below are the examples mentioned:

Example #1

Example of PHP count() method for finding the number of elements in an array. Next, we write the PHP code to understand the method more clearly with the following example, where the count() method is used to find the number of the element present in the single-dimensional array, as below.

Code:

Output:

As in the above program the code “$result = count($Language);” find and return the number of elements is present in the array “Language” and which is displaying as well, as we can see in the output.

Example #2

Example of PHP count() method for finding the number of counts for the multidimensional array.

Next, we write the HTML code to understand the PHP Count() method, where the length property is used to finding the number of counts of an element in the multidimensional array, as below.

Code:

Output:

As in the above program, the “sub” array is created to store the subjects and the respective faculty id who is handling it. Later in the code, the count() method is used two ways to find the number of elements present in this multidimensional array. The first way is “count( $sub, 1 );”, which is a recursive way as indicated by passing the mode value to 1 and the second way is “count( $sub );” , which is not a recursive way. So the output count of the first way is 12 and the output count of the second way is 2. PHP count() method for finding the number of counts for the multidimensional array of different data types.

Example #3

Next, we write the HTML code to understand the PHP Count() method, where the length property is used to find the number of counts of elements in the multidimensional array which is of different data types in different dimensions, as below.

Code:

Output:

As in the above program, the “Marks” array is created to store the subjects and the respective marks which is of different data types compare to the subject of a marks array. Later in the code, the count() method uses two ways to find the number of elements present in this multidimensional array, so the output count of the first way is 12 and the output count of the second way is 2.

Conclusion

The PHP count() method is a built-in method, which is used to get the number of elements present in an array.

Recommended Articles

This is a guide to PHP count. Here we discuss the introduction, working of the PHP count() method along with examples. You may also have a look at the following articles to learn more –