Différence entre la carte de tableau, la promenade de tableau et le filtre de tableau

L'idée de cartographie une fonction de tableau de données provient de la programmation fonctionnelle. Vous ne devriez pas penser à array_map comme une boucle foreach qui appelle une fonction sur chaque élément du tableau (même si c'est comme ça qu'elle est implémentée). Il devrait être considéré comme appliquant la fonction à chaque élément du tableau indépendamment.

En théorie, des choses telles que le mappage de fonction peuvent être faites en parallèle puisque la fonction appliquée aux données ne devrait affecter que les données et non l'état global. C'est parce qu'un array_map pourrait choisir n'importe quel ordre dans lequel appliquer la fonction aux éléments (même si en PHP ce n'est pas le cas).

array_walk d'autre part, c'est l'approche exactement opposée à la gestion des tableaux de données. Au lieu de gérer chaque élément séparément, il utilise un État (&$userdata) et peut modifier l'élément en place (un peu comme une boucle foreach). Comme chaque fois qu'un élément a le $funcname appliqué, il pourrait changer l'état global du programme et nécessite donc un seul corriger façon de traiter les éléments.

Retour en PHP land, array_map et array_walk sont presque identiques sauf que array_walk vous donne plus de contrôle sur l'itération des données et est normalement utilisé pour "changer" les données en place vs renvoyer un nouveau tableau "changé".

array_filter est vraiment une application de array_walk (ou array_reduce) et plus ou moins juste pour votre confort.

De la documentation,

Bool array_walk ( array &$array , callback $funcname [, mixed $userdata ] )

Array_walk prend un tableau et une fonction de F et la modifie en remplaçant chaque élément x de F(x).

Tableau array_map ( callback $ callback , tableau $ arr1 [, tableau $... ])

Array_map fait exactement la même chose sauf qu'au lieu de modifier sur place il retournera un nouveau tableau avec les éléments transformés.

Tableau array_filter ( array $input [, rappel $rappel ] )

Array_filter avec la fonction F, au lieu de transformer les éléments, va supprimer tous les éléments pour lesquels F(x) n'est pas vrai

Les autres réponses démontrent assez bien la différence entre array_walk (modification sur place) et array_map (copie modifiée de retour). Cependant, ils ne mentionnent pas vraiment array_reduce, qui est un moyen éclairant de comprendre array_map et array_filter.

La fonction array_reduce prend un tableau, une fonction à deux arguments et un 'accumulateur', comme ceci:

array_reduce(array('a', 'b', 'c', 'd'),
             'my_function',
             $accumulator)

Les éléments du tableau sont combinés avec l'accumulateur un à la fois, en utilisant la fonction donnée. Résultat de l'appel ci-dessus est le même que de faire ceci:

my_function(
  my_function(
    my_function(
      my_function(
        $accumulator,
        'a'),
      'b'),
    'c'),
  'd')

Si vous préférez penser en termes de boucles, c'est comme faire ce qui suit (j'ai effectivement utilisé ceci comme une solution de repli quand array_reduce n'était pas disponible):

function array_reduce($array, $function, $accumulator) {
  foreach ($array as $element) {
    $accumulator = $function($accumulator, $element);
  }
  return $accumulator;
}

Cette version en boucle explique clairement pourquoi j'ai appelé le troisième argument un "accumulateur": nous pouvons l'utiliser pour accumuler des résultats à chaque itération.

Alors qu'est-ce que cela a à voir avec array_map et array_filter? Il s'avère qu'ils sont tous les deux un particulier type de array_reduce. Nous pouvons les implémenter comme ceci:

array_map($function, $array)    === array_reduce($array, $MAP,    array())
array_filter($array, $function) === array_reduce($array, $FILTER, array())

Ignorer le fait que array_map et array_filter prennent leurs arguments dans un ordre différent; c'est juste une autre bizarrerie de PHP. Le point important est que le côté droit est identique sauf pour les fonctions que j'ai appelées $MAP et $ FILTER. Alors, à quoi ressemblent-ils?

$MAP = function($accumulator, $element) {
  $accumulator[] = $function($element);
  return $accumulator;
};

$FILTER = function($accumulator, $element) {
  if ($function($element)) $accumulator[] = $element;
  return $accumulator;
};

Comme vous pouvez le voir, les deux fonctions prennent l'accumulateur $et le renvoient à nouveau. Il y a deux différences dans ces fonctions:

• $MAP sera toujours ajouté à $ accumulator, mais $FILTER ne le fera que si $function ($element) est TRUE.
• $FILTER ajoute l'élément d'origine, mais $MAP ajoute $function ($element).

Notez que c'est loin d'être une anecdote inutile; nous pouvons l'utiliser pour rendre nos algorithmes plus efficaces!

Nous pouvons souvent voir du code comme ces deux exemples:

// Transform the valid inputs
array_map('transform', array_filter($inputs, 'valid'))

// Get all numeric IDs
array_filter(array_map('get_id', $inputs), 'is_numeric')

L'utilisation de array_map et array_filter au lieu de boucles rend ces exemples plutôt agréables. Cependant, cela peut être très inefficace si $inputs est grand, puisque le premier appel (map ou filter) traversera $inputs et construira un tableau intermédiaire. Ce tableau intermédiaire est passé directement dans le deuxième appel, qui traversera à nouveau le tout,puis le tableau intermédiaire devra être collecté.

Nous pouvons nous débarrasser de ce tableau intermédiaire en exploitant le fait que array_map et array_filter sont tous deux des exemples de array_reduce. En les combinant, nous n'avons qu'à traverse $entrées une fois dans chaque exemple:

// Transform valid inputs
array_reduce($inputs,
             function($accumulator, $element) {
               if (valid($element)) $accumulator[] = transform($element);
               return $accumulator;
             },
             array())

// Get all numeric IDs
array_reduce($inputs,
             function($accumulator, $element) {
               $id = get_id($element);
               if (is_numeric($id)) $accumulator[] = $id;
               return $accumulator;
             },
             array())

NOTE: mes implémentations de array_map et array_filter ci-dessus ne se comporteront pas exactement comme PHP, puisque mon array_map ne peut gérer qu'un tableau à la fois et mon array_filter n'utilisera pas "empty" comme fonction $par défaut. En outre, ni l'un ni l'autre ne préservera les clés.

Il n'est pas difficile de les faire se comporter comme PHP, mais j'ai senti que ces complications rendraient l'idée de base plus difficile à repérer.

La révision suivante cherche à délimiter plus clairement array_filer(), array_map () et array_walk () de PHP, qui proviennent tous de la programmation fonctionnelle:

Array_filter() filtre de données, produisant en conséquence, un nouveau tableau contenant uniquement les éléments souhaités de l'ancien tableau, comme suit:

<?php
$array = array(1, "apples",2, "oranges",3, "plums");

$filtered = array_filter( $array, "ctype_alpha");
var_dump($filtered);
?>

Code En Direct ici

Toutes les valeurs numériques sont filtrées hors de $ array, laissant $filtré avec seulement des types de fruits.

Array_map() crée également un nouveau array mais contrairement à array_filter () le tableau résultant contient chaque élément de l'entrée $ filtered mais avec des valeurs modifiées, en raison de l'application d'un rappel à chaque élément, comme suit:

<?php

$nu = array_map( "strtoupper", $filtered);
var_dump($nu);
?>

Code EN DIRECT ici

Le code dans ce cas applique un rappel en utilisant le strtoupper () intégré mais une fonction définie par l'utilisateur est également une autre option viable. Le rappel s'applique à chaque élément de $filtered et engendre ainsi $nu dont les éléments contiennent des majuscules valeur.

Dans l'extrait suivant, array walk() traverse $ nu et modifie chaque élément par rapport à l'opérateur de référence'&'. Les modifications se produisent sans créer de tableau supplémentaire. La valeur de chaque élément change en place dans une chaîne plus informative spécifiant sa clé, sa catégorie et sa valeur.

<?php

$f = function(&$item,$key,$prefix) {
    $item = "$key: $prefix: $item";
}; 
array_walk($nu, $f,"fruit");
var_dump($nu);    
?>    

Voir démo

Note: la fonction de rappel par rapport à array_walk() prend deux paramètres qui acquerront automatiquement la valeur d'un élément et sa clé et dans cet ordre, aussi lorsqu'il est invoqué par array_walk (). (Voir plus ici).