Use usort() to solve the multi-condition sorting problem of complex data in PHP. 1. Define the sorting logic through a custom callback function and use the operator to return -1, 0 or 1; 2. When implementing multi-level sorting, first compare the main fields, and if equal, enter the secondary fields step by step; 3. Create dynamic callback functions to flexibly adjust the sorting fields and directions according to the configuration array; 4. Support complex types such as date and calculated values, but preprocessing and time-consuming operations are required to improve performance; 5. If the original key name is required, uasort() should be used instead of usort(); finally, efficient and maintainable intelligent sorting is achieved through structured callbacks, and the complete ends.

Sorting arrays in PHP is straightforward when dealing with simple data types—just use sort() , asort() , or ksort() and you're done. But what happens when you need to sort complex data, like an array of associated arrays or objects, based on multiple conditions, dynamic rules, or non-standard comparisons? That's where usort() and custom callbacks shine.

Unlike basic sorting functions, usort() lets you define your own comparison logic through a callback function. This opens the door to powerful, flexible sorting behavior that can handle almost any scenario.

How usort() Works

usort() takes two arguments: the array to sort and a callback function that defines the sort order. The callback receives two elements from the array and must return an integer:

• Negative value if the first element should come before the second
• Zero if they are equal
• Positive value if the first should come after the second

 usort($array, function($a, $b) {
    return $a[&#39;value&#39;] <=> $b[&#39;value&#39;];
});

The <=> (spaceship operator) simplifies comparisons by returning -1, 0, or 1 depending on whether the left operand is less than, equal to, or greater than the right.

Sorting by Multiple Criteria

One common challenge is sorting by more than one field. For example, imagine you have an array of users and want to sort by last name, then by first name.

 $users = [
    ['first' => 'John', 'last' => 'Doe'],
    ['first' => 'Jane', 'last' => 'Doe'],
    ['first' => 'Alice', 'last' => 'Smith'],
];

usort($users, function($a, $b) {
    // First, compare last names
    $result = $a[&#39;last&#39;] <=> $b[&#39;last&#39;];

    // If last names are the same, compare first names
    return $result !== 0 ? $result : ($a[&#39;first&#39;] <=> $b[&#39;first&#39;]);
});

This pattern can be extended to three or more fields. Just keep nesting fallback comparisons.

You can also make it more readable by using a helper approach:

 usort($users, function($a, $b) {
    if (($cmp = $a[&#39;last&#39;] <=> $b[&#39;last&#39;]) !== 0) return $cmp;
    if (($cmp = $a[&#39;first&#39;] <=> $b[&#39;first&#39;]) !== 0) return $cmp;
    return 0;
});

Dynamic and Configurable Sorting

Sometimes, you don't know the sort criteria at runtime. You might want to sort by different fields based on user input or configuration.

You can create a reusable callback generator:

 function createSortCallback($sortKeys) {
    return function($a, $b) use ($sortKeys) {
        foreach ($sortKeys as $key => $direction) {
            $direction = strtolower($direction) === 'desc' ? -1 : 1;
            $valA = $a[$key] ?? null;
            $valB = $b[$key] ?? null;

            if ($valA !== $valB) {
                $cmp = $valA <=> $valB;
                return $direction * $cmp;
            }
        }
        return 0;
    };
}

// Usage: sort by last name ascending, then first name descending
$callback = createSortCallback([&#39;last&#39; => &#39;asc&#39;, &#39;first&#39; => &#39;desc&#39;]);
usort($users, $callback);

This makes your sorting logic reusable and driven by configuration.

Handling Complex Data Types

usort() isn't limited to strings and numbers. You can sort by dates, calculated values, or even nested structures.

For example, sorting events by date (assuming dates are strings or timestamps):

 $events = [
    ['name' => 'Event A', 'date' => '2023-12-01'],
    ['name' => 'Event B', 'date' => '2023-11-15'],
];

usort($events, function($a, $b) {
    $dateA = strtotime($a['date']);
    $dateB = strtotime($b['date']);
    return $dateA <=> $dateB;
});

Or sorting products by discounted price:

 $products = [
    ['name' => 'Laptop', 'price' => 1000, 'discount' => 0.1],
    ['name' => 'Phone', 'price' => 800, 'discount' => 0.2],
];

usort($products, function($a, $b) {
    $finalA = $a['price'] * (1 - $a['discount']);
    $finalB = $b['price'] * (1 - $b['discount']);
    return $finalA <=> $finalB;
});

Performance Considerations

While usort() is powerful, each comparison calls your callback, so avoid expensive operations inside it. For example, don't repeatedly parse dates or make database calls in the callback.

Instead, precompute values when possible:

 // Precompute timestamps
foreach ($events as &$event) {
    $event['timestamp'] = strtotime($event['date']);
}
unset($event);

usort($events, function($a, $b) {
    return $a[&#39;timestamp&#39;] <=> $b[&#39;timestamp&#39;];
});

Also, remember that usort() reindexes the array and doesn't preserve keys—use uasort() if you need to keep original keys.

Summary

• Use usort() when sorting complex data that requires custom logic
• Chain comparisons with the spaceship operator for multi-level sorting
• Build dynamic sort callbacks using closures and configuration
• Precompute expensive values to avoid performance hits
• Choose uasort() over usort() if key preservation matters

With well-structured callbacks, usort() becomes a versatile tool for handling real-world sorting challenges in PHP. It's not just about ordering data—it's about doing so intelligently and maintainably.

Basically, once you get the hang of writing comparison logic, the rest is just pattern and performance.

The above is the detailed content of Mastering Complex Sort Logic with `usort` and Custom Callbacks. For more information, please follow other related articles on the PHP Chinese website!