How to Sort Arrays in PHP

It's always easier to grab a specific piece of information from sorted data, otherwise you have to go through each element of the array one at a time.

For example, let's say you've stored the score of different students in a class in an array or a table. If the data is not sorted by the scores obtained, you'll have to look at the score of each student in the class before you can tell who obtained the highest and lowest score. If the table was already sorted low to high on basis of scores, just looking at the score of the first student would tell you the lowest mark.

Sorting an Array by Value

Sort an Associative Array
Sorting Array Elements by Value With User-Defined Functions

Sorting an Array by Key
Sorting Multi-Dimensional Arrays in PHP

Sorting With User-Defined Functions
Sorting Across Multiple Columns

Sorting makes a lot of tasks that require accessing or obtaining a specific set of data very easy and efficient. In this tutorial, we will learn how to use built-in PHP functions to sort different kinds of array.

Sorting an Array by Value

Sorting an array by the value of its elements is very easy in PHP. You can choose to maintain or discard key-value associations, and you can also define your own functions to dictate how elements are sorted. I'll show you how in this section of the tutorial.

You can use the sort(&$array, $sort_flags) function to sort the values of an array from low to high. However, it will not maintain any key-value associations when sorting the array. New keys are assigned to sorted elements instead of a simple reordering. The optional second parameter allows you to specify how the elements should be sorted. It can have six different values:

SORT_REGULAR—sort the values without changing their types.
SORT_NUMERIC—sort the values by comparing them numerically.
SORT_STRING—sort the values by comparing them as strings.
SORT_LOCALE_STRING—compare the values as strings based on the current locale. You can update the locale yourself by using setlocale().
SORT_NATURAL—sort the items using "natural ordering" while comparing them as strings.
SORT_FLAG_CASE—can be combined with SORT_STRING or SORT_NATURAL to turn off case-sensitivity while sorting strings.

Here are a couple of sorting examples to help you quickly grasp the difference between all the sort flags.

<?php

$random_data = [32508, 98134, "234984", "3249832", "38", 123, "Apple"];

sort($random_data);
echo "Regular Sorting  — ";
foreach($random_data as $element) {
    echo str_pad($element, 9)." ";
}
// Regular Sorting  — 38        123       32508     98134     234984    3249832   Apple

sort($random_data, SORT_NUMERIC);
echo "\nNumeric Sorting  — ";
foreach($random_data as $element) {
    echo str_pad($element, 9)." ";
}
// Numeric Sorting  — Apple     38        123       32508     98134     234984    3249832

sort($random_data, SORT_STRING);
echo "\nString Sorting   — ";
foreach($random_data as $element) {
    echo str_pad($element, 9)." ";
}
// String Sorting   — 123       234984    3249832   32508     38        98134     Apple

In the first example, regular sorting, the numerical strings are converted to their numerical values, and sorting is done accordingly. The "Apple" string is non-numeric, so it is left untouched and compared as a string.

In the second example, numeric sorting, we want the data to be sorted based on numerical value, so "Apple" is converted to the numeric value 0 and comes first. The rest of the values are sorted as expected.

In the third example, all the values are treated as strings. This means that instead of comparing the numerical value of 123 or 3249832 with 38, they are compared as strings—one character at a time. Since "1" comes before "3", the value 123 is considered lower than 38.

If you want to sort your array values from high to low instead of low to high, you can do so with the help of the rsort() function. It accepts all the same parameters as sort() but sorts the values in reverse order. It also doesn't maintain any key-value associations, so it isn't a good pick for sorting associative arrays.

Sort an Associative Array

Key-value associations become important when you are dealing with associative arrays.

Consider the following example, where an associative array is used to store the names of different persons and their favorite fruit. If you want to sort the list alphabetically by the names of the fruit, using the sort() function from the previous section will result in the loss of the associated keys.

<?php

$fruit_preferences = ["James" => "Orange", "John" => "Banana", "Patricia" => "Apple", "Jennifer" => "Mango", "Mary" => "Grapes"];

echo "Before Sorting — \n";
foreach($fruit_preferences as $person=>$preference) {
    echo $person." likes ".$preference."\n";
}

/*
Before Sorting — 
James likes Orange
John likes Banana
Patricia likes Apple
Jennifer likes Mango
Mary likes Grapes
*/

sort($fruit_preferences);

echo "After Sorting  — \n";
foreach($fruit_preferences as $person=>$preference) {
    echo $person." likes ".$preference."\n";
}

/*
After Sorting  — 
0 likes Apple
1 likes Banana
2 likes Grapes
3 likes Mango
4 likes Orange
*/

