Count "truthy" values in a 2d array

From the PHP array_filter documentation:

//This function filters an array and remove all null values recursively. 

<?php 
  function array_filter_recursive($input) 
  { 
    foreach ($input as &$value) 
    { 
      if (is_array($value)) 
      { 
        $value = array_filter_recursive($value); 
      } 
    } 

    return array_filter($input); 
  } 
?> 

//Or with callback parameter (not tested) : 

<?php 
  function array_filter_recursive($input, $callback = null) 
  { 
    foreach ($input as &$value) 
    { 
      if (is_array($value)) 
      { 
        $value = array_filter_recursive($value, $callback); 
      } 
    } 

    return array_filter($input, $callback); 
  } 
?>

A better alternative

One implementation that always worked for me is this one:

function filter_me(&$array) {
    foreach ( $array as $key => $item ) {
        is_array ( $item ) && $array [$key] = filter_me ( $item );
        if (empty ( $array [$key] ))
            unset ( $array [$key] );
    }
    return $array;
}

I notice that someone had created a similar function except that this one presents, in my opinion, few advantages:

1. you pass an array as reference (not its copy) and thus the algorithm is memory-friendly
2. no additional calls to array_filter which in reality involves:
   • the use of stack, ie. additional memory
   • some other operations, ie. CPU cycles

Benchmarks

1. A 64MB array
   • filter_me function finished in 0.8s AND the PHP allocated memory before starting the function was 65MB, when function returned it was 39.35MB !!!
   • array_filter_recursive function recommended above by Francois Deschenes had no chance; after 1s PHP Fatal error: Allowed memory size of 134217728 bytes exhausted
2. A 36MB array
   • filter_me function finished in 0.4s AND the PHP allocated memory before starting the function was 36.8MB, when function returned it was 15MB !!!
   • array_filter_recursive function succeeded this time in 0.6s and memory before/after was quite the same

I hope it helps.

This function effectively applies filter_recursive with a provided callback

class Arr {

    public static function filter_recursive($array, $callback = NULL)
    {
        foreach ($array as $index => $value)
        {
            if (is_array($value))
            {
                $array[$index] = Arr::filter_recursive($value, $callback);
            }
            else
            {
                $array[$index] = call_user_func($callback, $value);
            }

            if ( ! $array[$index])
            {
                unset($array[$index]);
            }
        }

        return $array;
    }

}

And you'd use it this way:

Arr::filter_recursive($my_array, $my_callback);

This might help someone

I needed an array filter recursive function that would walk through all nodes (including arrays, so that we have the possibility to discard entire arrays), and so I came up with this:

    public static function filterRecursive(array $array, callable $callback): array
    {
        foreach ($array as $k => $v) {
            $res = call_user_func($callback, $v);
            if (false === $res) {
                unset($array[$k]);
            } else {
                if (is_array($v)) {
                    $array[$k] = self::filterRecursive($v, $callback);
                }
            }
        }

        return $array;
    }

See more examples here: https://github.com/lingtalfi/Bat/blob/master/ArrayTool.md#filterrecursive

This should work for callback and mode support along with an optional support for depth.

function array_filter_recursive(array $array, callable $callback = null, int $mode = 0, int $depth = -1): array
{
    foreach ($array as & $value) {
        if ($depth != 0 && is_array($value)) {
            $value = array_filter_recursive($value, $callback, $mode, $depth - 1);
        }
    }

    if ($callback) {
        return array_filter($array, $callback, $mode);
    }

    return array_filter($array);
}

Calling the function with $depth = 0 for nested arrays, will yield the same result as array_filter.

<?php

$mm = array
(
    147 => array
        (
            "pts_m" => "",
            "pts_mreg" => 1,
            "pts_cg" => 1
        ) ,
    158 => array
        (
            "pts_m" => null ,
            "pts_mreg" => null,
            "pts_cg" => 0
        ),

    159 => array
        (
            "pts_m" => "",
            "pts_mreg" => 1,
            "pts_cg" => 1
        )

);

$count = 0;
foreach ($mm as $m) {
    foreach ($m as $value) {
        if($value !== false && $value !== "" && $value !== null) {
            $count++;
        }
    }
}
echo $count;
?>

1. Recursion is not necessary because the array has a consistent depth of 2 levels.
2. It is not necessary to generate an array of filtered elements so that you can traverse the filtered data to count it. Just traverse once and cast each value to a boolean and add that (which will be 0 or 1 when added) to the count total.

The following snippet calls no functions (only language constructs -- foreach()) and therefore will be highly efficient.

Code: (Demo)

$truthyCount = 0;
foreach ($array as $row) {
    foreach ($row as $v) {
        $truthyCount += (bool)$v;
    }
}
var_export($truthyCount);

For a functional-style approach, sum the mapped counts of all truthy values. Demo

var_export(
    array_sum(
        array_map(
            fn($row) => count(array_filter($row)),
            $array
        )
    )
);