Comment faire pour exécuter array_filter de façon récursive dans un tableau PHP?

Donné le tableau suivant $mm

Array
(
    [147] => Array
        (
            [pts_m] => 
            [pts_mreg] => 1
            [pts_cg] => 1
        )    
    [158] => Array
        (
            [pts_m] => 
            [pts_mreg] => 
            [pts_cg] => 0
        )

    [159] => Array
        (
            [pts_m] => 
            [pts_mreg] => 1
            [pts_cg] => 1
        )

)

Quand je lance count(array_filter($mm)) - je obtenir 3 comme résultat, car il n'est pas récursive.

count(array_filter($mm), COUNT_RECURSIVE) permettra aussi de ne pas le faire parce que j'ai réellement besoin pour exécuter le array_filter de manière récursive, puis à compter de son résultat.

Donc ma question est: comment puis-je exécuter de manière récursive array_filter($mm) dans ce cas?
Mon résultat escompté serait ici 4.

Veuillez noter que je n'utilise aucune de rappel afin que je puisse exclure les faux, nulle et vide.

Vous êtes tout simplement en essayant de compter les éléments du tableau qui ont une valeur?
c'est correct, mais pas 0

InformationsquelleAutor pepe | 2011-07-22

9

Devrait fonctionner
```
$count = array_sum(array_map(function ($item) {
  return ((int) !is_null($item['pts_m'])
       + ((int) !is_null($item['pts_mreg'])
       + ((int) !is_null($item['pts_cg']);
}, $array);
```
ou peut-être
```
$count = array_sum(array_map(function ($item) {
  return array_sum(array_map('is_int', $item));
}, $array);
```
Il y a certainement beaucoup plus de solutions possibles. Si vous souhaitez utiliser array_filter() (sans rappel), rappelez-vous, qu'il traite 0 comme false trop, et donc supprimer tout 0-valeur du tableau.

Si vous utilisez PHP dans une pré-version 5.3, je voudrais utiliser une foreach-boucle
```
$count = 0;
foreach ($array as $item) {
  $count += ((int) !is_null($item['pts_m'])
          + ((int) !is_null($item['pts_mreg'])
          + ((int) !is_null($item['pts_cg']);
}
```
Mise à jour

Concernant le commentaire ci-dessous:

Thx @kc je veux en fait la méthode pour supprimer false, 0, vide, etc

Quand ce n'est vraiment que, ce que vous voulez, la solution est très simple aussi.
Mais maintenant, je ne sais pas, comment interpréter

Mon résultat escompté serait ici 5.

De toute façon, son court maintenant 🙂
```
$result = array_map('array_filter', $array);
$count = array_map('count', $result);
$countSum = array_sum($count);
```
Le tableau qui en résulte ressemble à
```
Array
(
[147] => Array
    (
        [pts_mreg] => 1
        [pts_cg] => 1
    )    
[158] => Array
    (
    )

[159] => Array
    (
        [pts_mreg] => 1
        [pts_cg] => 1
    )

)
```
- Thx @kc je veux en fait la méthode pour supprimer false, 0, vide, etc
- Votre énoncé "Mon résultat attendu serait ici 5." est tout à fait trompeur alors et après la suppression de toute false-évalué la valeur count($array) toujours pas de retour 0.
- "... toujours pas de retour 5". Il compte les éléments du tableau et un tableau est un élément et ne seront donc comptabilisés comme 1 (je n'ai pas voulu ce commentaire pour être un idiot "voulez corriger ma faute de frappe"..)
- merci beaucoup @kingcrunch -- votre suggestion fonctionne à merveille, très apprécié!
InformationsquelleAutor KingCrunch

De la PHP array_filter de la 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); 
  } 
?>

serait-ce également supprimer vide et 0?
Cela fonctionne de la même manière que array_filter fait normalement. Si vous regardez dans la fonction, il appelle array_filter sauf si c'est la valeur actuelle est un tableau à quel point il appelle la array_filter_recursive fonction.
avec rappel ne fonctionne pas comme prévu, il donne le tableau de conversion de chaîne de caractères erreurs lors de la récursivité..
Ne fonctionne pas avec rappel fourni. Voir ma réponse pour un travail de la fonction
Si je ne passe pas une fonction de rappel (callback est null, le résultat est null :/ je ne Peux pas comprendre pourquoi

InformationsquelleAutor Francois Deschenes

5

Une meilleure alternative

Une mise en œuvre qui a toujours travaillé pour moi est celui-ci:
```
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;
}
```
J'ai remarqué que quelqu'un avait créé une fonction similaire sauf que celui-ci présente, à mon avis, quelques avantages:
1. vous passez un tableau comme référence (pas une copie) et donc l'algorithme est de mémoire
2. pas appel à d'autres array_filter qui, dans la réalité, il faut:
  - l'utilisation de la pile, c'est à dire. la mémoire supplémentaire
  - quelques autres opérations, c'est à dire. Les cycles CPU
Repères
1. Un tableau de 64 mo
  - filter_me fonction de fini en 0,8 s ET le PHP alloué de la mémoire avant de commencer la fonction était de 65 MO, lorsque la fonction est retourné, il a été disponible 39,35 MO !!!
  - array_filter_recursive fonction recommandé ci-dessus par François Deschênes avait aucune chance; après 1s PHP Fatal error: Allowed memory size of 134217728 bytes exhausted
2. Un tableau 36 mo
  - filter_me fonction de fini en 0,4 s ET le PHP alloué de la mémoire avant de commencer la fonction était de 36,8 MO, lorsque la fonction est retourné, il était de 15 mo !!!
  - array_filter_recursive fonction réussi cette fois à 0,6 s et de la mémoire avant/après, c'est tout à fait le même
J'espère que cela aide.
- Mais c'est une bonne solution por la question spécifique 😉 Upvoted
InformationsquelleAutor Eugen Mihailescu

Cette fonction de manière efficace s'applique filter_recursive avec un rappel

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

}

Et que vous souhaitez l'utiliser de cette façon:

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

Cela peut aider quelqu'un

Il peut aider donc c'est bon à savoir. De toute façon, la question est liée à la façon de filtrer ces "vide", les dossiers et ma réponse ciblée à fournir une meilleure alternative à l'égard de ce problème. Mais je suis d'accord que la version de votre filtre récursif a une plus large utilisation.
N'est-ce pas array_filter censés préserver la valeur d'origine si la fonction de rappel renvoie true? Dans ce cas, vous êtes en claquant la valeur d'origine de true
détruit le tableau d'entrée

InformationsquelleAutor helpse

J'ai besoin d'un tableau de filtre de fonction récursive, qui serait marcher à travers tous les nœuds (y compris les tableaux, de sorte que nous avons la possibilité de jeter des tableaux entiers), et donc je suis venu avec cette:


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

Voir plus d'exemples ici: https://github.com/lingtalfi/Bat/blob/master/ArrayTool.md#filterrecursive

cette mutation de l'entrée de la matrice de

InformationsquelleAutor ling

-1

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

Bonne idée dans ce cas array_filter pourrait être utilisé à la place du conditionnel et $count++, non?

InformationsquelleAutor Jrod

Vous devez vous connecter pour publier un commentaire.

Mise à jour