Accéder aux clés de premier niveau avec array_map() sans appeler `array_keys()`

Question

Existe-t-il un moyen de faire quelque chose de ce genre ?

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

var_dump(
    array_map(
        function($a, $b) {
            return "$a loves $b";
        }, 
        array_keys($test_array), 
        array_values($test_array)
    )
);

Mais au lieu d'appeler array_keys y array_values en transmettant directement le $test_array variable ?

Le résultat souhaité est le suivant :

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

Answer 1

Vous pouvez passer les 2 arguments à la fonction pour obtenir la clé et la valeur de votre tableau, comme par exemple :

array_map(function($key, $value) {
    return [$key => $value];
}, array_keys($my_array), $my_array);

Answer 2

Sur la base de Réponse de l'eis Voici ce que j'ai finalement fait pour éviter de gâcher le tableau d'origine :

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

$result_array = array();
array_walk($test_array, 
           function($a, $b) use (&$result_array) 
           { $result_array[] = "$b loves $a"; }, 
           $result_array);
var_dump($result_array);

Answer 3

J'ai créé cette fonction, basée sur Réponse de l'eis :

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

Sortie :

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

Bien entendu, vous pouvez utiliser array_values pour renvoyer exactement ce que veut l'OP.

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

Answer 4

YaLinqo La bibliothèque* est bien adaptée à ce genre de tâche. Il s'agit d'un portage de LINQ de .NET qui prend entièrement en charge les valeurs et les clés dans tous les rappels et qui ressemble à SQL. En voici un exemple :

$mapped_array = from($test_array)
    ->select(function ($v, $k) { return "$k loves $v"; })
    ->toArray();

ou simplement :

$mapped_iterator = from($test_array)->select('"$k loves $v"');

Ici, '"$k loves $v"' est un raccourci pour la syntaxe de fermeture complète que cette bibliothèque prend en charge. toArray() est facultatif. La chaîne de méthodes renvoie un itérateur, de sorte que si le résultat doit simplement être itéré en utilisant la méthode foreach , toArray peut être supprimée.

_{* développé par mes soins}

Answer 5

J'ai toujours aimé la variante javascript de array map. La version la plus simple serait :

/**
 * @param  array    $array
 * @param  callable $callback
 * @return array
 */
function arrayMap(array $array, callable $callback)
{
    $newArray = [];

    foreach( $array as $key => $value )
    {
        $newArray[] = call_user_func($callback, $value, $key, $array);
    }

    return $newArray;
}

Il suffit donc de lui passer une fonction de rappel pour qu'elle construise les valeurs.

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

var_dump(
    arrayMap($testArray, function($value, $key) {
        return $key . ' loves ' . $value;
    });
);