Сортировка массивов в php: ksort, asort и прочие sort’ы

Введение в сортировку массивов в PHP

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

<?php
$spisokTsvetov = array(
  "apple"  => "red",
  "grass"  => "green",
  "sky"    => "blue",
  "night"  => "black",
  "wall"   => "white"
);
?>

Теперь, если вы выведете массив, вы увидите элементы в том же порядке, в котором они были определены:

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

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

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

Теперь перейдем к процессу сортировки этого массива.

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  and  functions. Both these functions will maintain the key-value association of array elements after sorting. The  function sorts the keys from low to high, and sorts the keys from high to low.

Here is a basic sorting example:

You can also provide PHP with your own custom function for sorting array keys using the function. Just like , the callback function in 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.

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

Массивы на «стероидах»

Часто работаете с массивами? Тогда вам понравится это расширение для работы с коллекциями.

Рассмотрим несколько примеров.

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

$collection = collect();

$sorted = $collection->sort();

$sorted->values()->all();

// 

Сортировка по одной «колонке» ассоциативного массива:

$collection = collect(,
    ,
    ,
]);

$sorted = $collection->sortBy('price');

$sorted->values()->all();

/*
    ,
        ,
        ,
    ]
*/

Сортировка по нескольким аттрибутам одновременно:

$collection = collect(,
    ,
    ,
    ,
]);

$sorted = $collection->sortBy(,
    ,
]);

$sorted->values()->all();

/*
    ,
        ,
        ,
        ,
    ]
*/

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

$collection = collect(,
    ,
    ,
    ,
]);

$sorted = $collection->sortBy( <=> $b,
    fn ($a, $b) => $b <=> $a,
]);

$sorted->values()->all();

/*
    ,
        ,
        ,
        ,
    ]
*/

Коллекции позволяют работать с массивами как в Laravel и функции этого замечательного инструмента далеко не ограничиваются сортировкой.

Изучите документацию и вы влюбитесь в коллекции.

Помогла ли Вам эта статья?

Да
Нет

Пользовательская сортировка

Также мы можем задать и свои порядок сортировки, то есть создать пользовательскую сортировку.

Для этого также в php предусмотрены специальные функции.

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

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

Функция сравнения будет принимать две переменные и должна возвращать одно из значений:

1 – если первый элемент сравнения больше второго;

-1 – если второй больше первого;

0 – если элементы равны.

Таким образом мы, например, можем отсортировать элементы массива по возрастанию их длины.

Для этого сначала объявим сам массив, который будет содержать строковые элементы различной длины.

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

После этого воспользуемся функцией для пользовательской сортировки usort(). Ей передадим в качестве аргументов: имя нашего массива и имя функции, которую мы создали для сравнения элементов.

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

<?
$Mass = array('Андрей', 'Яна', 'Катя');
function check_length($str1,$str2){
$length1 = strlen($str1);
$length2 = strlen($str2);
if($length1 == $length2):
return 0;
elseif($length1 < $length2):
return -1;
else:
return 1;
endif;	
}
usort($Mass,"check_length");
print_r($Mass);
?>

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

Также мы можем сделать пользовательскую сортировку ассоциативного массива по его ключам. Для этого нам понадобится функция uksort() и сам ассоциативный массив.

Давайте оставим пользовательскую функцию той же, то есть сравниваем длину ключей.

<?
$Mass='яна';
$Mass='андрей';
$Mass='катя';
function check_length($str1,$str2){
$length1 = strlen($str1);
$length2 = strlen($str2);
if($length1 == $length2):
return 0;
elseif($length1 < $length2):
return -1;
else:
return 1;
endif;	
}
uksort($Mass,"check_length");
print_r($Mass);
?>

Ключи элементов массива отсортированы по возрастанию их длины.

И также мы можем создать пользовательскую сортировку ассоциативного массива по значениям его элементов. В этом нам поможет функция uasort().

Принцип все тот же.

<?
$Mass='яна';
$Mass='андрей';
$Mass='катя';
function check_length($str1,$str2){
$length1 = strlen($str1);
$length2 = strlen($str2);
if($length1 == $length2):
return 0;
elseif($length1 < $length2):
return -1;
else:
return 1;
endif;	
}
uasort($Mass,"check_length");
print_r($Mass);
?>

Теперь массив отсортирован по увеличению длин его значений.

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

Чтобы хорошенько понять, как работает пользовательская сортировка, нужно попрактиковаться и попробовать написать какую-то свою функцию сравнения.

Однако, теперь, я думаю, у Вас есть полное представление о том, как можно сортировать элементы массива и каким образом эти отсортированные элементы использовать.