?>

As you can see, we not only lost the association of people with their favorite fruit, but we also lost the names of the different people. Each sorted value has been assigned a new numeric index based on its position in the sorted array.

To help you tackle this problem easily, PHP has two different functions which maintain key-value association while sorting arrays by their values. These two functions are asort() and arsort(). The following code snippet sorts the same $fruit_preferences array but uses asort() to do so.

<?php

$fruit_preferences = ["James" => "Orange", "John" => "Banana", "Patricia" => "Apple", "Jennifer" => "Mango", "Mary" => "Grapes"];

echo "Before Sorting — \n";
foreach($fruit_preferences as $person=>$preference) {
    echo $person." likes ".$preference."\n";
}

/*
Before Sorting — 
James likes Orange
John likes Banana
Patricia likes Apple
Jennifer likes Mango
Mary likes Grapes
*/

asort($fruit_preferences);

echo "After Sorting  — \n";
foreach($fruit_preferences as $person=>$preference) {
    echo $person." likes ".$preference."\n";
}

/*
After Sorting  — 
Patricia likes Apple
John likes Banana
Mary likes Grapes
Jennifer likes Mango
James likes Orange
*/

?>

As is evident from the above example, the value Apple moves to the top while still maintaining its association with Patricia. The fruit names could be sorted in reverse just as easily by using the arsort() function.

Both these functions accept the same sorting flags as the value of their optional second parameter as sort() and rsort().

Sorting Array Elements by Value With User-Defined Functions

The four sorting functions can easily handle your common sorting needs with the help of different flags. However, sometimes your criteria for comparing the array elements might be different.

Let's say you have an array of random words which need to be sorted alphabetically. However, you also want to sort them based on their length before sorting them alphabetically. For example, zoo would come after apple in traditional alphabetical sorting. However, if you want to show the short words before longer ones, zoo will appear before apple. In the same set of letters, ape would come before zoo due to alphabetical ordering.

Basically, the words are first sorted based on their length, and then the words with the same number of letters are sorted alphabetically within their own group. This type of sorting is not built into PHP, so we will have to write our own sorting function.

What PHP does in this case is provide you with a couple of functions which can be used to pass the array that you want to sort, along with the name of your own sorting function.

You can use the usort() function to sort array values in regular arrays. Similarly, you can use the uasort() function to sort values in associative arrays while also maintaining key-value associations.

The code snippet below shows one way of accomplishing this behavior.

<?php

$random_words = ["ape", "apple", "zoo", "pie", "elephant", "banana", "picnic", "eye"];

sort($random_words);
echo "Regular Sort Function: \n";
foreach($random_words as $element) {
    echo str_pad($element, 9)." ";
}

/*
Regular Sort Function: 
ape       apple     banana    elephant  eye       picnic    pie       zoo
*/

function custom_sort($word_a, $word_b) {
    if (strlen($word_a) < strlen($word_b)) {
        return -1;
    }
    if (strlen($word_a) == strlen($word_b)) {
        return strcmp($word_a, $word_b);
    }
    if (strlen($word_a) > strlen($word_b)) {
        return 1;
    }
}

usort($random_words, "custom_sort");
echo "\nCustom Sort Function: \n";
foreach($random_words as $element) {
    echo str_pad($element, 9)." ";
}

/*
Custom Sort Function: 
ape       eye       pie       zoo       apple     banana    picnic    elephant
*/

?>

In the callback functions meant for custom sorting, we have to return an integer less than 0 to indicate that the first value is smaller than the second. Return 0 if the first value is equal to the second. Return an integer greater than 0 if the first value is greater than second.

Since our primary sorting criteria was string length, we directly return -1 if the first word is shorter than the second. Similarly, we directly return 1 if the first word is longer than the second. If the two words are equal in length, we compare them alphabetically using the strcmp() function and return its value.

As you can see in the output, our custom sort function reorders the words exactly the way we wanted.

Sorting an Array by Key

Sorting an array based on its keys is generally useful when you are dealing with associative arrays.

For instance, you might have an array with information about the total number of airports in various countries. Assuming that the names of different countries are keys and the numbers of airports are values, you might want to sort the country names alphabetically. This is very easy to do with the ksort() and krsort() functions. Both these functions will maintain the key-value association of array elements after sorting. The ksort() function sorts the keys from low to high, and krsort() sorts the keys from high to low.

Here is a basic sorting example:

<?php

$airport_count = ["United States" => 13513, "Brazil" => 4093, "Mexico" => 1714, "Canada" => 1467, "Russia" => 1218, "Argentina" => 1138, "Bolivia" => 855, "Colombia" => 836, "Paraguay" => 799, "Indonesia" => 673];

