How to Sort a 2D Array by a Column Value in PHP

You will learn how to sort a two-dimensional array in PHP using the value of a specific key such as order. By the end, you will understand how usort() works, how to write a custom comparison function, and how to handle ascending and descending sorts safely.

In PHP, a two-dimensional array is an array that contains other arrays. When you want to sort it by one field inside each inner array, such as order, you cannot use basic sorting functions like sort() directly in a useful way because they do not know which inner key should control the ordering.

This is where usort() becomes useful. usort() lets you define how two items should be compared. PHP then repeatedly uses that comparison rule to arrange the full array.

For your case, each item looks like this:

[
    'hashtag' => '...',
    'title' => '...',
    'order' => 3
]

If you want to sort by order, your comparison function should compare:

$a['order']

and

$b['order']

This matters in real programming because data often needs custom ordering:

• sorting products by price
• sorting users by age
• sorting tasks by priority
• sorting API results by date
• sorting menu items by display order

Knowing how to sort by a nested value is a very common PHP skill.

Think of each inner array as a card in a stack.

Each card has several labels on it:

• hashtag
• title
• order

You want to arrange the cards based only on the number written next to order.

usort() is like giving a helper one instruction:

When comparing two cards, put the one with the smaller order number first.

PHP keeps applying that rule until the whole stack is sorted.

The most common way to sort a 2D array by a key in PHP is with usort().

Basic syntax

usort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

The <=> operator is called the spaceship operator. It returns:

• -1 if left is smaller
• 0 if both are equal
• 1 if left is greater

That is exactly what usort() needs.

Example: ascending order

$array = [
    ['hashtag' => 'a7e...', 'title' => 'Flower', 'order' => 3],
    ['hashtag' => 'b24...', 'title' => 'Free',   'order' => 2],
    ['hashtag' => 'e7d...', 'title' => 'Ready',  'order' => 1],
];

usort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

print_r($array);

Result:

Array
(
    [0] => Array
        (
            [hashtag] => e7d...
            [title] => Ready
            [order] => 1
        )

    [1] => Array
        (
            [hashtag] => b24...
            [title] => Free
            [order] => 2
        )

    [2] => Array
        (
            [hashtag] => a7e...
            [title] => Flower
            [order] => 3
        )
)

Example: descending order

usort($array, function ($a, $b) {
    return $b['order'] <=> $a['order'];
});

Older style comparison

If you are not using the spaceship operator, you may see this:

usort($array, function ($a, $b) {
    if ($a['order'] == $b['order']) {
        return 0;
    }
    return ($a['order'] < $b['order']) ? -1 : 1;
});

This works too, but the spaceship version is shorter and clearer.

Consider this code:

$array = [
    ['title' => 'Flower', 'order' => 3],
    ['title' => 'Free', 'order' => 2],
    ['title' => 'Ready', 'order' => 1],
];

usort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

Here is what happens step by step:

1. PHP starts sorting the array.
2. It picks two items to compare.
3. The callback receives them as $a and $b.
4. It compares $a['order'] and $b['order'].
5. If $a['order'] is smaller, it returns -1, so $a should come first.
6. If they are equal, it returns 0, so their relative position does not need to change.
7. If $a['order'] is larger, it returns 1, so $b should come first.
8. PHP repeats this process until the whole array is sorted.

Small comparison trace

Suppose PHP compares:

['title' => 'Flower', 'order' => 3]

and

['title' => 'Free', 'order' => 2]

Then:

3 <=> 2

returns:

1

That means the first item should come after the second one.

Next, if it compares:

2 <=> 1

it returns 1 again, so the item with order = 1 moves earlier.

Final order becomes:

• Ready
• Free
• Flower

Sorting a 2D array by a key is common in many PHP applications.

Typical use cases

• Menu items sorted by display order
• Tasks sorted by priority
• Blog posts sorted by publish date or rank
• Products sorted by price or stock level
• API responses sorted before sending data to the frontend
• Form fields sorted by custom position

Example: sorting menu items

$menu = [
    ['label' => 'Contact', 'order' => 3],
    ['label' => 'Home', 'order' => 1],
    ['label' => 'About', 'order' => 2],
];

