To implement advanced conditional filtering using PHP's array_filter, you need to combine custom logic and closures. 1. In the basic usage, array_filter retains elements that return true through the callback function. 2. For associative arrays, you can use if statements to combine multiple conditions, such as checking the user's active status, age and role at the same time. 3. Use the use keyword to introduce external variables (such as $minAge, $allowedRoles) to implement dynamic filtering conditions. 4. Split the filtering logic into independent functions (such as isActive, isAdult, hasValidRole) to improve readability and reusability. 5. When dealing with edge cases, you need to explicitly check null, missing keys or null values to avoid errors caused by loose comparisons. 6. In complex scenarios, multiple filters can be dynamically combined according to the type through the callback distribution mechanism. Ultimately, you should ensure that the data within the callback is fully validated without side effects, and pay attention to performance optimization when processing big data, thereby building clear and scalable filtering logic.

When working with arrays in PHP, filtering data based on complex or advanced conditions is a common requirement. While array_filter is a powerful built-in function, its real potential shines when combined with custom logic — including if statements and nested conditions — to handle more sophisticated filtering scenarios.

Here's how to use array_filter effectively with advanced conditional patterns.

1. Basic array_filter Recap

By default, array_filter loops over each element in an array and keeps only those for which the callback returns true .

 $numbers = [1, 2, 3, 4, 5, 6];
$even = array_filter($numbers, function($n) {
    return $n % 2 === 0;
});
// Results: [2, 4, 6]

But real-world data is rarely this simple.

2. Filtering Associative Arrays with Multiple Conditions

Suppose you have an array of users and want to filter based on multiple criteria like age, role, and activity status.

 $users = [
    ['name' => 'Alice', 'age' => 25, 'role' => 'admin', 'active' => true],
    ['name' => 'Bob', 'age' => 17, 'role' => 'user', 'active' => false],
    ['name' => 'Charlie', 'age' => 30, 'role' => 'moderator', 'active' => true],
    ['name' => 'Diana', 'age' => 19, 'role' => 'user', 'active' => true],
];

Now, filter for:

• Active users
• Age 18 or older
• Role is either 'user' or 'admin'

 $filtered = array_filter($users, function($user) {
    if (!$user['active']) {
        return false;
    }
    if ($user[&#39;age&#39;] < 18) {
        return false;
    }
    if (!in_array($user[&#39;role&#39;], [&#39;user&#39;, &#39;admin&#39;])) {
        return false;
    }
    return true;
});

This approach allows full control using if logic, making it easy to debug and extend.

3. Using External Variables in Filters with use

Sometimes your conditions depend on dynamic values (eg, minimum age from input).

 $minAge = 21;
$allowedRoles = ['user', 'admin'];

$filtered = array_filter($users, function($user) use ($minAge, $allowedRoles) {
    return $user['active'] &&
           $user['age'] >= $minAge &&
           in_array($user['role'], $allowedRoles);
});

The use keyword imports variables into the closure's scope — essential for dynamic filtering.

4. Combining Multiple Filter Rules (Reusable Logic)

For better maintainability, break logic into smaller functions.

 function isActive($user) {
    return $user['active'];
}

function isAdult($user, $minAge = 18) {
    return $user['age'] >= $minAge;
}

function hasValidRole($user, $roles) {
    return in_array($user['role'], $roles);
}

// Now compose them
$filtered = array_filter($users, function($user) {
    return isActive($user) &&
           isAdult($user, 18) &&
           hasValidRole($user, ['user', 'admin']);
});

This improves readability and reusability across different filters.

5. Filtering with Negation and Edge Cases

Be careful with null , empty strings, or missing keys.

 $products = [
    ['name' => 'Laptop', 'price' => 1200, 'stock' => 5],
    ['name' => 'Mouse', 'price' => null, 'stock' => 0],
    ['name' => 'Keyboard', 'price' => 80, 'stock' => 3],
];

// Only in-stock items with valid price
$available = array_filter($products, function($product) {
    if (!isset($product['price']) || $product['price'] === null) {
        return false;
    }
    if (!isset($product[&#39;stock&#39;]) || $product[&#39;stock&#39;] <= 0) {
        return false;
    }
    return true;
});

Explicit checks prevent bugs caused by loose comparison.

6. Filtering with Callback Dispatch (Advanced Pattern)

For highly dynamic systems, route to different filters based on type.

 $filters = [
    'admin' => function($user) { return $user['role'] === 'admin'; },
    'active_adults' => function($user) { return $user['active'] && $user['age'] >= 18; },
    'min_age' => function($user) use ($minAge) { return $user['age'] >= $minAge; }
];

// Apply multiple filters dynamically
$activeAdmins = array_filter($users, function($user) use ($filters) {
    return $filters['admin']($user) && $filters['active_adults']($user);
});

This pattern works well in search or API filtering layers.

Final Notes

• Always validate data inside the callback (check for missing keys, types).
• Use use to inject dependencies cleanly.
• Avoid side effects — array_filter should not modify external state.
• Consider performance: complex logic on large arrays may need optimization or early returns.

With smart use of if logic and closings, array_filter becomes a flexible tool for handling real-world data filtering needs.

Basically, it's not just about simple checks — it's about structuring your conditions clearly and scalably.

The above is the detailed content of Advanced Conditional Patterns Using `array_filter` and `if` Logic. For more information, please follow other related articles on the PHP Chinese website!