{"id":402,"date":"2026-06-30T13:04:14","date_gmt":"2026-06-30T13:04:14","guid":{"rendered":"https:\/\/abrarqasim.com\/blog\/php-8-4-array-find-the-foreach-loops-i-finally-deleted\/"},"modified":"2026-06-30T13:04:14","modified_gmt":"2026-06-30T13:04:14","slug":"php-8-4-array-find-the-foreach-loops-i-finally-deleted","status":"publish","type":"post","link":"https:\/\/abrarqasim.com\/blog\/php-8-4-array-find-the-foreach-loops-i-finally-deleted\/","title":{"rendered":"PHP 8.4 array_find: The Foreach Loops I Finally Deleted"},"content":{"rendered":"

Confession: I have written the same foreach<\/code> loop maybe two thousand times. The one where you iterate over a collection, check a predicate, set a variable, and break<\/code>. Every time I do it I think “there has to be a cleaner way” and every time I shrug and write the loop anyway, because the alternative was array_filter(...)[0] ?? null<\/code> and that’s worse.<\/p>\n

PHP 8.4 finally fixed this. It shipped four new functions, array_find<\/code>, array_find_key<\/code>, array_any<\/code>, and array_all<\/code>, and after a few weeks of using them I’ve deleted more boilerplate than I expected. This post is what I actually replaced, where they shine, and where I still reach for foreach<\/code>.<\/p>\n

The loop I’d been writing forever<\/h2>\n

Here’s the pattern. You’ve got a list of users, you want the first admin, you want null<\/code> if there isn’t one. In PHP 8.3 and below, the cleanest version was something like this:<\/p>\n

$admin = null;\nforeach ($users as $user) {\n    if ($user->role === 'admin') {\n        $admin = $user;\n        break;\n    }\n}\n<\/code><\/pre>\n
Four lines plus the break<\/code> to remember. It’s fine. It works. But it’s noisy, and when you have five of them in a controller method you start scanning for the break<\/code> line to confirm you didn’t typo a condition.<\/p>\n
The “functional” alternative wasn’t much better:<\/p>\n
$admin = array_filter($users, fn($u) => $u->role === 'admin')[0] ?? null;\n<\/code><\/pre>\n
This lies. array_filter<\/code> preserves keys, so [0]<\/code> only works if the first matching element happens to be at index 0. Realistically you needed array_values(array_filter(...))[0] ?? null<\/code>, which is now an unreadable chain that allocates a whole array just to throw it away.<\/p>\n
PHP 8.4 gives you this instead:<\/p>\n
$admin = array_find($users, fn($u) => $u->role === 'admin');\n<\/code><\/pre>\n
Returns the first matching element, or null<\/code> if nothing matches. Short-circuits. Doesn’t allocate. The PHP 8.4 release announcement<\/a> covers the full feature list, but array_find<\/code> and friends are the ones I miss the most when I’m working on an 8.3 codebase now.<\/p>\n
The full set, and when I reach for each<\/h2>\n
There are four new functions and they all take the same (array, callable)<\/code> shape. Here’s how I actually use them.<\/p>\n
array_find($array, $fn)<\/code><\/strong> returns the first element where $fn($value, $key)<\/code> is truthy, or null<\/code>. Use when you want the matched value.<\/p>\n
array_find_key($array, $fn)<\/code><\/strong> returns the key of the first match, or null<\/code>. Use when you need the index back, often to mutate the array in place.<\/p>\n
array_any($array, $fn)<\/code><\/strong> returns true<\/code> if any element matches. Use for guards: “does this collection contain at least one X.”<\/p>\n
array_all($array, $fn)<\/code><\/strong> returns true<\/code> if every element matches. Use for invariants: “every item in the cart is in stock.”<\/p>\n
A real example from a checkout flow:<\/p>\n
\/\/ Before, PHP 8.3\n$hasOutOfStock = false;\nforeach ($cart->items as $item) {\n    if ($item->stock === 0) {\n        $hasOutOfStock = true;\n        break;\n    }\n}\n\nif ($hasOutOfStock) {\n    throw new CheckoutException('Some items are out of stock');\n}\n<\/code><\/pre>\n
\/\/ After, PHP 8.4\nif (array_any($cart->items, fn($i) => $i->stock === 0)) {\n    throw new CheckoutException('Some items are out of stock');\n}\n<\/code><\/pre>\n
Two of these in a single method took my checkout validator from 38 lines to 22, and the diff was nice enough that the reviewer didn’t ask me a single question about it.<\/p>\n
The original RFC<\/a> on the PHP wiki is short and worth reading if you want the design context for why all four landed at once instead of just array_find<\/code>.<\/p>\n
Where I still write the foreach<\/h2>\n
The new functions aren’t a hammer for everything. Three cases where I still reach for foreach<\/code>:<\/p>\n
You need both the matched element and its index.<\/strong> array_find<\/code> gives you the element, array_find_key<\/code> gives you the key, but calling both walks the array twice. If you need both, write the loop.<\/p>\n
$index = null;\n$winner = null;\nforeach ($entries as $i => $entry) {\n    if ($entry->score > 100) {\n        $index = $i;\n        $winner = $entry;\n        break;\n    }\n}\n<\/code><\/pre>\n
You’re mutating as you iterate.<\/strong> The new functions are read-only. If you need to update each item, the old foreach ($items as &$item)<\/code> pattern is still the cleanest path.<\/p>\n
The predicate has side effects.<\/strong> Don’t put a database call or a log line inside an array_any<\/code> callback. The short-circuit behavior is well defined, but anyone reading the code will assume the closure is pure. Reserve these functions for predicates that just look at the value.<\/p>\n
If you’ve spent any time with the Laravel collection methods<\/a> I wrote about recently, the mental model is the same. The new native functions are just the parts of Collection::first()<\/code>, Collection::contains()<\/code>, and Collection::every()<\/code> that finally made it into the language itself, so you don’t need to wrap your data in a collection to get them.<\/p>\n
A small bonus: better error messages<\/h2>\n
One thing I didn’t expect to notice. When I’d typo a predicate in array_filter<\/code> and get back an empty array, debugging was “set a breakpoint, walk the loop, figure out which case isn’t matching.” With array_find<\/code> returning null<\/code>, my code throws on the very next line where I try to use the result, which I always intended would never be null<\/code> because the data invariant said so. That’s a much faster failure than discovering it three function calls deep.<\/p>\n
Small thing. But after years of squinting at filter chains it’s a meaningful upgrade.<\/p>\n
Migration plan if you’re upgrading from 8.3<\/h2>\n
This is what I did across a Laravel 11 codebase last month. Took about ninety minutes.<\/p>\n
First, search the codebase for foreach<\/code> blocks ending in break<\/code>. In most editors that’s a regex like foreach.*\\n.*if.*\\n.*=.*\\n.*break<\/code>. About two-thirds of mine were array_find<\/code> candidates.<\/p>\n
Second, search for array_filter<\/code> followed by array_values<\/code> or reset<\/code>. Those are the “I wanted array_find<\/code> but didn’t have it” cases. Replace them outright.<\/p>\n
Third, search for boolean accumulator patterns: $has = false; foreach ... { if ... { $has = true; break; } }<\/code>. Those are array_any<\/code> candidates and they collapse to a single readable line.<\/p>\n
Fourth, run your tests. The functions are pure and the semantics are obvious, so I had zero regressions across maybe eighty edits, but I wouldn’t ship without the safety net.<\/p>\n
If you’re still on PHP 8.3 and not ready to upgrade, you can polyfill array_find<\/code> in about six lines, but you’re not going to get the same engine-level optimizations. Worth waiting for the real 8.4 deploy.<\/p>\n
The Symfony team’s PHP 8.4 compatibility notes<\/a> (look for the polyfill section) cover a similar deprecation cleanup if you want to see how a large project handled the upgrade.<\/p>\n
What to try this week<\/h2>\n
Grep your codebase for foreach<\/code>. Find a file with three or more of them. Spend twenty minutes converting the ones that are checking a predicate. Read the result out loud. If your eyes stop pulling on the break<\/code> keyword and the boilerplate just goes away, you’ll get why this matters.<\/p>\n
I also keep a short notes page on PHP modernization<\/a> on my site for things like this, and I’m happy to argue about which patterns are worth chasing on any given week. The honest answer for array_find<\/code> is: yes, this one is worth the upgrade. It’s a small feature that quietly improves every list-processing function you’ll write for the next decade.<\/p>\n","protected":false},"excerpt":{"rendered":"
PHP 8.4 added array_find, array_find_key, array_any, and array_all. Here’s where they actually replace a foreach in real code, and where they don’t.<\/p>\n","protected":false},"author":2,"featured_media":401,"comment_status":"","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"rank_math_title":"","rank_math_description":"PHP 8.4 added array_find, array_find_key, array_any, and array_all. Here's where they actually replace a foreach in real code, and where they don't.","rank_math_focus_keyword":"php 8.4 new features","rank_math_canonical_url":"","rank_math_robots":"","footnotes":""},"categories":[52],"tags":[436,49,56,437,53,339],"class_list":["post-402","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-php","tag-array-find","tag-backend","tag-laravel","tag-modern-php-2","tag-php","tag-php-8-4-3"],"_links":{"self":[{"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/posts\/402","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/comments?post=402"}],"version-history":[{"count":0,"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/posts\/402\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/media\/401"}],"wp:attachment":[{"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/media?parent=402"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/categories?post=402"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/abrarqasim.com\/blog\/wp-json\/wp\/v2\/tags?post=402"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}