PHP array_map y compris les touches

Pas avec array_map, comme il ne gère pas les clés.

array_walk n':

$test_array = array("first_key" => "first_value",
                    "second_key" => "second_value");
array_walk($test_array, function(&$a, $b) { $a = "$b loves $a"; });
var_dump($test_array);

//array(2) {
//  ["first_key"]=>
//  string(27) "first_key loves first_value"
//  ["second_key"]=>
//  string(29) "second_key loves second_value"
//}

Il change le tableau donné en paramètre cependant, il n'est donc pas exactement de la programmation fonctionnelle (que vous avez de la question étiqueté comme ça). Aussi, comme l'a souligné dans les commentaires, cela ne fera que modifier les valeurs de la matrice, de sorte que les touches ne seront pas ce que vous avez spécifié dans la question.

Vous pouvez écrire une fonction qui corrige les points au-dessus de vous-même si vous voulez, comme ceci:

function mymapper($arrayparam, $valuecallback) {
  $resultarr = array();
  foreach ($arrayparam as $key => $value) {
    $resultarr[] = $valuecallback($key, $value);
  }
  return $resultarr;
}

$test_array = array("first_key" => "first_value",
                    "second_key" => "second_value");
$new_array = mymapper($test_array, function($a, $b) { return "$a loves $b"; });
var_dump($new_array);

//array(2) {
//  [0]=>
//  string(27) "first_key loves first_value"
//  [1]=>
//  string(29) "second_key loves second_value"
//}

Voici mon très simple, PHP 5.5-une solution compatible:

function array_map_assoc(callable $f, array $a) {
    return array_column(array_map($f, array_keys($a), $a), 1, 0);
}

Remboursables que vous fournissez doit retourner un tableau avec deux valeurs, c'est à dire return [key, value]. L'appel intérieur à array_map produit donc un tableau de tableaux. Cela devient alors de nouveau converti en tableau à une seule dimension par array_column.

D'utilisation

$ordinals = [
    'first' => '1st',
    'second' => '2nd',
    'third' => '3rd',
];

$func = function ($k, $v) {
    return ['new ' . $k, 'new ' . $v];
};

var_dump(array_map_assoc($func, $ordinals));

De sortie

array(3) {
  ["new first"]=>
  string(7) "new 1st"
  ["new second"]=>
  string(7) "new 2nd"
  ["new third"]=>
  string(7) "new 3rd"
}

Application partielle

