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' => 1, 'name' => 'Mary Jane', 'count' => 420],
    (object) ['ID' => 2, 'name' => 'Johnny', 'count' => 234],
    (object) ['ID' => 3, 'name' => 'Kathy', 'count' => 4354],
];

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

print_r($array);

Result order:

Johnny
Kathy
Mary Jane

Descending order

Swap the values:

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

Now larger count values come first.

Dynamic property sorting

If the property name is stored in a variable:

$field = 'count';

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

This is useful when the user chooses the sort field.

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.

6. PHP places $a before $b.

7. If the counts are equal, the callback returns 0.

8. PHP treats them as equal for sorting.

9. PHP repeats this process until the whole array is ordered.

With the sample data:

• compare 420 and 234 → 420 is greater, so Johnny should come first
• compare 420 and 4354 → 420 is smaller, so Mary Jane stays before Kathy
• final order becomes Johnny, Mary Jane, Kathy when sorted by count

You can verify it:

foreach ($array as $item) {
    echo $item->name . ' - ' . $item->count . PHP_EOL;
}

Output:

Johnny - 234
Mary Jane - 420
Kathy - 4354

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 ?? 0;

    return $aValue <=> $bValue;
});

This avoids errors when some objects do not have the property.

3. Descending sort for dashboards

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

This is common when showing highest values first.

4. Sorting after fetching data

Sometimes data comes from a database already sorted, but if not, PHP sorting is still useful for:

• transformed data
• merged data from multiple sources
• temporary in-memory collections
• custom business rules not handled by SQL easily

5. Encapsulating sort logic in a function

function sortByField(array &$items, string $field): void
{
    usort($items, function ($a, $b) use ($field) {
        return $a->$field <=> $b->$field;
    });
}

This keeps controllers and services cleaner.

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) {
    return $a->count > $b->count;
});

This may appear to work sometimes, but it is not the correct contract.

Correct code:

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

4. Mixing string and numeric logic carelessly

If count is stored as a string like '420', comparisons may still work, but inconsistent data can cause confusion. It is better to keep numeric fields numeric.

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

5. Not handling missing properties

Broken code:

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

If score does not exist on every object, this can produce notices or incorrect behavior.

Safer version:

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

6. Forgetting case sensitivity in string sorting

Alphabetical sorting can behave unexpectedly if names have mixed uppercase and lowercase letters.

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

usort() vs uasort()

Ascending vs descending

String vs numeric sorting

// 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) {
    return strtolower($a->name) <=> strtolower($b->name);
});

// Handle missing properties safely
usort($items, function ($a, $b) {
    return ($a->count ?? 0) <=> ($b->count ?? 0);
});

Rules to remember

• Use usort() for custom sorting of array values.
• The callback compares two items at a time.
• Return negative, zero, or positive.
• Use <=> for clean comparisons.
• Swap left and right to reverse the order.
• usort() resets numeric keys.
• Use uasort() if keys must be preserved.

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($array, fn($a, $b) => $a->$field <=> $b->$field);

What if some objects do not have that property?

Use a fallback value:

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

Does usort() keep the original array keys?

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

Should I sort in PHP or in SQL?

If the data comes from a database, sorting in SQL is often better for large datasets. Sorting in PHP is useful when the data is already loaded or when the sort rule is custom.

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