Изучаем php: сортировка массива

Sorting based on a list of values

There are situations where it’s not possible to use a numeric or
alphabet-based sort routine. Suppose that you have the following
data to present on a website:

index	name	position
	Mary Johnson	Secretary
	Amanda Miller	Member
	James Brown	Member
	Patricia Williams	Member
	Michael Davis	President
	Sarah Miller	Vice-President
	Patrick Miller	Member

And that you want to sort these names by their position, based on the
following list:

Again, it’s not as difficult as you might think. All we need is the
following custom function:

If you don’t have a second field that you want to sort by, just
replace the highlighted line with return 0;

All we’re doing here is looking at the values in the
position field. If they’re identical then we sort by the
name field instead. Otherwise we do a comparison of where in
the sortorder list the relevant values appear and sort based on
that. The output is as follows:

index	name	position
	Michael Davis	President
	Sarah Miller	Vice-President
	Mary Johnson	Secretary
	Amanda Miller	Member
	James Brown	Member
	Patricia Williams	Member
	Patrick Miller	Member

As detailed above for simpler cases we can now enhance this function
to make it more generic and re-usable, but I’ll leave that as an
exercise for you. You would need pass the sortorder array to
the function along with details of which fields to sort by.

If you’re working on the web with this type of data, you might also
want to read the article Formatting Data as
HTML which presents instructions for converting PHP data to HTML
tables, lists and forms.

Using an ‘anonymous’ function

This is where it starts to get interesting. You can create an
anonymous function based on information gathered at run time.
This allows for greater flexibility, without too much extra coding.

The call can then be shortened to:

Finally, you can wrap it all into a single function as shown below.
Now the code’s starting to look more ‘readable’ which is a good
sign:

index	firstname	lastname	age
	Patricia	Williams	7
	Amanda	Miller	18
	Sarah	Miller	24
	Mary	Johnson	25
	Patrick	Miller	27
	James	Brown	31
	Michael	Davis	43

We now have a simple generic function that can be used to sort any
associative array on a single scalar attribute.

Sorting on a single field

Sorting associative arrays is really quite simple — IF you know
beforehand which field you want to sort by. For example, to sort by
lastname you can use the usort (user-defined search) function:

The output is as follows:

index	firstname	lastname	age
	James	Brown	31
	Michael	Davis	43
	Mary	Johnson	25
	Amanda	Miller	18
	Sarah	Miller	24
	Patrick	Miller	27
	Patricia	Williams	7

To sort by different fields just replace the
compare_lastname function with a function that orders by
firstname (see below), by age, or any other field in
the associative array. The strnatcmp («natural
order» string comparison) function is handy here as it can be
applied to numbers as well as strings.

Below we will explore using a single function to sort by different
fields by specifying the sort field in the function call. The
comparison function can also be generated on the fly as an anonymous
function.

Сортируем массивы-списки в алфавитном и обратном порядке

Для начала давайте познакомимся с достаточно простой и понятной функцией sort().

Она позволит нам отсортировать элементы массива по возрастанию или, если эти элементы строковые – в алфавитном порядке.

Применение ее достаточно простое. Чтобы протестировать эту функцию, нам достаточно объявить некий массив, далее при помощи функции отсортировать его элементы и вывести результат на экран, чтобы увидеть, что получится.

<?
$Mass = array('Катя', 'Аня', 'Лена','Андрей');
sort($Mass);
print_r($Mass);
?>

А результат будет следующим. Как Вы можете видеть на скриншоте справа, элементы отсортированы в алфавитном порядке. Если вместо строковых элементов у нас будут числа, то эта функция также отсортирует числа по возрастанию. Можете проверить это самостоятельно.

Также существует и функция, которая делает обратное действие, то есть сортирует элементы массива по убыванию или в порядке обратном алфавитному.

Эта функция называется rsort(). Работает она следующим образом:

<?
$Mass = array('Катя', 'Аня', 'Лена','Андрей');
rsort($Mass);
print_r($Mass);
?>

Как Вы можете видеть, теперь результат полностью противоположный. Элементы массива отсортированы по убыванию, что в данном случае обозначает в порядке обратном алфавитному.

Думаю, что с этими функциями все предельно ясно. Протестируйте их со своими массивами и у Вас не останется никаких вопросов.

ksort()- Sort Array in Ascending Order, According to Key