ksort($airport_count);

foreach($airport_count as $country=>$count) {
    echo str_pad($country, 15)." ".$count."\n";
}

/*
Argentina       1138
Bolivia         855
Brazil          4093
Canada          1467
Colombia        836
Indonesia       673
Mexico          1714
Paraguay        799
Russia          1218
United States   13513
*/

?>

You can also provide PHP with your own custom function for sorting array keys using the uksort() function. Just like usort(), the callback function in uksort() also requires you to return an integer less than 0 if the first key is considered less than the second one and an integer greater than 0 if the first key is greater than second. This function also maintains the key-value association of array elements.

<?php

$airport_count = ["United States" => 13513, "Brazil" => 4093, "Mexico" => 1714, "Canada" => 1467, "Russia" => 1218, "Argentina" => 1138, "Bolivia" => 855, "Colombia" => 836, "Paraguay" => 799, "Indonesia" => 673];

function custom_sort($word_a, $word_b) {
    if (strlen($word_a) < strlen($word_b)) {
        return -1;
    }
    if (strlen($word_a) == strlen($word_b)) {
        return strcmp($word_a, $word_b);
    }
    if (strlen($word_a) > strlen($word_b)) {
        return 1;
    }
}

uksort($airport_count, "custom_sort");

foreach($airport_count as $country=>$count) {
    echo str_pad($country, 15)." ".$count."\n";
}

/*
Brazil          4093
Canada          1467
Mexico          1714
Russia          1218
Bolivia         855
Colombia        836
Paraguay        799
Argentina       1138
Indonesia       673
United States   13513
*/

?>

In the above example, we have used the custom sort function from the previous section to sort the names of countries first by the length of their name and then alphabetically.

Sorting Multi-Dimensional Arrays in PHP

It is much more common in real life to deal with multi-dimensional information. For instance, institutions will store the marks of all students in a variety of subjects in a single table instead of creating new tables for each subject. If you have to store the same information in PHP, you would also prefer to do it using a multi-dimensional array instead of a separate array for each subject.

Sorting With User-Defined Functions

In this tutorial, we will learn how to sort a multi-dimensional array using a list of tallest buildings in the world as an example. Our array will contain information about the name of the building, the city and country where it is located, the number of floors, and the total height in meters, along with the year in which it was built.

When you want to sort the values in a multi-dimensional array based on a particular field, you can simply use the usort() function. The example below should help you understand this technique better.

<?php

$tallest_buildings = [
    ["Building" => "Burj Khalifa","City" => "Dubai","Country" => "United Arab Emirates","Height" => 828,"Floors" => 163,"Year" => 2010],
    ["Building" => "Shanghai Tower","City" => "Shanghai","Country" => "China","Height" => 632,"Floors" => 128,"Year" => 2015],
    ["Building" => "Abraj Al-Bait Towers","City" => "Mecca","Country" => "Saudi Arabia","Height" => 601,"Floors" => 120,"Year" => 2012],
    ["Building" => "Ping An Finance Center","City" => "Shenzhen","Country" => "China","Height" => 599,"Floors" => 115,"Year" => 2017],
    ["Building" => "Lotte World Tower","City" => "Seoul","Country" => "South Korea" ,"Height" => 554,"Floors" => 123,"Year" => 2016]
];

function storey_sort($building_a, $building_b) {
    return $building_a["Floors"] - $building_b["Floors"];
}

usort($tallest_buildings, "storey_sort");

foreach($tallest_buildings as $tall_building) {
    list($building, $city, $country, $height, $floors) = array_values($tall_building);
    echo $building." is in ".$city.", ".$country.". It is ".$height." meters tall with ".$floors." floors.\n";
}

/*
Ping An Finance Center is in Shenzhen, China. It is 599 meters tall with 115 floors.
Abraj Al-Bait Towers is in Mecca, Saudi Arabia. It is 601 meters tall with 120 floors.
Lotte World Tower is in Seoul, South Korea. It is 554 meters tall with 123 floors.
Shanghai Tower is in Shanghai, China. It is 632 meters tall with 128 floors.
Burj Khalifa is in Dubai, United Arab Emirates. It is 828 meters tall with 163 floors.
*/

?>

In the above example, the information about each building is stored in its own array inside the main $tallest_buildings array. The storey_sort() function simply subtracts the numbers of floors in the second building from the first to determine which building is smaller according to our criteria. We don't have to worry about returning a specific negative or positive value because all negative values mean smaller and all positive values mean bigger.

