Categories

# Sorting Arrays

The simplest array-sorting functions are sort( ) and rsort( ), which rearrange the elements of the subject array in ascending and descending order, respectively:

All sorting functions rearrange the elements in the source array itself. Because of this behavior, the sort functions must be passed a variable, not an expression. In this tutorial, we’ll discuss the sort and rsort functions. Both functions sort the subject array based on the values of each element.

```<?php
/*Syntax:
sort (array &\$array, int \$flags = SORT_REGULAR): bool
rsort(array &\$array, int \$flags = SORT_REGULAR): bool
*/```

## Sorting Arrays in Ascending Order – `sort()`

The following example shows the `sort( )` function on an array of integers:

```<?php
\$numbers = array(24, 19, 3, 16, 56, 8);

sort(\$numbers);

foreach(\$numbers as \$n)
echo "\$n ";
//3 8 16 19 24 56

print_r ( \$numbers );
/*
Array ( [0] => 3
[1] => 8
[2] => 16
[3] => 19
[4] => 24
[5] => 56 )
*/```

## Sorting Arrays in Descending Order – `rsort()`

The following example shows the `rsort( )` function on the same array:

```<?php
\$numbers = array(24, 19, 3, 16, 56, 8);
rsort(\$numbers);
foreach(\$numbers as \$n)
echo "\$n ";
print_r(\$numbers);```

The output of the example shows the elements sorted in reverse order by value:

```//56 24 19 16 8 3

Array ( [0] => 56
[1] => 24
[2] => 19
[3] => 16
[4] => 8
[5] => 3 )```

## Sorting Arrays Alphabetically

By default, PHP sorts strings in alphabetical order and numeric values in numeric order. An optional parameter, `flag`, can be passed to force the string or numeric sorting behavior. In the following example, the PHP constant `SORT_STRING` sorts the numbers as if they were strings:

```<?php
\$numbers = array(24, 19, 3, 16, 56, 8, 171);
sort(\$numbers, SORT_STRING);
print_r(\$numbers);```

The output of the example shows the result:

```Array ( [0] => 16
[1] => 171
[2] => 19
[3] => 24
[4] => 3
[5] => 56
[6] => 8 )```

## Sorting Flags

Numerical arrays can be sorted rather easily by using `sort()` or `rsort()`. However, a problem exists if the array contains both numerical and string values (for instance, `"2" > "10"` but `2 < 10`). Therefore, the sorting can be tweaked so that a special data type is used for comparing elements when sorting:

• `SORT_REGULAR` – sorts elements according to their data type (the default behavior).
• `SORT_NUMERIC` – sorts elements as numbers.
• `SORT_STRING` – sorts elements as strings.
• `SORT_LOCALE_STRING` – sorts elements as strings, based on the current locale.
• `SORT_NATURAL` – sorts elements as strings using “natural ordering” like `natsort()`.
• `SORT_FLAG_CASE` – can be combined (bitwise OR) with `SORT_STRING` or `SORT_NATURAL` to sort strings case-insensitively

### Using `SORT_NUMERIC` and `SORT_STRING` flags

```<?php
\$a = array('4', 31, '222', 1345);

sort(\$a, SORT_NUMERIC);
print_r(\$a);

sort(\$a, SORT_STRING);
print_r(\$a);```

Here is the output of the preceding listing:

```Array
(
[0] => 4
[1] => 31
[2] => 222
[3] => 1345
)
Array
(
[0] => 1345
[1] => 222
[2] => 31
[3] => 4
)```

If you want to sort the elements of the array in reverse order (descending order), use `rsort()` (r for reverse). The same optional second parameters are allowed that can be used with `sort()`.

`sort( )` and `rsort( )` can be used on associative arrays, but the keys are lost. The resulting array contains only the values in the sorted order. Consider the following example:

```<?php
\$map = array("o"=>"kk", "e"=>"zz", "z"=>"hh", "a"=>"rr");
sort(\$map);
print_r(\$map);```

The `print_r( )` output shows the modified array without the key values:

`Array ( [0] => hh [1] => kk [2] => rr [3] => zz )`