The is the following function that sorts an associative array in ascending order, as per according to the key:

<?php
$age = array(«Giselle»=>»25», «Amara»=>»15», «Josephine»=>»28», «Penelope»=>»18» );
ksort($age);

foreach($age as $x => $x_value) {
print_r («Key=» . $x . «, Value=» . $x_value);
print_r («<br>»);
}
?>

1 2 3 4 5 6 7 8 9

<?php $age=array(«Giselle»=>»25″,»Amara»=>»15″,»Josephine»=>»28″,»Penelope»=>»18»); ksort($age); foreach($ageas$x=>$x_value){ print_r(«Key=».$x.», Value=».$x_value); print_r(«<br>»); } ?>

Output:

Key=Amara, Value=15
Key=Giselle, Value=25
Key=Josephine, Value=28
Key=Penelope, Value=18

1 2 3 4

Key=Amara,Value=15 Key=Giselle,Value=25 Key=Josephine,Value=28 Key=Penelope,Value=18

Функция array_multisort

Оказывается разработчики PHP уже давным давно все придумали до нас. Оказывается есть функция array_multisort. Как работает эта функция:
Грубо говоря каждый массив будет отсортирован в соответствии с предыдущим массивом. Вообщем пример:

//Сортируемый масив
$array_main=array(
‘foo’,
‘bar’,
‘foobar’,
);

//Определяющий массив
$array_id=array(
3,
1,
2,
);

array_multisort($array_id, $array_main);

var_dump($array_main);

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

//Сортируемый масив $array_main=array( ‘foo’, ‘bar’, ‘foobar’, );   //Определяющий массив $array_id=array( 3, 1, 2, ); array_multisort($array_id,$array_main); var_dump($array_main);

Выведет:

array(4) {
=> string(3) «bar»
=> string(3) «foobar»
=> string(3) «foo»
}

1 2 3 4 5

array(4){ =>string(3)»bar» 1=>string(3)»foobar» 2=>string(3)»foo» }

А это как раз то что нам надо! Возвращаемся к тестам на скорость:

$data_year=array();
//Генерируем «определяющий» массив
foreach($data as $key=>$arr){
$data_year=$arr;
}

for($i=0; $i<100000; $i++){
$data_tmp=$data;
array_multisort($data_year, SORT_NUMERIC, $data_tmp);
}

1 2 3 4 5 6 7 8 9 10

$data_year=array(); //Генерируем «определяющий» массив foreach($data as$key=>$arr){ $data_year$key=$arr’year’; }   for($i=;$i<100000;$i++){ $data_tmp=$data; array_multisort($data_year,SORT_NUMERIC,$data_tmp); }

Засекаем. Получаем: 3.87 сек. Это рекорд!

Ну то что это самый быстрый вариант мы определили. Это хорошо. А как насчет расширяемости? Как к примеру заставить сортировать массив по двум ключам? Оказывается с этой функцией очень просто! Достаточно добавить еще один «определяющий массив», вот так:

$data_author=array();
foreach($data as $key=>$arr){
$data_author=$arr;
}

$data_year=array();
foreach($data as $key=>$arr){
$data_year=$arr;
}

array_multisort($data_year, SORT_NUMERIC, $data_author, $data);
var_export($data);

1 2 3 4 5 6 7 8 9 10 11 12

$data_author=array(); foreach($data as$key=>$arr){ $data_author$key=$arr’author’; }   $data_year=array(); foreach($data as$key=>$arr){ $data_year$key=$arr’year’; }   array_multisort($data_year,SORT_NUMERIC,$data_author,$data); var_export($data);

На выходе получим вот такой массив:

array(
0 => array(‘text’ => ‘str3’, ‘year’ => ‘2009’, ‘author’ => 20, ),
1 => array(‘text’ => ‘str8’, ‘year’ => ‘2009’, ‘author’ => 20, ),
2 => array(‘text’ => ‘str1’, ‘year’ => ‘2010’, ‘author’ => 10, ),
3 => array(‘text’ => ‘str5’, ‘year’ => ‘2010’, ‘author’ => 20, ),
4 => array(‘text’ => ‘str4’, ‘year’ => ‘2010’, ‘author’ => 30, ),
5 => array(‘text’ => ‘str2’, ‘year’ => ‘2011’, ‘author’ => 10, ),
6 => array(‘text’ => ‘str6’, ‘year’ => ‘2011’, ‘author’ => 10, ),
7 => array(‘text’ => ‘str7’, ‘year’ => ‘2011’, ‘author’ => 20, ),
);

