How to Sort an Array of Objects by Property in PHP

By the end of this page, you will understand how to sort an array of objects in PHP by a specific property using usort(). You will learn how comparison functions work, how to sort strings and numbers, how ascending and descending order differ, and how this pattern is used in real PHP codebases.

In PHP, an array of objects is a normal array where each item is an object. To sort that array by one object property, you usually use usort().

usort() lets you define how two items should be compared. PHP repeatedly calls your comparison function and rearranges the array based on the result.

Your comparison function must return:

• a negative number if the first item should come before the second
• 0 if they are equal
• a positive number if the first item should come after the second

This matters because arrays of objects are very common in real programs:

• database results turned into objects
• API responses mapped into objects
• collections of users, products, or orders
• reports sorted by totals, names, or timestamps

When sorting objects, the main question is: which property should decide the order?

For example:

• sort by name alphabetically
• sort by count numerically
• sort by ID ascending

In modern PHP, the spaceship operator <=> makes comparisons much cleaner. It returns exactly the kind of value usort() needs.

Think of usort() as hiring a judge to compare two objects at a time.

The judge does not sort the whole array at once. Instead, PHP keeps asking questions like:

• Should Mary Jane come before Johnny?
• Should Johnny come before Kathy?
• Should 420 come before 234?

Your comparison function is the judge's rulebook.

If you say:

• compare $a->name with $b->name, PHP sorts alphabetically
• compare $a->count with $b->count, PHP sorts numerically

So the key idea is:

• usort() does the sorting work
• you provide the rule for comparing two objects

The basic syntax is:

usort($array, function ($a, $b) {
    return $a->property <=> $b->property;
});

Sort by a numeric property

usort($array, function ($a, $b) {
    return $a->count <=> $b->count;
});

This sorts the objects by count in ascending order.

Sort by a string property

usort($array, function ($a, $b) {
    return $a->name <=> $b->name;
});

This sorts the objects by name alphabetically.

Full example

$array = [
    (object) ['ID' => ,  => ,  => ],
    () [ => ,  => ,  => ],
    () [ => ,  => ,  => ],
];

(, function (, ) {
     ->name <=> ->name;
});

();

Consider this example:

$array = [
    (object) ['name' => 'Mary Jane', 'count' => 420],
    (object) ['name' => 'Johnny', 'count' => 234],
    (object) ['name' => 'Kathy', 'count' => 4354],
];

usort($array, function ($a, $b) {
    return $a->count <=> $b->count;
});

What happens step by step:

1. PHP starts sorting the array.

2. It picks two objects to compare.

3. The callback receives them as $a and $b.

4. It evaluates:

   $a->count <=> $b->count
   

5. If $a->count is smaller, the callback returns a negative number.

Sorting arrays of objects by property is used constantly in PHP applications.

Common examples

• User lists: sort users by name, age, or signup date
• Product catalogs: sort products by price, rating, or stock count
• Admin dashboards: sort records by newest first or highest total
• Reports: sort rows by sales count or revenue
• API responses: reorder fetched objects before returning JSON
• Search results: sort by relevance score or alphabetically

Example: sort products by price

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

Example: sort users by last name

usort($users, function ($a, $b) {
    return $a->lastName <=> $b->lastName;
});

In real projects, developers rarely hardcode sorting in only one place. They often build reusable sorting patterns.

1. Sorting by a requested field

$allowedFields = ['name', 'count', 'ID'];
$field = $_GET['sort'] ?? 'name';

if (!in_array($field, $allowedFields, true)) {
    $field = 'name';
}

usort($array, function ($a, $b) use ($field) {
    return $a->$field <=> $b->$field;
});

This uses validation so the code only sorts by safe, expected properties.

2. Guard clauses for missing data

usort($array, function ($a, $b) {
    $aValue = $a->count ?? 0;
    $bValue = $b->count ?? ;

      <=> ;
});

1. Using sort() instead of usort()

sort() does not let you compare object properties directly.

Broken idea:

sort($array);

Use:

usort($array, function ($a, $b) {
    return $a->name <=> $b->name;
});

2. Forgetting that usort() reindexes the array

After sorting, numeric keys are reset.

If you need to preserve keys, usort() is not the right tool.

3. Returning true or false instead of a comparison value

Broken code:

usort($array, function ($a, $b) {
     ->count > ->count;
});

// Sort by numeric property ascending
usort($items, function ($a, $b) {
    return $a->count <=> $b->count;
});

// Sort by numeric property descending
usort($items, function ($a, $b) {
    return $b->count <=> $a->count;
});

// Sort by string property ascending
usort($items, function ($a, $b) {
    return $a->name <=> $b->name;
});

// Sort by dynamic property
$field = 'name';
usort($items, function ($a, $b) use ($field) {
    return $a->$field <=> $b->$field;
});

// Case-insensitive string sort
usort($items, function ($a, $b) {
     (->name) <=> (->name);
});


(, function (, ) {
     (->count ?? ) <=> (->count ?? );
});

How do I sort an array of objects alphabetically in PHP?

Use usort() and compare the string property:

usort($array, fn($a, $b) => $a->name <=> $b->name);

How do I sort an array of objects by a number in PHP?

Compare the numeric property with <=>:

usort($array, fn($a, $b) => $a->count <=> $b->count);

How do I sort in descending order?

Reverse the comparison:

usort($array, fn($a, $b) => $b->count <=> $a->count);

Can I sort by a property name stored in a variable?

Yes.

$field = 'name';
usort(, fn(, ) => -> <=> ->);

• usort() — the main PHP function for custom sorting of array values.
• uasort() — similar to usort(), but preserves array keys.
• sort() — useful for simple arrays of scalar values.
• array_multisort() — can sort multiple related arrays or extracted columns.
• PHP anonymous functions — used to define the sorting callback.
• Spaceship operator <=> — simplifies comparison logic.
• Objects in PHP — important because sorted items are object instances.
• Associative arrays — a related structure often sorted by value or key.
• Null coalescing operator ?? — useful for missing property fallbacks during sorting.