I got a Slack message from a project manager. A client with a high-traffic WooCommerce shop was complaining that a custom dashboard widget we’d inherited was timing out. Constantly. It was supposed to show a quick breakdown of sales by country, but it was bringing the whole admin area to a crawl.
I SSH’d in, found the widget’s code, and… man, it was a mess. The original dev had used a massive get_posts call to pull thousands of order objects. Then, they used one big foreach loop to check the order status, and inside that, another loop to group them by country, and another to add up the totals. A nested nightmare. It’s a classic example of how reaching for a loop can get out of hand, making your code slow and hard to reason about. Using specific PHP array functions is almost always a cleaner approach.
The “Obvious” Fix That Wasn’t
My first thought? Just cache it. Slap a transient on the final HTML output and call it a day. And yeah, that worked… for about ten minutes. Then the client messaged again: “I just got a new sale from Germany but the widget hasn’t updated.” Of course. The data was stale. Caching the result fixed the performance but ignored the real problem: the horribly inefficient code that generated the data in the first place. The real fix had to be at the query and data-processing level.
Ditching Loops for Smarter PHP Array Functions
Instead of that nested loop monstrosity, you can process array data in stages using functions built for the job. It’s a more functional approach, a concept Carl Alexander wrote a great piece on that’s still relevant. You filter out what you don’t need, transform what’s left into the shape you want, and then reduce it to your final result. Clean. Testable. Readable.
First, I replaced the initial loop—the one filtering for only completed orders—with array_filter. Its only job is to trim down an array based on a condition. Perfect.
Next, instead of looping again to create a new array of just country codes and totals, I used array_map. Its job is to transform an array from one thing into another. In this case, turning a whole WC_Order object into a simple array like ['country' => 'DE', 'total' => 99.50].
Finally, to sum up the totals for each country, array_reduce is the tool. It can take an array of data and “reduce” it down to a single value, which in this case was an array of calculated totals per country.
<?php
// 1. Start with all your raw order objects from the database.
$all_orders = get_posts(/*...args...*/);
// 2. Filter down to only the orders we care about.
$completed_orders = array_filter($all_orders, function($order) {
return $order->post_status === 'wc-completed';
});
// 3. Transform the filtered order objects into a simpler format.
$sales_data = array_map(function($order) {
$wc_order = wc_get_order($order->ID);
return [
'country' => $wc_order->get_shipping_country(),
'total' => $wc_order->get_total(),
];
}, $completed_orders);
// 4. Reduce the clean data to get our final totals.
$totals_by_country = array_reduce($sales_data, function($carry, $sale) {
$country = $sale['country'];
$total = $sale['total'];
if (!isset($carry[$country])) {
$carry[$country] = 0;
}
$carry[$country] += $total;
return $carry;
}, []);
// Now $totals_by_country is a clean, efficient array like ['US' => 540.00, 'DE' => 125.50]
?>So, What’s the Point?
Look, loops aren’t evil. But they’re a blunt instrument. When you use specific functions like array_filter or array_map, you’re writing self-documenting code. You see the function name and you immediately know the intent of that block. A generic foreach loop? You have to read the whole thing to figure out if it’s filtering, transforming, or calculating something. This approach is easier to debug, easier to maintain, and way more efficient when you chain them correctly. And that was it. The widget was fast, the data was fresh, and the client was happy.
Look, this stuff gets complicated fast. If you’re tired of debugging someone else’s mess and just want your site to work, drop my team a line. We’ve probably seen it before.
Leave a Reply