Как найти количество элементов массива php

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

}

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

$count = count($data);
print "Count: $countn";

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: $countn";

Count: 250

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

}

?>

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

  }

?>

function count_elt($array, &$count=0){
  foreach($array as $v) if(is_array($v)) count_elt($v,$count); else ++$count;
  return $count;
}

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

    }

?>

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

$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

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

$a = array("a"=>"appple", b"=>array('a'=>array(1,2,3),'b'=>array(1,2,3)));
$b = array("a"=>"appple", "b"=>array(array('a'=>array(1,2,3),'b'=>array(1,2,3)), array(1,2,3),'b'=>array(1,2,3)), array('a'=>array(1,2,3),'b'=>array(1,2,3))));

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

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

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

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

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