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 (  => 3
 => 8
 => 16
 => 19
 => 24
 => 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 (  => 56
 => 24
 => 19
 => 16
 => 8
 => 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 (  => 16
 => 171
 => 19
 => 24
 => 3
 => 56
 => 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
(
 => 4
 => 31
 => 222
 => 1345
)
Array
(
 => 1345
 => 222
 => 31
 => 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 (  => hh  => kk  => rr  => zz )`