How to Sort an Array of Associative Arrays by Column Value in PHP

By the end of this page, you will understand how to sort an array of associative arrays in PHP using a custom comparison function. You will learn the most common approach with usort(), how ascending and descending sorting work, how to sort by different keys, and which beginner mistakes to avoid.

In PHP, when you have an array where each item is itself an associative array, you often need to sort the outer array based on one value inside each inner array.

In this example, each item has:

• a type
• a price

You do not want to sort by the whole inner array. You want to sort by one specific field: price.

This is a common problem in real programs because data is often structured like this:

• products with name, price, and stock
• users with name, age, and email
• API results with id, created_at, and status

The main PHP tool for this is usort().

usort() lets you sort an array using your own comparison logic. You give it:

1. the array to sort
2. a function that compares two items

That comparison function must return:

Think of usort() like asking a helper to arrange a stack of product cards.

Each card contains multiple pieces of information:

• type
• price

If you just say, “Sort these cards,” the helper does not know what to use.

So you give a rule:

• compare the price on card A and card B
• if A is more expensive, put A first
• if B is more expensive, put B first

usort() is the helper. The comparison function is the rule you give it.

The basic syntax is:

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

Example: sort by price descending

$inventory = array(
    array("type" => "fruit", "price" => 3.50),
    array("type" => "milk", "price" => 2.90),
    array("type" => "pork", "price" => 5.43),
);

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

print_r($inventory);

Output:

Consider this code:

$inventory = array(
    array("type" => "fruit", "price" => 3.50),
    array("type" => "milk", "price" => 2.90),
    array("type" => "pork", "price" => 5.43),
);

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

Step-by-step

1. PHP starts sorting the array

usort() takes control of $inventory and begins comparing pairs of elements.

2. It picks two items

For example, PHP may compare:

$a = array("type" => "fruit", "price" => );
 = ( => ,  => );

Sorting arrays of associative arrays is very common in PHP applications.

Common examples

• E-commerce: sort products by price, rating, or stock
• Admin dashboards: sort users by signup date or last login
• Reports: sort rows by revenue, quantity, or score
• API data: sort decoded JSON arrays by a field like created_at or priority
• Task lists: sort tasks by deadline or importance

Example: sorting products by price

$products = [
    ['name' => 'Laptop', 'price' => 899.99],
    ['name' => 'Mouse', 'price' => 19.99],
    ['name' => 'Monitor', 'price' => 249.99],
];

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

Example: sorting users by age

 = [
    [ => ,  => ],
    [ => ,  => ],
    [ => ,  => ],
];

(, function (, ) {
     [] <=> [];
});

In real projects, developers usually wrap sorting logic in a clear pattern so it is easy to reuse and maintain.

Common patterns

Guard clauses for missing keys

Real data is not always perfect. Some items may not have the key you expect.

usort($inventory, function ($a, $b) {
    $priceA = $a['price'] ?? 0;
    $priceB = $b['price'] ?? 0;

    return $priceB <=> $priceA;
});

This avoids undefined index errors.

Sorting after fetching or decoding data

$data = json_decode($json, true);

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

This is common after reading API responses.

Reusable sort function

1. Using sort() instead of usort()

sort() does not let you compare nested values inside associative arrays.

Broken example:

sort($inventory);

Why it is a problem:

• it sorts using PHP's default rules
• it does not specifically sort by price

Use usort() when you need custom logic.

2. Returning true or false instead of a comparison value

Broken example:

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

Why it is a problem:

• usort() expects negative, zero, or positive values

// Descending by price
usort($inventory, function ($a, $b) {
    return $b['price'] <=> $a['price'];
});

// Ascending by price
usort($inventory, function ($a, $b) {
    return $a['price'] <=> $b['price'];
});

Rules

• Use usort() for custom sorting of indexed arrays.
• The callback receives two elements: $a and $b.
• Return:
  • negative if $a should come first
  • 0 if equal
  • positive if $b should come first
• <=> is a clean way to compare values.
• usort() reindexes numeric keys.

Safe version for missing keys

How do I sort an array of associative arrays by a value in PHP?

Use usort() with a comparison function that compares the desired key, such as price.

How do I sort by price in descending order in PHP?

Use:

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

How do I sort in ascending order instead?

Swap the comparison order:

return $a['price'] <=> $b['price'];

What does the <=> operator do in PHP?

It is the spaceship operator. It compares two values and returns a negative number, 0, or a positive number.

Does usort() preserve array keys?

No. usort() reindexes the array numerically. Use uasort() if you need to preserve keys.

• usort() — the main PHP function for custom sorting.
• uasort() — similar to usort(), but preserves array keys.
• array_multisort() — another way to sort arrays using one or more columns.
• Associative arrays in PHP — important for understanding nested data structures.
• Indexed arrays in PHP — useful because usort() works on indexed arrays.
• Anonymous functions in PHP — used as the comparison callback.
• Spaceship operator <=> in PHP — simplifies comparison logic.
• Null coalescing operator ?? in PHP — helps safely handle missing keys.