PHP 5.6.29 Released

count

(PHP 4, PHP 5, PHP 7)

countCuenta todos los elementos de un array o algo de un objeto

Descripción

int count ( mixed $array_or_countable [, int $mode = COUNT_NORMAL ] )

Cuenta todos los elementos en un array o algo de un objeto.

En objetos, si se tiene SPL instalado, se puede enganchar a count() implementado la interfaz Countable. Esta interfaz tiene solamente un método, Countable::count(), el cual devuelve el valor retornado por la función count().

Véase la sección Array del manual para una explicación detallada sobre cómo se implementan y usan los arrays en PHP.

Parámetros

array_or_countable

Un array o un objeto Countable.

mode

Si el parámetro opcional mode está establecido a COUNT_RECURSIVE (o 1), count() contará el array de forma recursiva. Esto es particularmente útil para contar todos los elementos de un array multidimensional.

Precaución

count() puede detectar recursividad para evitar un bucle infinito, pero emitirá un mensaje E_WARNING cada vez que lo haga (en caso de que el array se contenga a sí mismo más de una vez) y devolverá una cuenta mayor de la que se podría esperar.

Valores devueltos

Devuelve el número de elementos en array_or_countable, Si el parámetro no es un array o no es un objecto con la interfaz Countable implementada, devolverá 1. Existe una excepción, si array_or_countable es NULL, devolverá 0.

Precaución

count() devolverá 0 si la variable que se intenta contar no está establecida, pero también podría devolver 0 si la variable ha sido inicializada conun array vacío. Use isset() para comprobar si la variable está establecida.

Ejemplos

Ejemplo #1 Ejemplo de count()

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

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

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

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

Ejemplo #2 Ejemplo de count() recursivo

<?php
$comida 
= array('frutas' => array('naranja''plátano''manzana'),
                
'verduras' => array('zanahoria''col''guisante'));

// Cuenta recursiva
echo count($comidaCOUNT_RECURSIVE); // muestra 8

// Cuenta normal
echo count($comida); // muestra 2

?>

Ver también

  • is_array() - Comprueba si una variable es un array
  • isset() - Determina si una variable está definida y no es NULL
  • strlen() - Obtiene la longitud de un string

add a note add a note

User Contributed Notes 9 notes

up
61
onlyranga at gmail dot com
2 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
33
danny at dannymendel dot com
9 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
19
Gerd Christian Kunze
2 years ago
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? ;-)
up
31
alexandr at vladykin dot pp dot ru
10 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
11
pied-pierre
1 year 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
12
JumpIfBelow
1 year ago
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]);
?>
up
3
ayyappan dot ashok at gmail dot com
7 months ago
/** Count of objects */

class ABC{ }
$objecto = new ABC();
$total = count((array)$object); //Returns Zero.
$total = count($object); //Returns One
echo $total;
up
0
php_count at cubmd dot com
18 days 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
-2
ThisIsNotImportant
11 months ago
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))
?>
To Top