1 2 3 4 5 6 7 8 9 10

array( =>array(‘text’=>’str3′,’year’=>’2009’,’author’=>20,), 1=>array(‘text’=>’str8′,’year’=>’2009’,’author’=>20,), 2=>array(‘text’=>’str1′,’year’=>’2010’,’author’=>10,), 3=>array(‘text’=>’str5′,’year’=>’2010’,’author’=>20,), 4=>array(‘text’=>’str4′,’year’=>’2010’,’author’=>30,), 5=>array(‘text’=>’str2′,’year’=>’2011’,’author’=>10,), 6=>array(‘text’=>’str6′,’year’=>’2011’,’author’=>10,), 7=>array(‘text’=>’str7′,’year’=>’2011’,’author’=>20,), );

Как видите функция справилась со своей задачей. Наш массив отсортирован сначала по year, затем по author. А с помощью различных флагов типа SORT_DESC, SORT_ASC и тд можно добится любой сортировки (про них подробнее смотрите в мане), так что это на мой взгляд самый лучший вариант для использования в своих скриптах.

Минусы

??

Плюсы

• Лучшая скорость
• Расширяемость
• Функциональность

arsort()- Sort Array in Descending Order, According to Value

Therefore, The following function is used to sorts an associative array in descending order, according to the value.

<?php
$age = array(«Giselle»=>»25», «Amara»=>»15», «Josephine»=>»28», «Penelope»=>»18» );
arsort($age);

foreach($age as $x => $x_value) {
print_r («Key=» . $x . «, Value=» . $x_value);
print_r («<br>»);
}
?>

1 2 3 4 5 6 7 8 9

<?php $age=array(«Giselle»=>»25″,»Amara»=>»15″,»Josephine»=>»28″,»Penelope»=>»18»); arsort($age); foreach($ageas$x=>$x_value){ print_r(«Key=».$x.», Value=».$x_value); print_r(«<br>»); } ?>

Output:

Key=Josephine, Value=28
Key=Giselle, Value=25
Key=Penelope, Value=18
Key=Amara, Value=15

1 2 3 4

Key=Josephine,Value=28 Key=Giselle,Value=25 Key=Penelope,Value=18 Key=Amara,Value=15

Proposal

This RFC proposes to make all PHP sorting functions stable. This includes sort, rsort, usort, asort, arsort, uasort, ksort, krsort, uksort, array_multisort, as well as corresponding methods on ArrayObject.

Implementation

The underlying sort implementation remains an unstable hybrid quick sort. Stability is achieved by storing the original order of the array elements and using that order as a fallback sorting criterion.

This matches what is implemented in the PHP code above, with the difference that certain internal implementation details allow us to do this highly efficiently, without increasing memory usage.

An alternative would be to change the underlying sorting algorithm to Timsort, which is inherently stable.

Illegal comparison functions

PHP documents that comparison functions must return an integer smaller than, equal to, or greater than zero. However, due to the specific implementation of sorting in PHP, it is currently also possible to return a boolean that indicates whether the value is greater:

usort($values, function($a, $b) {
    // Should be $a <=> $b !
    return $a > $b;
});

This works, because PHP currently only checks whether the comparison result is “greater than” or not, and never explicitly distinguishes the “equal” and “smaller than” cases. This breaks down with the approach proposed here, because we now do need to know whether values are equal or not, in order to use the fallback sorting criterion.

This RFC takes two steps to address this. First, a deprecation warning will be emitted if a boolean is returned from a custom comparison function. The deprecation warning is thrown only once per sort:

Second, if boolean false is returned, PHP will automatically call the comparison function again with arguments swapped. This allows us to distinguish whether the “false” stood for “equal” or “smaller than”. This fallback behavior should be removed in a future version of PHP.

Performance

Of course, stable sorting is not entirely free. This gist contains a simple script to evaluate sort performance at various levels of duplication in the array. As the results show, sort performance is essentially unchanged if the array does not contain duplicates (and thus stable vs unstable sorting does not matter). However, if the array contains many duplicates, the unstable sort becomes faster, while the stable sort always has approximately the same performance.

Свои способы сортировки

