PHP uksort() Function

PHP

PHP uksort() - Custom Sort by Key

SEO Description: Learn PHP uksort() function. Sort arrays by keys using a user-defined comparison function for custom key-based sorting.

Introduction

In PHP, sorting arrays by their keys is a common requirement, especially when working with associative arrays. While PHP provides built-in functions like ksort() for natural ascending sorting of keys, sometimes you need more control over how keys are sorted. This is where the uksort() function comes in—it lets you define a custom comparison function to determine the order of keys.

In this tutorial, we will explore the uksort() function in detail, showing how to use it effectively to sort arrays by keys in a custom manner, with code examples, best practices, common pitfalls, and interview tips for PHP developers.

Prerequisites

  • Basic understanding of PHP arrays and associative arrays.
  • Familiarity with sorting functions like sort(), ksort().
  • Knowledge of PHP anonymous functions and callbacks.
  • PHP 5.3+ (for anonymous functions) or compatible PHP version.

Setup

To follow this tutorial, you just need a PHP environment (like XAMPP, MAMP, or a local development setup). No additional libraries are required since uksort() is a core PHP function.

What is uksort()?

The uksort() function sorts an array by keys using a user-defined comparison function. Unlike ksort(), which sorts keys according to their natural order, uksort() allows you to specify exactly how keys should be compared.

bool uksort(array &$array, callable $callback)
  • $array: The array to be sorted (passed by reference).
  • $callback: The comparison function that compares two keys and returns 0, <0, or >0.

How the Callback Works

The callback function will receive two keys from the array and must return:

  • < 0 if the first key is “less than” the second key
  • 0 if they are equal
  • > 0 if the first key is “greater than” the second

Examples

Example 1: Basic Alphabetical Reverse Sorting of Keys

Sort keys in reverse alphabetical order using a simple callback.

<?php
$array = [
    "banana" => 3,
    "apple" => 5,
    "orange" => 1,
    "grape" => 7,
];

uksort($array, function($a, $b) {
    return strcmp($b, $a); // Reverse alphabetical sort
});

print_r($array);
?>

Output:

Array
(
    [orange] => 1
    [grape] => 7
    [banana] => 3
    [apple] => 5
)

Example 2: Numeric String Keys Sorted by Numeric Value

Sort keys that are numeric strings but need to be sorted as numbers.

<?php
$array = [
    "10" => "Ten",
    "1" => "One",
    "5" => "Five",
];

uksort($array, function($a, $b) {
    return (int)$a - (int)$b;  // Numeric ascending sort
});

print_r($array);
?>

Output:

Array
(
    [1] => One
    [5] => Five
    [10] => Ten
)

Example 3: Custom Prefix-Based Sorting

When keys have prefixes, you may want to sort based on those prefix priorities.

<?php
$array = [
    "cat_3" => "Cat",
    "dog_1" => "Dog",
    "bird_2" => "Bird",
];

$priority = ["dog" => 1, "cat" => 2, "bird" => 3];

uksort($array, function($a, $b) use ($priority) {
    $prefixA = explode('_', $a)[0];
    $prefixB = explode('_', $b)[0];
    return $priority[$prefixA] - $priority[$prefixB];
});

print_r($array);
?>

Output:

Array
(
    [dog_1] => Dog
    [cat_3] => Cat
    [bird_2] => Bird
)

Best Practices

  • Always return an integer from the callback: The callback must return <0, 0, or >0 appropriately; using strcmp() or numeric comparisons is effective.
  • Avoid modifying the array inside the callback: The callback should only compare keys, not alter the array.
  • Use type casting when needed: If keys are numeric strings, cast to (int) or (float) for numeric comparisons.
  • Use anonymous functions or named functions carefully: For readability, anonymous functions are fine for small callbacks; named functions help reuse.
  • Remember uksort() sorts by keys, not values: If you need to sort by values, use other functions like usort() or uasort().