Dans le cas où vous avez besoin d'utiliser la fonction de nombreuses fois avec d'autres tableaux, mais la même fonction de mapping, vous pouvez faire quelque chose appelé partielle de la fonction de demande (lié aunourrissage"), qui permet de passer dans le tableau de données lors de l'invocation:

function array_map_assoc_partial(callable $f) {
    return function (array $a) use ($f) {
        return array_column(array_map($f, array_keys($a), $a), 1, 0);
    };
}

...
$my_mapping = array_map_assoc_partial($func);
var_dump($my_mapping($ordinals));

Qui produit le même résultat, étant donné $func et $ordinals sont comme précédemment.

REMARQUE: si votre mappé fonction renvoie la même clé pour deux entrées différentes, la valeur associée à le plus tard clé de la victoire. Inverser le tableau d'entrée et de sortie de la suite de array_map_assoc pour permettre clés pour gagner. (Le retour de l'clés dans mon exemple ne peut pas entrer en collision puisqu'elles intègrent la touche de la source matrice, ce qui à son tour doit être unique.)

---

Alternative

Suivant est une variante de ce qui précède, ce qui peut s'avérer plus logique pour certains, mais nécessite PHP 5.6:

function array_map_assoc(callable $f, array $a) {
    return array_merge(...array_map($f, array_keys($a), $a));
}

Dans cette variante, votre fonction fournie (sur lequel le tableau de données est mappé) devrait plutôt retourner un tableau associatif avec une ligne, c'est à dire return [key => value].
Le résultat de la cartographie de la appelable est alors simplement déballé et transmis à array_merge. Comme précédemment, le retour d'un double de la clé entraînera plus tard, les valeurs de la réussite.

n.b. Alex83690 l'a fait remarquer dans un commentaire que l'utilisation de array_replace ici à la place de array_merge permettrait de préserver entier clés. array_replace ne modifie pas le tableau d'entrée, donc, est sans danger pour le code fonctionnel.

Si vous êtes sur PHP 5.3 à 5.5, le suivant est équivalent. Il utilise array_reduce et le binaire + de la matrice de l'opérateur de convertir la résultante de deux dimensions de la matrice de down d'un tableau à une dimension tout en préservant clés:

function array_map_assoc(callable $f, array $a) {
    return array_reduce(array_map($f, array_keys($a), $a), function (array $acc, array $a) {
        return $acc + $a;
    }, []);
}

D'utilisation

Ces deux variantes seraient utilisés ainsi:

$ordinals = [
    'first' => '1st',
    'second' => '2nd',
    'third' => '3rd',
];

$func = function ($k, $v) {
    return ['new ' . $k => 'new ' . $v];
};

var_dump(array_map_assoc($func, $ordinals));

Note le => au lieu de , dans $func.

Le résultat est le même qu'avant, et chacun peut être partiellement appliquées de la même manière qu'avant.

---

 Résumé

Le but de la question d'origine est de faire de l'invocation de l'appel d'aussi simple que possible, au détriment de la plus compliquée de la fonction qui est appelé; en particulier, avoir la capacité de transmettre le tableau de données dans un seul argument, sans fractionnement les clés et les valeurs. À l'aide de la fonction fournie au début de cette réponse:

$test_array = ["first_key" => "first_value",
               "second_key" => "second_value"];

$array_map_assoc = function (callable $f, array $a) {
    return array_column(array_map($f, array_keys($a), $a), 1, 0);
};

$f = function ($key, $value) {
    return [$key, $key . ' loves ' . $value];
};

var_dump(array_values($array_map_assoc($f, $test_array)));

Ou, pour cette question seulement, on peut faire une simplification array_map_assoc() fonction que les gouttes de sortie touches, puisque la question ne demande pas pour eux:

$test_array = ["first_key" => "first_value",
               "second_key" => "second_value"];

$array_map_assoc = function (callable $f, array $a) {
    return array_map($f, array_keys($a), $a);
};

$f = function ($key, $value) {
    return $key . ' loves ' . $value;
};

var_dump($array_map_assoc($f, $test_array));

Donc la réponse est PAS, vous ne pouvez pas éviter d'appeler array_keys, mais vous pouvez abstraction de l'endroit où array_keys est appelée dans une fonction d'ordre supérieur, qui pourrait être assez bon.

C'est de cette façon que j'ai mis en œuvre ce dans mon projet.

function array_map_associative(callable $callback, $array) {
    /* map original array keys, and call $callable with $key and value of $key from original array. */
    return array_map(function($key) use ($callback, $array){
        return $callback($key, $array[$key]);
    }, array_keys($array));
}

Par le "manuel de la boucle" je voulais écrire une fonction personnalisée qui utilise foreach. Cela renvoie un nouveau tableau comme array_map n'parce que la fonction de l'étendue des causes $array être un copier—pas une référence:

function map($array, callable $fn) {
  foreach ($array as $k => &$v) $v = call_user_func($fn, $k, $v);
  return $array;
}

Votre technique à l'aide de array_map avec array_keys quoique, en réalité, semble plus simple et plus puissant parce que vous pouvez utiliser null comme un rappel pour retourner les paires clé-valeur:

function map($array, callable $fn = null) {
  return array_map($fn, array_keys($array), $array);
}

J'ai fait cette fonction, basée sur la réponse de l'éie:

function array_map_($callback, $arr) {
    if (!is_callable($callback))
        return $arr;

    $result = array_walk($arr, function(&$value, $key) use ($callback) {
        $value = call_user_func($callback, $key, $value);
    });

    if (!$result)
        return false;

    return $arr;
}

Exemple:

$test_array = array("first_key" => "first_value", 
                "second_key" => "second_value");

var_dump(array_map_(function($key, $value){
    return $key . " loves " . $value;
}, $arr));

De sortie:

array (
  'first_key' => 'first_key loves first_value,
  'second_key' => 'second_key loves second_value',
)

Bien sûr, vous pouvez utiliser array_values pour revenir exactement ce que l'OP veut.

array_values(array_map_(function($key, $value){
    return $key . " loves " . $value;
}, $test_array))

Regardez ici! Il y a une solution triviale!

function array_map2(callable $f, array $a)
{
    return array_map($f, array_keys($a), $a);
}

Comme indiqué dans la question, array_map a déjà exactement les fonctionnalités nécessaires. Les autres réponses ici sérieusement compliquer les choses: array_walk n'est pas fonctionnelle.

Utilisation

Exactement comme vous le souhaitez à partir de votre exemple:

$test_array = array("first_key" => "first_value", 
                    "second_key" => "second_value");

var_dump(array_map2(function($a, $b) { return "$a loves $b"; }, $test_array));

Je vois qu'il en manque la réponse évidente:

function array_map_assoc(){
    if(func_num_args() < 2) throw new \BadFuncionCallException('Missing parameters');

    $args = func_get_args();
    $callback = $args[0];

    if(!is_callable($callback)) throw new \InvalidArgumentException('First parameter musst be callable');

    $arrays = array_slice($args, 1);

    array_walk($arrays, function(&$a){
        $a = (array)$a;
        reset($a);
    });

    $results = array();
    $max_length = max(array_map('count', $arrays));

    $arrays = array_map(function($pole) use ($max_length){
        return array_pad($pole, $max_length, null);
    }, $arrays);

    for($i=0; $i < $max_length; $i++){
        $elements = array();
        foreach($arrays as &$v){
            $elements[] = each($v);
        }
        unset($v);

        $out = call_user_func_array($callback, $elements);

        if($out === null) continue;

        $val = isset($out[1]) ? $out[1] : null;

        if(isset($out[0])){
            $results[$out[0]] = $val;
        }else{
            $results[] = $val;
        }
    }

    return $results;
}

Fonctionne exactement comme array_map. Presque.

En fait, il n'est pas pur map comme vous le savez à partir d'autres langues. Php est très bizarre, il ne nécessite certaines très bizarre fonctions de l'utilisateur, pour que nous ne voulons pas unbreak nos précisément cassé worse is better approche.

Vraiment, ce n'est pas vraiment map à tous. Pourtant, il est toujours très utile.

• Première différence évidente de array_map, est que le rappel prend des sorties de each() de chaque tableau d'entrée au lieu de la valeur à lui seul. Vous pouvez toujours parcourir plusieurs tableaux à la fois.

• Deuxième différence est la façon dont la clé est traité après il est retourné à partir de rappel; la valeur de retour de fonction de callback doit être array('new_key', 'new_value'). Les touches peuvent être modifiées, même les touches peut même causer la valeur précédente d'être remplacé, même si la clé a été retourné. Ce n'est pas commun map comportement, mais il vous permet de réécrire les touches.

• Troisième étrange c'est que, si vous omettez key en valeur de retour (soit par array(1 => 'value') ou array(null, 'value')), une nouvelle clé va être affecté, comme si $array[] = $value a été utilisé. Ce n'est pas map's d'un comportement commun, et il est très utile parfois, je suppose.

• Quatrième étrange c'est que, si la fonction de rappel de la fonction ne renvoie pas de valeur, ou retourne null, l'ensemble des courants de clés et de valeurs est omis de la sortie, c'est tout simplement ignorée. Cette fonctionnalité est totalement nations uniesmappy, mais il serait de rendre cette fonction super stunt double pour array_filter_assoc, si il y avait une telle fonction.

• Si vous omettez deuxième élément (1 => ...) (le valeur partie) dans le rappel du retour, null est utilisée au lieu de la valeur réelle.

• D'autres éléments à l'exception de ceux avec des touches de 0 et 1 dans le rappel de retour sont ignorés.

• Et enfin, si lambda renvoie une valeur quelconque à l'exception de null ou un tableau, elle est traitée comme si à la fois la clé et la valeur ont été omises, de telle sorte:

  1. nouvelle clé pour l'élément est affecté
  2. null est utilisé comme valeur

AVERTISSEMENT:

Gardez à l'esprit, que cette dernière fonctionnalité est juste un résidu de fonctionnalités et il est probablement totalement inutile. S'appuyant sur cette fonctionnalité est fortement déconseillée, car cette fonctionnalité va être au hasard deprecated et a changé de façon inattendue dans les futures versions.

REMARQUE:

Contrairement à array_map, tous les non-matrice de paramètres passés à array_map_assoc, à l'exception du premier paramètre de rappel, sont silencieusement coulé à des tableaux.

EXEMPLES:

//TODO: examples, anyone?

Une autre manière de faire avec(sur) la préservation clés:

$test_array = [
    "first_key"     => "first_value",
    "second_key"    => "second_value"
];

$f = function($ar) {
    return array_map(
        function($key, $val) {
            return "{$key} - {$val}";
        },
        array_keys($ar),
        $ar
    );
};

#-- WITHOUT preserving keys
$res = $f($test_array);

#-- WITH preserving keys
$res = array_combine(
    array_keys($test_array),
    $f($test_array)
);