Если предложенные способы сортировки вам не подходят, то можно создать свой способ сортировки ключей и значений массивов.
Для этого есть 3 функции uasort, uksort и usort.
С их помощью мы можем задать свою callback функцию, которая будет сравнивать элементы между собой и определять какой из них «больше» и какой «меньше».

• uasort — Сортирует массив, используя пользовательскую функцию для сравнения элементов с сохранением ключей
• uksort — Сортирует массив по ключам, используя пользовательскую функцию для сравнения ключей
• usort — Сортирует массив по значениям используя пользовательскую функцию для сравнения элементов

Принцип работы следующий, мы создаем callback функцию сравнения по какому-то необычному признаку. Она должна сравнивать элементы и возвращать одно из трех значений: -1, 0 или 1

Давайте рассмотрим как они работают напримере функции uasort, которая сравнивает значения с сохранением ключей.

// Наша функция сравнения
$callbackCmpFunction = function cmp($a, $b) {
    if ($a == $b) { // если 2 значения массива равны
        return 0; // вернем 0
    }
    return ($a < $b) ? -1 : 1; 
}

• -1 — возвращается, когда элемент, который слева больше правого
• 0 — когда элементы равны
• 1 — когда правый больше левого

Применить нашу новую функцию можно так:

// Сортируемый массив
$array = array('a' => 4, 'b' => 8, 'c' => -1, 'd' => -9, 'e' => 2, 'f' => 5, 'g' => 3, 'h' => -4);
print_r($array);

// Сортируем и выводим получившийся массив
uasort($array, $callbackCmpFunction); // вторым параметром указываем нашу callback функцию
print_r($array);

Сохранение ключей означает, что каждый ключ как бы привязан к своему значению.

Функции без сохранения ключей sort и rsort, сбрасывают ключи и они начинают идти по порядку (0, 1, 2, …)

Иногда бывает полезно одно, иногда — другое. В зависимости от задачи.

Если сортировка не дает ожидаемый результат, то изучите флаги сортировки. По умолчанию используется обычный тип сортировки SORT_REGULAR

Флаги типа сортировки:

• SORT_REGULAR — обычное сравнение элементов; подробности описаны в разделе операторы сравнения
• SORT_NUMERIC — числовое сравнение элементов
• SORT_STRING — строковое сравнение элементов
• SORT_LOCALE_STRING — сравнение элементов как строки на основе текущего языкового стандарта. Используется языковой стандарт, который можно изменить с помощью setlocale()
• SORT_NATURAL — сравнение элементов как строки, используя «естественный порядок», например natsort()
• SORT_FLAG_CASE — можно объединять (побитовое ИЛИ) с SORT_STRING или SORT_NATURAL для сортировки строк без учёта регистра. Пример: sort($arr, SORT_NATURAL | SORT_FLAG_CASE)

Флаг сортировки передается в функцию сортировки, например так:

sort($arr, SORT_STRING); 

Операции с массивами

Один из случаев ключевой операции с массивами, а именно его создание мы рассмотрели выше. А как ещё можно создать массив? Самый простой случай, это создание пустого массива:

Создание и модификация массива

Пустой массив может служить заготовкой под определённую коллекцию данных. Конечно его можно не определять заранее и создать прямо в цикле где он должен заполняться, но тогда это будет менее понятный код.

Вы так же можете заполнить массив на лету, например данными из базы данных:

Перебор массивов

С другой стороны готовый массив можно перебрать и например вывести его элементы на экран:

Вообще в php существует больше 70 функций для работы с массивами, однако в большинстве случаев вы будет использовать не больше двадцати. Приведу некоторые из них:

• in_array — проверяет присутствие элемента в массиве
• key_exists  — проверяет присутствует ли в массиве указанный ключ или индекс
• array_search  — осуществляет поиск заданного значения в массиве и возвращает ключ первого найденного значения
• array_merge — объединяет 2 и более массивов в один
• array_chunk — разбивает массив на части

Сортировка массива

Отдельным блоком может идти операции связанные с сортировкой массив. В PHP существует несколько встроенных функций для быстрой сортировки массивов, например по возрастанию/убыванию значения или в алфавитном порядке. Причём сортировка может идти как по ключам массива так и по значениям. Одной из интересных возможностей предоставляет функция , при помощи которой вы можете отсортировать элементы массива используя собственный алгоритм сравнения. Рассмотрим пример:

Как вы понимаете данный пример максимально упрощён. Но внутри вашей функции  можно реализовать любой алгоритм сравнения элементов. Главное правильно возвращать значение, ноль — если элементы не отличаются и их не надо менять местами и 1 или -1 если нужно изменить порядок элементов.

Вы так же можете пробросить в тело функции  внешнюю переменную используя анонимную функцию и ключевое слово :

Грубо говоря сортировка по возрастанию шла пока значение  попадало в диапазон от 0 до 3-х.

Основные функции сортировки массива в PHP

Для сортировки массива в PHP вы можете использовать встроенные функции и . Разница между ними заключается в том, что сортирует массив в обратном порядке (по убыванию), а – в обычном порядке (по возрастанию).

Давайте посмотрим, как это работает. Отсортируем массив с помощью функции , прежде чем отобразить его содержимое. Код выглядит так:

<?php
sort($spisokTsvetov);
foreach ($spisokTsvetov as $key => $value) {
  echo '<p>' . $key . ' - ' . $value . '</p>';
}
?>

Результат будет следующим:

0 - black
1 - blue
2 - green
3 - red
4 - white

Как вы могли заметить, эта функция назначает новые ключи для элементов в массиве. Функция сортировки удаляет все существующие ключи, которые вы могли назначить, вместо того, чтобы просто переупорядочивать ключи. Решение этой проблемы рассмотрим позже.

Если вам нужен обратный порядок, единственное, что вам нужно сделать, это использовать вместо этого функцию , например, так:

<?php
rsort($spisokTsvetov);
foreach ($spisokTsvetov as $key => $value) {
  echo '<p>' . $key . ' - ' . $value . '</p>';
}
?>

И результат будет следующий:

0 - white
1 - red
2 - green
3 - blue
4 - black

Теперь давайте узнаем, как решить проблему с потерей ключей, что важно, если вы используете ассоциативные массивы

Сортировка ассоциативных массивов в PHP

Как мы видели ранее, функции и не подойдут, если нам нужно сохранить ключи нашего массива. К счастью, в PHP есть встроенные функции и для этой проблемы. Функции называются и . По примеру вышерассмотренных функций, сортирует по возрастанию, а – по убыванию. Кроме этого, данные функции поддерживают сохранение ключей массива. Итак, давайте посмотрим, как эти функции справляются с сортировкой данных в массиве. Повторим наш тест с использованием новых функций:

<?php
asort($spisokTsvetov);
foreach ($spisokTsvetov as $key => $value) {
  echo '<p>' . $key . ' - ' . $value . '</p>';
}
?>

Результат будет следующим:

night - black
sky - blue
grass - green
apple - red
wall - white

Теперь результат выглядит намного лучше. Чтобы получить сортировку в обратном порядке, просто используйте функцию вместо .

Но что делать, если вы хотите отсортировать ассоциированные массивы на основе ключей? Нет проблем, давайте посмотрим как это сделать.

Как сортировать массив по ключу в PHP

Вы уже вероятно догадались, что в PHP есть функция сортировки ассоциативного массива по ключам. Этими функциями являются и . Как и прежде, сортирует массив в обратном порядке. Использование такое же, как и раньше, поэтому код будет следующим:

<?php
ksort($spisokTsvetov);
foreach ($spisokTsvetov as $key => $value) {
  echo '<p>' . $key . ' - ' . $value . '</p>';
}
?>

Результат будет следующим:

apple - red
grass - green
night - black
sky - blue
wall - white

Использовать функцию довольно просто.

Помимо рассмотренных функций в PHP есть и другие, более сложные функции сортировки:

• – сортировка нескольких или многомерных массивов.
• – сортировка массива с использованием нечувствительного к регистру алгоритма «естественного порядка»
• – сортировка массива с использованием алгоритма «естественного порядка».
• – сортирует массив с помощью пользовательской функции сравнения и поддерживает связь с индексами.
• – сортирует массив по ключам, используя пользовательскую функцию сравнения
• – сортирует массив по значениям, используя пользовательскую функцию сравнения

Бонусный навык: поиск в массиве с помощью PHP

Представьте себе, что у вас есть большой массив, который заполняется из файла или кода. И вы не знаете, существует ли данное значение в массиве или нет. И если оно существует, то было бы хорошо получить ключ этого элемента.

Массив рассмотрим тот же (что в самом начале статьи).