Common Mistakes

  • Returning boolean values (true or false) instead of integers in the callback.
  • Confusing uksort() with usort() (which sorts by values, not keys).
  • Not passing the array by reference (though uksort() expects a reference).
  • Modifying the array inside the callback leading to unpredictable behavior.
  • Using complex callback logic that slows down sorting unnecessarily.

Interview Questions

Junior Level Questions

  • Q1: What does the uksort() function do in PHP?
    A: It sorts an array by its keys using a user-defined comparison function.
  • Q2: What type of argument does uksort() take for the sorting logic?
    A: A callback function that compares two keys.
  • Q3: Does uksort() sort by keys or values?
    A: It sorts by keys.
  • Q4: How do you define the callback function for uksort() in PHP 7+?
    A: Typically using an anonymous function or named function that accepts two keys.
  • Q5: What should the callback function return when the first key is less than the second?
    A: A negative integer (value < 0).

Mid Level Questions

  • Q1: How can you sort associative array keys numerically using uksort() if keys are strings?
    A: Cast keys to integers inside the callback before comparing.
  • Q2: What happens if your user-defined callback for uksort() returns a boolean value?
    A: It may cause unexpected sorting results because integers are expected.
  • Q3: Can you use a named function instead of an anonymous function with uksort()?
    A: Yes, pass the function name as a string.
  • Q4: How does PHP handle key sorting if two keys are considered equal by the callback?
    A: Their order remains unchanged (stable sorting).
  • Q5: Is it possible to preserve the key-value association when sorting by keys using uksort()?
    A: Yes, uksort() sorts keys in-place preserving key-value pairs.

Senior Level Questions

  • Q1: Explain how you would implement complex key sorting with multiple sorting criteria using uksort().
    A: The callback can implement chained comparisons, e.g., first compare key prefixes, then suffixes, returning as soon as criteria differ.
  • Q2: What are the performance considerations when using uksort() with a heavy callback?
    A: Since the callback is called multiple times, minimize complexity inside it to improve sorting performance.
  • Q3: How can you debug issues in a custom comparison function passed to uksort()?
    A: Use logging or var_dump inside the callback to monitor key pairs being compared.
  • Q4: How does uksort() differ internally from ksort() in PHP’s C source regarding sorting algorithms?
    A: ksort() uses natural ascending order and optimized algorithms without callback overhead, while uksort() must call user callbacks, adding overhead.
  • Q5: Can you use uksort() to sort arrays with non-string keys, like objects or arrays? Why or why not?
    A: No, since keys in arrays must be strings or integers. Objects/arrays are invalid keys in PHP arrays.

Frequently Asked Questions (FAQ)

Q1: What is the difference between uksort() and uasort()?

A: uksort() sorts arrays by their keys using a user-defined comparison, while uasort() sorts by values using a user-defined comparison function.

Q2: Can I use uksort() on indexed arrays?

A: Yes, but indexed arrays have numeric keys, so sorting keys may reorder elements based on their indexes, which is rarely useful. It’s more practical for associative arrays.

Q3: What does it mean that the array is passed by reference in uksort()?

A: The original array is modified in-place by uksort(). No need to assign the result to another variable.

Q4: What happens if the callback does not return the correct integer values?

A: Sorting behavior will be unpredictable, which can result in incorrect key order or errors.

Q5: Is uksort() stable in sorting keys?

A: PHP does not guarantee the stability of uksort(). Keys considered equal may change positions depending on PHP version.

Conclusion

The uksort() function is a powerful tool in PHP for sorting arrays by keys with full customizability via user-defined comparison functions. It helps you sort keys according to any criteria beyond natural order, such as numeric comparison, prefix-based priority, or custom business logic.

By following best practices, understanding how the comparison callback works, and avoiding common pitfalls, you can master uksort() to manipulate associative arrays precisely as needed in your PHP applications.

The flexibility of uksort() makes it essential for complex array key sorting use cases, and knowing it well can add a valuable skill to any PHP developer's toolkit.