PHP array_filter(): Filter an Array by Value or Key

array_filter($array, $callback) returns the elements of $array for which $callback returns true (or any value that converts to true). The array comes first, the callback second, and the elements that stay keep their original keys.

<?php
$numbers = [1, 2, 3, 4, 5, 6, 7, 8];

$even = array_filter($numbers, fn($n) => $n % 2 === 0);

print_r($even);

The keys in the result are 1, 3, 5, 7: the positions those values had in the original array. That detail matters more than it looks, and the section after next shows how to deal with it.

Remove empty values from an array

Call array_filter without a callback and it removes every value that converts to false: empty strings, null, false, 0, "0" and empty arrays. That is the quickest way to clean up the pieces of an explode() or a list of form fields.

<?php
$fields = ["Ada", "", null, "0", 0, "London", false, []];

print_r(array_filter($fields));

// Keep 0 and "0", drop only "" and null
print_r(array_filter($fields, fn($v) => $v !== '' && $v !== null));

The first result also lost "0" and 0, which are often real data (a quantity of zero, a postcode digit). When zero is a valid answer, write the callback yourself, as in the second call. The empty page has the full list of values PHP treats as empty.

Reindex the result with array_values

Because the keys are kept, a filtered list can have gaps. A for loop from 0 then hits missing keys, and json_encode turns the result into a JSON object instead of an array. array_values() renumbers it.

<?php
$words = ["apple", "kiwi", "banana", "fig"];

$long = array_filter($words, fn($w) => strlen($w) > 4);

echo json_encode($long), "\n";
echo json_encode(array_values($long)), "\n";

Filter by key with ARRAY_FILTER_USE_KEY

The third argument chooses what the callback receives. ARRAY_FILTER_USE_KEY passes only the key. ARRAY_FILTER_USE_BOTH passes the value and then the key.

<?php
$config = [
    "db_host" => "localhost",
    "db_port" => 5432,
    "app_name" => "Shop",
    "app_debug" => false,
];

// Keep only keys that start with db_
print_r(array_filter($config, fn($key) => str_starts_with($key, 'db_'), ARRAY_FILTER_USE_KEY));

$scores = ["ada" => 92, "bob" => 48, "cy" => 75, "dee" => 55];

// Value and key: a passing score and a name longer than two letters
print_r(array_filter(
    $scores,
    fn($score, $name) => $score >= 50 && strlen($name) > 2,
    ARRAY_FILTER_USE_BOTH
));

To keep a fixed set of keys you already know, array_intersect_key($config, array_flip(['db_host', 'db_port'])) does the same without a callback.

Filter a multidimensional array

Most real data is a list of rows. The callback receives one row at a time, so you test whichever field you need.

<?php
$products = [
    ["name" => "Keyboard", "price" => 49, "inStock" => true],
    ["name" => "Monitor", "price" => 189, "inStock" => false],
    ["name" => "Mouse", "price" => 19, "inStock" => true],
    ["name" => "Webcam", "price" => 65, "inStock" => true],
];

$maxPrice = 60;

$affordable = array_filter(
    $products,
    fn($p) => $p["inStock"] && $p["price"] <= $maxPrice
);

foreach ($affordable as $p) {
    echo "{$p['name']}: \${$p['price']}\n";
}

Change $maxPrice and run it again. To get just the names afterwards, pass the result to array_column: array_column($affordable, 'name').

Filter, then map, then reduce

array_filter picks elements, array_map changes them, and array_reduce folds the array into one value. array_reduce($array, $callback, $initial) calls the callback with the running total and the next element.

<?php
$orders = [
    ["id" => 1, "total" => 120.0, "status" => "paid"],
    ["id" => 2, "total" => 35.5, "status" => "refunded"],
    ["id" => 3, "total" => 80.0, "status" => "paid"],
    ["id" => 4, "total" => 15.0, "status" => "paid"],
];

$paid = array_filter($orders, fn($o) => $o["status"] === "paid");

$totals = array_map(fn($o) => $o["total"], $paid);

$revenue = array_reduce($totals, fn($sum, $t) => $sum + $t, 0);

echo "Paid orders: " . count($paid) . "\n";
echo "Revenue: $revenue\n";

For a plain sum, array_sum($totals) is shorter. array_reduce earns its place when the result is something else: a string, a count per group, the largest row.

Common mistake: changing values inside array_filter

The callback's return value only decides whether an element stays. Anything else it computes is thrown away, so this code does not trim anything:

<?php
$names = ["  Ada ", "", " Grace"];

// Looks like it trims, but array_filter keeps the original values
$wrong = array_filter($names, fn($n) => trim($n));
var_dump($wrong);

// Trim first, then filter
$right = array_values(array_filter(array_map('trim', $names)));
var_dump($right);

Transform with array_map, then filter, and add array_values when you need a clean list.