In the end, we just iterate through the main array and print out information about each building.

Sorting Across Multiple Columns

There is a function called array_multisort() which you can use to sort your multi-dimensional array based on the values of multiple columns or dimensions. You just need to create an array of the key values which you want to use for sorting. After that, it is just a matter of passing the sorting flags.

The following example should make it clear:

<?php

$players = [
    [
        'name' => 'Adam',
        'score' => 70,
        'health' => 80
    ],
    [
        'name' => 'Joey',
        'score' => 60,
        'health' => 90
    ],
    [
        'name' => 'Monty',
        'score' => 70,
        'health' => 45
    ],
    [
        'name' => 'Andrew',
        'score' => 90,
        'health' => 80
    ],
    [
        'name' => 'Sally',
        'score' => 60,
        'health' => 85
    ],
    [
        'name' => 'Amanda',
        'score' => 98,
        'health' => 50
    ],
    [
        'name' => 'James',
        'score' => 50,
        'health' => 50
    ]
];

$p_score = array_column($players, 'score');
$p_health = array_column($players, 'health');

array_multisort($p_score, SORT_DESC, $p_health, SORT_ASC, $players);

?>

We have a multi-dimensional array which stores the name, score, and health of players. We use the array_column() function to create two separate arrays called $p_score and $p_health which store the score and health of the players.

Notice the order in which the arrays are passed to the array_multisort() function. This will have an effect on the final result. We pass the $p_score array first, and the values in $p_score will be sorted in descending order. This will put Amanda at the top as she has the highest score. Now, the elements in the arrays $p_health and $players will also be rearranged so that Amanda's health is at the top in $p_health and she is at the top in $players.

In other words, array_multisort() will sort the whole $p_score array in descending order. Then the values in other arrays will also be rearranged to match that order. So the order will be Amanda, Andrew, Adam, Monty, etc.

Once it has gone through the whole $p_score array, it will move on to the $p_health array. You will notice that both Adam and Monty have the same score. So their ultimate position will be determined by their health values, which have to be sorted in ascending order. Monty has lower health than Adam, so he will be placed before Adam. The order of players will now become Amanda, Andrew, Monty, Adam, and so on.

All other value clashes are resolved in a similar manner. Here is the final result that you will get after sorting the array:

<?php

print_r($players);

/*
Array
(
    [0] => Array
        (
            [name] => Amanda
            [score] => 98
            [health] => 50
        )

    [1] => Array
        (
            [name] => Andrew
            [score] => 90
            [health] => 80
        )

    [2] => Array
        (
            [name] => Monty
            [score] => 70
            [health] => 45
        )

    [3] => Array
        (
            [name] => Adam
            [score] => 70
            [health] => 80
        )

    [4] => Array
        (
            [name] => Sally
            [score] => 60
            [health] => 85
        )

    [5] => Array
        (
            [name] => Joey
            [score] => 60
            [health] => 90
        )

    [6] => Array
        (
            [name] => James
            [score] => 50
            [health] => 50
        )

)
*/

?>

It might have become obvious by now, but I would still like to point out that array_multisort() will not help you save multiple sort() calls for separate arrays. Here's an example:

1	<?php
2
3	$marks_a = [60, 80, 78, 90, 63];
4	$marks_b = [81, 75, 92, 40, 35];
5
6	array_multisort($marks_a, SORT_ASC, $marks_b, SORT_ASC);
7
8	print_r($marks_a);
9	/*
10	Array
11	(
12	[0] => 60
13	[1] => 63
14	[2] => 78
15	[3] => 80
16	[4] => 90
17	)
18	*/
19
20	print_r($marks_b);
21	/*
22	Array
23	(
24	[0] => 81
25	[1] => 35
26	[2] => 92
27	[3] => 75
28	[4] => 40
29	)
30	*/
31
32	?>

If your intention was to sort both the arrays in ascending order independently, then array_multisort() will disappoint you badly. Your best bet in this situation is to simply call sort() separately on both the arrays.

Final Thoughts

In this tutorial, I showed you some different functions in PHP that can be used to sort arrays either by their keys or their values. We also learned how to sort an array by its keys or values using our own custom sorting criteria with the help of the uksort() and uasort() functions. The final section discussed how to sort all the values in a multi-dimensional array using only a specific field.

I hope you learned something new from this tutorial. If you have any questions or suggestions, please let me know in the comments. The best way to learn is to try and create some examples of your own, sorting arrays by using these functions.

This post has been updated with contributions from Monty Shokeen. Monty is a full-stack developer who also loves to write tutorials and to learn about new JavaScript libraries.