Практикуйтесь, пишите Ваши комментарии и делитесь статьей с друзьями при помощи кнопок социальных сетей.

Если Вы еще не подписаны на обновления блога, то подписывайтесь. Форма подписки находится ниже.

С Вами была Анна Котельникова. До встречи в следующих статьях.

Меняем порядок сортировки

Вы можете пропустить (опционально) flag-аргумент после аргумента массива чтобы менять порядок сортировки:

SORT_ASC сортировка по возрастаниюSORT_DESC сортировка по убыванию

Тут сортируем $directors по возрастанию, затем $titles по убыванию:

 $directors = array( "Stanley Kubrick", "Alfred Hitchcock", "Martin Scorsese", "Stanley Kubrick" ); $titles = array( "Full Metal Jacket", "Rear Window", "Mean Streets", "A Clockwork Orange" ); $years = array( 1987, 1954, 1973, 1971 ); array_multisort( $directors, SORT_ASC, $titles, SORT_DESC, $years ); print_r( $directors ); echo "<br />"; print_r( $titles ); echo "<br />"; print_r( $years ); echo "<br />"; 

Вот что вышло: заметьте, что «Full Metal Jacket» теперь перед «A Clockwork Orange»:

Array ( => Alfred Hitchcock => Martin Scorsese => Stanley Kubrick => Stanley Kubrick ) Array ( => Rear Window => Mean Streets => Full Metal Jacket => A Clockwork Orange ) Array ( => 1954 => 1973 => 1987 => 1971 )

Сортировка многомерных массивов

Сортировка через array_multisort() проходит по первому элементу каждого массива. Если 2 значения одинаковы, сортирвка идёт по 2у элементу и тп.

Это пример, который показывает, как это работает Сортировка идет по director, потом по title, потом по year:

 $movies = array( array( "director" => "Alfred Hitchcock", "title" => "Rear Window", "year" => 1954 ), array( "director" => "Stanley Kubrick", "title" => "Full Metal Jacket", "year" => 1987 ), array( "director" => "Martin Scorsese", "title" => "Mean Streets", "year" => 1973 ), array( "director" => "Stanley Kubrick", "title" => "A Clockwork Orange", "year" => 1971 ) ); array_multisort( $movies ); echo "<pre>"; print_r( $movies ); echo "</pre>"; 

Результат:

Array ( => Array ( => Alfred Hitchcock => Rear Window => 1954 )

=> Array ( => Martin Scorsese => Mean Streets => 1973 )

=> Array ( => Stanley Kubrick => A Clockwork Orange => 1971 )

=> Array ( => Stanley Kubrick => Full Metal Jacket => 1987 )

Как видите, array_multisort() отсортирвал массив по director. Когда имя режиссёра повторилось, («Stanley Kubrick»), сортировка пошла по title.

Чтобы отсортровать в обратном порядке, укажите SORT_DESC-флаг как второй аргумент array_multisort(). Просто!

Итог

В этом уроке мы посмотрели на простые PHP-функции для сортровки массива:

* sort() и rsort() для сортровки индексируемых массивов * asort() и arsort() для сортровки асоциативных массивов * ksort() и krsort() для сортровки ассоциативнх массивов по ключу * array_multisort() для сортировки для сортировки сложных и многомерных массивов

______________

Наткнулся тут на интересный блог – блог про блоги так сказать) Автор обзоры делает)

Naikom » Кодинг » PHP

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.

Сортировка многомерных массивов

Создадим функцию, которая нам поможет в сортировке массивов

// создадим функцию которая нам поможет в сортировке массивов
function array_orderby()
{
    $args = func_get_args();
    $data = array_shift($args);
    foreach ($args as $n => $field) {
        if (is_string($field)) {
            $tmp = array();
            foreach ($data as $key => $row)
                $tmp = $row;
            $args = $tmp;
            }
    }
    $args[] = &$data;
    call_user_func_array('array_multisort', $args);
    return array_pop($args);
}

Пример работы этой функции :

$data = ,
	,
	,
	,
	,
	,
];
	
// Сортируем массив $data сначала по volume, затем по edition
$sorted = array_orderby($data, 'volume', SORT_DESC, 'edition', SORT_ASC);
// SORT_ASC - по возрастанию
// SORT_DESC - по убыванию

print_r($sorted); // выводим результат

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); 

Функция 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 и тд можно добится любой сортировки (про них подробнее смотрите в мане), так что это на мой взгляд самый лучший вариант для использования в своих скриптах.

Минусы

??

Плюсы

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

Основные функции сортировки массива в 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

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

• 1197

• 68

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

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