PHP: Some thoughts on using array_* with closures
The other day, I was hacking away on the PHP backend for the “Startup Institute” visualization and I realized it was going to need a good deal of array manipulation. Figuring it was as good a time as any, I decided to try and leverage PHP 5.3+ new closures along with the array_* functions to manipulate the arrays. I’m not well versed with functional programming but I’ve used Underscore.js’s array/collection functions so this is mostly in comparison to that.
The Array
The entire shebang is on GitHub but here is the gist of what we’re intersted in:
There is a CSV file that looks like ssdata.csv.sample except with more entries that is read into a list ($data) where every object has keys cooresponding to the values in the header. Thinking in JSON, the array ends up looking like:
[
{"fname": "Ashish", "lname": "Datta", "track": "dev", "email_address": "ashish@setfive.com"},
{"fname": "Matt", "lname": "Daum", "track": "dev", "email_address": "matt@setfive.com"}
...
]Ok great, but now what can we do with it?
Sorting:
Using the usort function is particularly natural with closures. Compare the following:
<?php
/* Without closures: */
class ArraySorter {
public static $sortKey = "";
public function sort($a, $b){
return strcmp($a[ ArraySorter::$sortKey ], $b[ ArraySorter::$sortKey ]);
}
}
ArraySorter::$sortKey = $sortKey;
usort($data, array("ArraySorter”, "sort”));
/* With closures: */
usort($data, function($a, $b) use($sortKey) {
return strcmp($a[ $sortKey ], $b[ $sortKey ]);
});It’s pretty clear the version with closures is much shorter, more conscience, and ultimately easier to follow. Being able to “capture” the local $sortKey variable is also a key feature on the closure version since with the static version there’s no easy way to introduce variables into the sorting function.
Mapping:
In the linked example, I used array_map to basically convert an array of characters into an array of ASCII values for those characters.
<?php
/* Without: */
for($i = 0; $i < count($data["first_name"]); $i++){
$data["first_name"][$i] = ord($data["first_name"][$i]);
}
/* With: */
$data["first_name"] = array_map(function($el){ return ord($el);}, $data["first_name"]);With such a small map function, it’s hard to see or appreciate the benefits of using the closure along with array_map. With the closure though, you’ll get a couple of benefits including isolated scope so that you won’t inadvertently rely on the value of a variable that isn’t directly related to transforming the array values.
Using the closure would also “look” much cleaner if the array had non-numeric keys, since without being able to use integer indexes the for(…) loop would be more confusing.
Filter it:
This isn’t used but it could have been to return only the elements that were selected.
<?php
/* Without: */
$filteredArray = array();
foreach( $payload as $item ){
if( (strlen($filterEmailAddress)
&& $item["email_address"] == $filterEmailAddress)
|| in_array($item["track"], $selectedTracks) ){
$filteredArray[] = $item;
}
}
/* With: */
$filteredArray = array_filter($payload, function($item) use ($filterEmailAddress, $selectedTracks){
return ((strlen($filterEmailAddress)
&& $item["email_address"] == $filterEmailAddress)
|| in_array($item["track"], $selectedTracks));
});Looking at the the version with the closure, its a bit easier to follow and since it’ll enforce scope isolation if the “truth test” was a bit more complicated you’d only have to debug what’s actually inside the closure. Also, not having to “skip” some elements leaves the code with a nicer feel and overall I’d argue its just better looking.
Overall Thoughts:
Overall, using closures with the array_* functions will definitely lead to cleaner, more concise, and easier to follow code. Unfortunately, there are a few rough spots. Like with most of the standard library, the argument order is inconsistent which is always a constant irritation. For example, for no apparent reason array_map is “callback, array” but array_filter is “array, callback”. Also, another irritation is that the “index” isn’t available inside several of the callbacks like on array_reduce or array_map.
Personally though, the biggest limitation is that none of the array_* functions will work with classes that implement the Traversable or Iterator interfaces. That means if you have a Doctrine_Collection and you want to reduce down to a single result you’re still stuck with a foreach(…).
Anyway, as always I’d love to hear other opinions in the comments.