Теперь, если вы хотите узнать, существует ли значение , вы можете использовать встроенную в PHP функцию . Ниже пример ее использования:

<?php
echo 'Blue is ' . array_search("blue", $spisokTsvetov);
?>

В результате вы получите следующее значение:

Blue is sky

На сегодня все, спасибо, что читаете нас!

• 1144

• 68

• Опубликовано 09/12/2019

• PHP, Уроки программирования

Сортировка массива по ключу

Сортировка массива на основе его ключей как всегда полезна, когда вы имеете дело с ассоциативными массивами. Например, у вас может быть массив с информацией общего количества аэропортов в разных странах.  Предполагая, что названия разных стран являются ключами, а количество аэропортов — значениями, вы можете отсортировать названия стран по алфавиту. Это очень легко сделать с помощью функций и .  Функция сортирует ключи от низкого к высокому, а сортирует ключи от высокого к низкому. 

Вот основной пример сортировки:

Вместо собственной пользовательской функции для сортировки ключей массива вы можете использовать стандартную PHP функцию . На ряду , функция обратного вызова в также требует возврата  целого числа меньше 0, если первый ключ считается меньше второго, и целого числа больше 0, если первый ключ больше второго.  Эта функция также поддерживает ассоциации ключевых значений для элементов массива.

В приведенном выше примере, чтобы отсортировать названия стран по длине их названия, а затем по алфавиту, мы использовали пользовательскую функцию сортировки из предыдущего раздела.

Классическое решение

Естественно первое про что вы подумали, это сортировка многомерного массива с помощью uasort, да? Набросаем вот такой вот код:

function cmp($a, $b) {
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
}
for($i=0; $i<100000; $i++){
$data_tmp=$data;
uasort($data_tmp, ‘cmp’);
}

1 2 3 4 5 6 7 8 9 10

