Mapping associative arrays in PHP

Trying to solve the same problem, I came across this Stack Overflow question about accessing keys in PHP’s array_map. The accepted answer uses array_keys, but this is unsatisfactory since it requires giving the array a name (I wouldn’t have been Googling for a solution if it was so easy!).

Turns out there’s no great solution, so I added an answer listing a few alternatives. I’m shamelessly re-posting it here:

The Problem

When mapping an anonymous function over an anonymous array, there is no way to access the keys:

array_map(
    function($val) use ($foo) { /* ... */ },
    array(key1 => val1,
          key2 => val2,
          /* ... */));

array_reduce doesn’t get access to the keys either. array_walk can access keys, but the array is passed by reference, which we can’t do with anonymous values.

Solutions

Array of pairs

This is bad, since we’re changing the original array, which might require pre-processing. Also, the boilerplate array() calls increase linearly with the length of the array`:

array_map(
    function($pair) use ($foo) {
        list($key, $val) = $pair;
        /* ... */
    },
    array(array(key1, val1),
          array(key2, val2),
          /* ... */));

Temporary variable

We don’t need to pre-process the array, and the boilerplate is constant, but we can accidentaly clobber an existing variable:

$i_hope_this_does_not_conflict = array(key1 => val1,
                                       key2 => val2,
                                       /* ... */);
array_map(
    function($key, $val) use ($foo) { /* ... */ },
    array_keys($i_hope_this_does_not_conflict),
    $i_hope_this_does_not_conflict);
unset($i_hope_this_does_not_conflict);

One-shot function

We can use a function to restrict the scope of our temporary variable and prevent clobbering existing names. One downside is that we need to add an extra use clause for the values we’ll need:

call_user_func(
    function($arr) use ($foo) {
        return array_map(function($key, $val) use ($foo) { /* ... */ },
                         array_keys($arr),
                         $arr);
    },
    array(key1 => val1,
          key2 => val2,
          /* ... */));

Multi-argument one-shot function

We define the function we’re mapping in the original scope to prevent the use boilerplate:

call_user_func(
    function($f, $arr) {
        return array_map($f, array_keys($arr), $arr);
    },
    function($key, $val) use ($foo) { /* ... */ },
    array(key1 => val1,
          key2 => val2,
          /* ... */));

New function

The interesting thing to note is that our last one-shot function has a nice, generic signature and looks a lot like array_map. We might want to give this a name so we can re-use it:

function array_mapk($f, $arr) {
    return array_map($f, array_keys($arr), $arr);
}

Our application code then gets back to where we started, but in the process we’ve gained a useful function for our library:

array_mapk(
    function($key, $val) use ($foo) { /* ... */ },
    array(key1 => val1,
          key2 => val2,
          /* ... */));