usort($menu, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

This ensures the menu appears in the intended order.

Example: sorting products by price

$products = [
    ['name' => 'Phone', 'price' => 699],
    ['name' => 'Case', 'price' => 29],
    ['name' => 'Charger', 'price' => 19],
];

usort($products, function ($a, $b) {
    return $a['price'] <=> $b['price'];
});

In real projects, developers usually sort arrays after fetching data from:

• a database
• an external API
• a config file
• user input

Common patterns

1. Sorting by a configurable field

$sortKey = 'order';

usort($array, function ($a, $b) use ($sortKey) {
    return $a[$sortKey] <=> $b[$sortKey];
});

This is useful when the sort key can change.

2. Guarding against missing keys

usort($array, function ($a, $b) {
    $aValue = $a['order'] ?? PHP_INT_MAX;
    $bValue = $b['order'] ?? PHP_INT_MAX;
    return $aValue <=> $bValue;
});

This avoids errors if some items do not have an order value.

3. Early data cleanup before sorting

$array = array_filter($array, function ($item) {
    return isset($item['order']);
});

usort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

This is a common pattern when input data may be incomplete.

4. Sorting before rendering a view

Developers often sort arrays right before looping over them in templates or controllers so the output is predictable.

5. Reindexing behavior

usort() reindexes numeric keys. In many codebases, that is fine. But if preserving original keys matters, developers often use uasort() instead.

1. Using sort() instead of usort()

Broken example:

sort($array);

Why it is a problem:

• sort() does not let you choose a nested key like order
• it compares whole values in a way that is usually not what you want

Use this instead:

usort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

2. Returning true or false from the callback

Broken example:

usort($array, function ($a, $b) {
    return $a['order'] > $b['order'];
});

Why it is a problem:

usort() expects:

• negative number
• zero
• positive number

A boolean is not the proper comparison result.

Correct version:

usort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

3. Forgetting that values may be strings

If order comes from a form or API, it may be a string like '10'.

Safer version:

usort($array, function ($a, $b) {
    return (int)$a['order'] <=> (int)$b['order'];
});

4. Not handling missing keys

Broken example:

usort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

If one item has no order, this can cause warnings.

Safer version:

usort($array, function ($a, $b) {
    $aOrder = $a['order'] ?? PHP_INT_MAX;
    $bOrder = $b['order'] ?? PHP_INT_MAX;
    return $aOrder <=> $bOrder;
});

5. Expecting original numeric keys to stay the same

usort() reindexes the array from 0, 1, 2...

If you need to preserve keys, use uasort().

uasort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

usort() vs uasort()

• Use usort() when key preservation does not matter.
• Use uasort() when you want to keep the original array keys.

Spaceship operator vs manual comparison

Sorting numbers vs sorting strings

Sort a 2D array by key in PHP

Ascending

usort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

Descending

usort($array, function ($a, $b) {
    return $b['order'] <=> $a['order'];
});

Preserve original keys

uasort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

Handle missing keys safely

usort($array, function ($a, $b) {
    return ($a['order'] ?? PHP_INT_MAX) <=> ($b['order'] ?? PHP_INT_MAX);
});

Cast values to integers

usort($array, function ($a, $b) {
    return (int)$a['order'] <=> (int)$b['order'];
});

Important rules

• usort() sorts the original array in place.
• usort() reindexes numeric keys.
• The callback must return a negative number, 0, or a positive number.
• Use <=> for clean comparisons.
• Use uasort() if you must preserve keys.

How do I sort a multidimensional array by one key in PHP?

Use usort() with a callback that compares the chosen key:

usort($array, function ($a, $b) {
    return $a['order'] <=> $b['order'];
});

How do I sort in descending order in PHP?

Reverse the comparison:

usort($array, function ($a, $b) {
    return $b['order'] <=> $a['order'];
});

What is the difference between usort() and uasort()?

usort() reindexes numeric keys. uasort() preserves the original keys.

Can I sort by a string key like title instead of order?

Yes. For example:

usort($array, function ($a, $b) {
    return strcmp($a['title'], $b['title']);
});

Does usort() return a new array?

No. It sorts the existing array directly.

What happens if two items have the same order value?

The comparison returns 0, meaning they are considered equal for sorting. Their final relative order should not be relied on unless you add a secondary comparison.

Should I cast order to an integer?

If the values may come from forms, JSON, or databases as strings, casting to (int) is a good idea.

• usort() — The main PHP function for custom sorting.
• uasort() — Similar to usort() but preserves array keys.
• array_multisort() — Useful when sorting multiple related arrays or columns.
• associative arrays — Important because each row is an associative array with named keys.
• multidimensional arrays — This question is about sorting arrays that contain arrays.
• spaceship operator — A concise way to write comparison logic in PHP.
• comparison functions — Core idea behind custom sorting.
• null coalescing operator — Helpful for handling missing keys safely during sorting.