functioncmp($a,$b){ if($a’year’==$b’year’){ return; } return($a’year'<$b’year’)?-11; } for($i=;$i<100000;$i++){ $data_tmp=$data; uasort($data_tmp,’cmp’); }

Запускаем, и засекаем время выполнения… Итого: 13.15 сек. Долговато и не впечатляет.

Ищем пути решения проблемы, находим на php.net, другой вариант функции сравнения, который, как там написано, должен работать быстрее:

function cmp($a, $b) {
return strcmp($a, $b);
}
for($i=0; $i<100000; $i++){
$data_tmp=$data;
uasort($data_tmp, ‘cmp’);
}

1 2 3 4 5 6 7

functioncmp($a,$b){ returnstrcmp($a’year’,$b’year’); } for($i=;$i<100000;$i++){ $data_tmp=$data; uasort($data_tmp,’cmp’); }

Итого: 23.11 сек. Хреновая оптимизация…

Ладно, хорошо, со временем выполнения мы определились. Давайте попробуем определится с «расширяемостью кода». Допустим нам поставили задачу отсортировать сначала по ключу year а затем по ключу author. Для этого нам приходится переписывать всю «дополнительную функцию», в итоге получаем что то похожее на это:

function cmp($a, $b) {
if ($a == $b) {
if ($a == $b){
return 0;
}else{
return ($a < $b) ? -1 : 1;
}
}else{
return ($a < $b) ? -1 : 1;
}
}

1 2 3 4 5 6 7 8 9 10 11

functioncmp($a,$b){ if($a’year’==$b’year’){ if($a’author’==$b’author’){ return; }else{ return($a’author'<$b’author’)?-11; } }else{ return($a’year'<$b’year’)?-11; } }

Громоздко. Сложно изменять. Вообщем отстой, на мой взгляд.

Итак, подведем итоги. Минусы:

• Долго выполняется
• Сложно расширять
• Под каждую сортировку нужна своя, новая функция

Плюсы:

Единственный очевидный вариант (?)

rsort()- Sort Array in Descending Order

There is the following function which sorts the elements of a numerical array in descending numerical order.
Let’s see the example, here also use it in the same script we saw in the example with the fruits name. therefore, The change of function will produce a different result:

<?php
$fruits = ;
rsort($fruits);
print_r($fruits);
?>

1 2 3 4 5

<?php $fruits=’Graps’,’Mango’,’Apple’; rsort($fruits); print_r($fruits); ?>

Output:

Array ( => Mango => Graps => Apple )

1	Array(=>Mango1=>Graps2=>Apple)

Let’s do another example with the numbers. I hope you will notice the script produces an opposite result than sort() did in the previous example:

<?php
$numbers = ;
rsort($numbers);
print_r($numbers);
?>

1 2 3 4 5

<?php $numbers=21,16,71,14,7,25; rsort($numbers); print_r($numbers); ?>

Output:

Array ( => 71 => 25 => 21 => 16 => 14 => 7 )

1	Array(=>711=>252=>213=>164=>145=>7)

Операции с массивами

Последнее обновление: 12.03.2021

Рассмотрим некоторые встроенные наиболее распространенные функции, которые мы можем применять при работе с массивами.

Функция is_array

Функция is_array() проверяет, является ли переменная массивом, и если является, то возвращает , иначе возвращает
. Например:

$users = ;
$isArray = is_array($users);
echo ($isArray==true)?"это массив":"это не массив";

Функции count/sizeof

Функция count() и sizeof() получают количество элементов массива:

$users = ;
$number = count($users);
// то же самое, что
// $number = sizeof($users);
echo "В массиве users $number элемента/ов";

Функции shuffle

Функция shuffle перемешивает элементы массивы случайным образом:

$users = ;
shuffle($users);
print_r($users);
// один из возможных вариантов
//Array (  => Bob  => Tom  => Alice  => Sam )

Функции compact

Функция compact позволяет создать из набора переменных ассоциативный массив, где
ключами будут имена переменных:

<?php

$model = "Apple II";
$producer = "Apple";
$year = 1978;

$data = compact("model", "producer", "year");
print_r($data);
// получится следующий вывод
// Array (  => Apple II  => Apple  => 1978 ) 
?>

Функция compact получает в скобках набор переменных. Каждая переменная указывается в кавычка без знака $. Результатом функции является новый массив.

Сортировка массивов

В PHP имеются два типа сортировки: сортировка строк по алфавиту и сортировка чисел по возрастанию/убыванию. Если сортируемые значения представляют строки,
то они сортируются по алфавиту, если числа — то они сортируются в порядке возрастания чисел. PHP по умолчанию самостоятельно выбирает тип сортировки.

Для сортировки по возрастанию используется функция asort:

$users = ;
asort($users);
print_r($users);
// вывод отсортированного массива
// Array (  => Alice  => Bob  => Sam  => Tom )

В данном случае значения массива представляют строки, поэтому PHP выберет сортировку по алфавиту. Однако с помощью дополнительного параметра мы можем явно указать
интерпретатору PHP тип сортировки. Данный параметр может принимать три значения:

• : автоматический выбор сортировки

• : числовая сортировка

• : сортировка по алфавиту

Укажем явно тип сортировки:

asort($users, SORT_STRING);

Чтобы отсортировать массив в обратном порядке, применяется функция arsort:

arsort($users);

Сортировка по ключам

Функция производит сортировку по значениям элементов, но также существует и еще и сортировка по ключам. Она представлена функцией
ksort:

$states = ;
asort($states);
print_r($states);
// массив после asort	- сортировка по значениям элементов
// Array (  => Berlin  => Madrid  => Paris ) 

ksort($states);
print_r($states);
// массив после ksort - сортировка по ключам элементов
//  Array (  => Paris  => Berlin  => Madrid )

Сортировка по ключам в обратном порядке выполняется функцией krsort():

krsort($states);

Естественная сортировка

Хотя выше описанные функции сортировки прекрасно выполняют свою работу, но их возможностей все-таки недостаточно. Например, отсортируем по возрастанию следующий массив:

<?php
$os = array("Windows 7", "Windows 8", "Windows 10");
asort($os);
print_r($os);
// результат
// Array (  => Windows 10  => Windows 7  => Windows 8 ) 
?>

Так как значения представляют строки, то PHP сортирует по алфавиту. Однако подобная сортировка не учитывает числа и регистр. Поэтому значение
«Windows 10» будет идти в самом начале, а не в конце, как должно было быть. И для решения этой проблемы в PHP есть функция natsort(),
которая выполняет естественную сортировку:

<?php
$os = array("Windows 7", "Windows 8", "Windows 10");
natsort($os);
print_r($os);
// результат
// Array (  => Windows 7  => Windows 8  => Windows 10) 
?>

Если нам надо еще при этом, чтобы сортировка не учитывала регистр, то мы можем применить функцию natcasesort():

natcasesort($os);

НазадВперед