使用usort()可解決PHP中復雜數據的多條件排序問題，1. 通過自定義回調函數定義排序邏輯，利用操作符返回-1、0或1；2. 實現(xiàn)多級排序時，先比較主要字段，若相等則逐級進入次要字段；3. 可創(chuàng)建動態(tài)回調函數，根據配置數組靈活調整排序字段和方向；4. 支持日期、計算值等複雜類型排序，但需預處理耗時操作以提升性能；5. 若需保留原鍵名，應使用uasort()而非usort()；最終通過結構化回調實現(xiàn)高效、可維護的智能排序，完整結束。

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 associative 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.

以上是用' usort”和'自定義回調”掌握複雜排序邏輯的詳細內容。更多資訊請關注PHP中文網其他相關文章！