Массивы

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

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

Ассоциативные массивы и массивы с числовыми индексами

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

Будьте внимательны: большинство людей начинают счет не с 0, а с 1. По рассеянности вы легко можете обратиться к несуществующему элементу массива – это называется ошибкой завышения на единицу (off-by-one error). Чтобы получить значение индекса последнего элемента в массиве, нужно вычесть из длины массива единицу. Типичный симптом того, что по ошибке вы начали обходить массив с индекса 1, а не 0 – обнаружение того, что при попытке обратиться к последнему элементу массива такого элемента просто не находится.

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

Создание массива

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

Непосредственное присваивание

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

// Создание и наполнение числового массива
$array[0] = 1;
$array[1] = 2;
$array[3] = 'Hello, world!';

// Создание и наполнение ассоциативного массива
$arr['fruit'] = 'яблоко';
$arr['color'] = 'зеленый';
$arr['count'] = 40;

// Ассоциативные и числовые массивы можно перемешивать, это не
// вызовет ошибки (но лучше такой подход не использовать)
$arr[4] = 'груша';
$array['ten'] = 10;

Чтобы создать массив, нужно определить значения его элементов и индексов. В качестве элементов массива могут использоваться любые значения, включая строки, числа и даже другие массивы. Поле ключа должно быть скаляром. Скалярные значения – это такие значения элементарного типа, как числа или строки, включая значения TRUE и FALSE, но не данные, которые могут иметь несколько составных значений, например объекты. Кроме того, в поле ключа массива для каждого элемента должно быть уникальное значение, иначе вы можете записать новый элемент поверх уже имеющегося, с тем же ключом. Если вы попытаетесь назначить новому элементу ключ, который уже определен для другого элемента, новое значение просто заменит старое.

Конструкция array()

Еще один способ создания массива состоит в использовании конструкции array(), которая создает новый массив на основании спецификации элементов и ассоциированных с ними ключей. В своей простейшей версии конструкция array() вызывается без параметров, что приводит к созданию нового пустого массива. Более сложной по сравнению с простейшей является версия, в которой конструкция array() принимает разделенный запятыми список элементов, подлежащих сохранению, без какого-либо указания ключей. Результатом становится то, что элементы сохраняются в массиве в заданном порядке и им присваиваются целочисленные ключи, начинающиеся с нуля. Например, выполнение оператора:

// Создание числового массива с помощью конструкции array()
$fruit = array('Апельсин', 'Яблоко', 'Банан', 'Груша');

приводит к тому, что имя переменной $fruit становится именем массива с четырьмя строковыми элементами ('Апельсин', 'Яблоко', 'Банан', 'Груша'), имеющими соответственно индексы 0,1, 2 и 3. Кроме того массив запоминает порядок, в котором осуществлялась запись в него элементов. Таким образом, приведенная выше операция присваивания значения переменной $fruit влечет за собой получение точно такого же результата, как и следующие операции:

$fruit[0] = 'Апельсин';
$fruit[1] = 'Яблоко';
$fruit[2] = 'Банан';
$fruit[3] = 'Груша';

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

$fruit[] = 'Апельсин';
$fruit[] = 'Яблоко';
$fruit[] = 'Банан';
$fruit[] = 'Груша';

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

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

В простом примере конструкции array(), приведенном в предыдущем примере, присваивание индексов элементам осуществлялось автоматически, но такие индексы являются исключительно целочисленными и отсчитываются в сторону увеличения от нуля, поэтому указанный подход не предоставляет широкого выбора. Но, как оказалось, конструкция array() обеспечивает возможность использовать специальную синтаксическую структуру для создания ассоциативных массивов. Вместо перечисления значений элементов, разделенных запятыми, в этой конструкции можно задать разделенные запятыми пары "ключ-значение", в которых ключ и значение разделены с помощью специального символа =>. Рассмотрим следующий оператор:

$fruit = array(0 => 'Апельсин', 1 => 'Яблоко', 
                  2 => 'Банан', 3 => 'Груша');

Выполнение этого оператора приведет к получению такого же результата, как и выполнение приведенных выше вариантов операций присваивания — каждая строка будет сохранена в массиве последовательно и этим строковым значениям будут по порядку присвоены индексы 0, 1, 2, 3. Однако вместо этого можно использовать точно такую же синтаксическую структуру для сохранения тех же элементов, но со строковыми индексами:

$fruit = array('orange' => 'Апельсин',
			   'red' => 'Яблоко',
			   'yellow' => 'Банан',
			   'green' => 'Груша');

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

// Этот элемент должен иметь значение 'Банан'
$fruit['yellow'];

Функции, возвращающие массивы

Последний способ создания массива в сценарии состоит в вызове функции, которая возвращает массив. Это может быть функция, определяемая пользователем, или встроенная функция, создающая массив с помощью каких-то внутренних методов PHP.

Например, в виде динамически создаваемых массивов возвращают свои результаты многие функции, обеспечивающие взаимодействие с базой данных. Предусмотрены и другие функции, предназначенные исключительно для создания массивов, удобных для использования в качестве заготовок в применяемых впоследствии функциях манипулирования массивами. Одной из таких функций является range(), которая принимает два целых числа в качестве параметров и возвращает массив, заполненный всеми целыми числами (включительно), лежащими на числовой оси между этими параметрами. Иными словами, оператор $my_array = range(1,5); эквивалентен оператору $my_array = array(1, 2, 3, 4, 5);.

Выборка значений

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

Выборка с помощью индекса или ключа

Самый непосредственный способ выборки значения элемента массива состоит в использовании индекса элемента. Например, если по индексу 5 в массив $my_array было записано некоторое значение, то вычисление выражения $my_array[5] должно привести к выборке хранимого значения.

Конструкция list()

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

$fruit = array('Апельсин', 'Яблоко', 'Банан', 'Груша');

list($fruit1, $fruit2) = $fruit;

В результате выполнения этих операторов происходит присваивание строки 'Апельсин' переменной $fruit1 и строки 'Яблоко' переменной $fruit2 (строка 'Банан' не присваивается какой-либо переменной, поскольку не было задано достаточное количество переменных). Переменным в конструкции list() значения элементов массива присваиваются в том порядке, в каком эти элементы были первоначально сохранены в массиве. Обратите внимание на то, насколько необычной является синтаксическая структура используемой операции присваивания — конструкция list() находится слева от знака операции присваивания (=), тогда как в этой позиции обычно можно встретить только имена переменных.

В определенном смысле конструкция list() является противоположной, или обратной, конструкции array(), поскольку array() упаковывает свои параметры в массив, а конструкция list() распаковывает массив, присваивая значения отдельным переменным.

Многомерные массивы

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

// Два простых одномерных массива
$counts = array(1, 2, 10, 14, -5);
$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша');

// Два двухмерных массива
$counts2[0][0] = 1;
$counts2[0][1] = 2;
$counts2[0][2] = 3;
$counts2[1][0] = 4;
$counts2[1][1] = 5;
$counts2[1][2] = 6;
$counts2[2][0] = 7;
$counts2[2][1] = 8;
$counts2[2][2] = 9;

$nature = array('fruit' =>
					array('orange' => 'Апельсин',
						  'red' => 'Яблоко',
						  'yellow' => 'Банан',
						  'green' => 'Груша'),
				 'flower' =>
				 	array('red' => 'Астра',
						  'white' => 'Роза',
						  'pink' => 'Пион',
						  'blue' => 'Колокольчик'));

// Вывести на экран значение белого цветка
echo $nature['flower']['white'];

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

Получение сведений о массивах

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

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

echo count($nature);   // 2
echo count($nature['flower']);   // 4

Удаление элементов из массивов

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

$my_array[0] = 'значение';
$my_array[1] = 'это значение нужно удалить';
$my_array[2] = 'еще одно значение';

unset($my_array[1]);

После завершения выполнения кода эта переменная $my_array будет содержать два значения ('значение', 'еще одно значение'), ассоциированные с двумя индексами (соответственно 0 и 2).

Следует отметить, что операция удаления элемента не аналогична операции присваивания элементу пустого значения. Например, если вместо вызова функции unset() был применен следующий оператор:

$my_array[1] = '';

то в конечном итоге массив содержал бы три хранимых значения ('значение', '', 'еще одно значение'), ассоциированных с тремя индексами (соответственно 0, 1 и 2).

Итерация массивов

Массивы PHP не только сохраняют значения, ассоциированные с соответствующими ключами, но и по умолчанию образуют упорядоченный список пар "ключ-значение", хранящийся в том порядке, в котором происходила запись этих пар в массив. Такая структура массива была принята исходя из тех соображений, чтобы массив можно было использовать для обеспечения итерации по всему содержимому массива. (Следует отметить, что эту задачу трудно выполнить, просто сформировав цикл, который наращивает значение индекса, поскольку индексы массивов PHP не обязательно должны быть числовыми.)

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

В каждом массиве некоторая определенная хранимая пара "ключ-значение" запоминается как текущая, и определенная часть действий итеративных функций массива основана на принципе передвижения этого маркера текущей пары по внутреннему списку ключей и значений. Мы будем называть этот маркер текущим указателем, но следует учитывать, что язык PHP не поддерживает полноценные указатели в том смысле, в каком это понятие трактуют программисты, работающие на языках C/C++/C#. К тому же термин текущий указатель, применяемый в указанном смысле, будет появляться только в контексте описания средств итерации по элементам массива.

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

Цикл foreach

Для организации циклической обработки массива можно использовать цикл foreach. Безусловно, создается впечатление, что эта конструкция унаследована от конструкции foreach языка Perl, но имеет немного странную синтаксическую структуру (которая, тем не менее, не совпадает со странной синтаксической структурой аналогичной конструкции из языка Perl). Синтаксическая структура конструкции foreach в языке PHP имеет две разновидности, и решение о том, какая из них должна использоваться в программе, зависит от того, требуется ли выборка и ключей, и значений массива или только значений:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 
				'yellow' => 'Банан', 'green' => 'Груша');

// Использование цикла foreach для извлечения только значений
foreach ($fruits as $value)
{
	echo $value.'<br>';
}
echo '<br>';

// Использование цикла foreach для извлечения значений и ключей
foreach ($fruits as $key => $f)
{
	echo '<b>'.$key.'</b> => '.$f.'<br>';
}

Итеративные функции

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

Функция current() возвращает сохраненное значение, на которое в настоящее время направлен указатель. Во вновь созданном массиве с элементами текущий указатель всегда направлен на первый элемент. Функция next() вначале продвигает указатель, а затем возвращает текущее значение, на которое направлен указатель. Если функция next() вызывается в тех условиях, когда текущий указатель уже направлен на последнее хранимое значение и поэтому должен выйти за конец массива, функция возвращает ложное значение.

В качестве примера рассмотрим вывод содержимого массива с помощью итеративных функций current() и next(), как показано ниже:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 
				'yellow' => 'Банан', 'green' => 'Груша');

function print_all_next($array)
{
	$current = current($array);
	if ($current)
		echo $current.'<br>';
	else
		echo 'Указатель не найден';
		
	while ($current = next($array))
		echo $current.'<br>';
	
	echo '<br>';
}

print_all_next($fruits);
print_all_next($fruits);	// Инициируем повторный вызов, 
							// чтобы посмотреть что произойдет

После выполнения данного кода вывода массива снова будут получены такие данные:

В связи с получением приведенных здесь результатов возникает вопрос: как получилось, что второй вызов функции print_all_next() привел к получению прежних результатов? Как удалось вернуть текущий указатель в начало, чтобы снова повторить все операции во второй раз? Ответ обусловлен тем фактом, что вызовы функций PHP представляют собой вызовы по значению. Таким образом, в функцию передаются копии параметров и функция оперирует этими копиями, а не самими параметрами. Поэтому в обоих этих вызовах функции передается немодифицированная копия массива, используемого в качестве параметра, а сам массив не затрагивается в результате вызова функции next().

Предыдущий пример показывает, как можно написать собственную функцию, являющуюся частичным аналогом цикла foreach. Но цикл foreach позволяет отображать также ключи. Давайте модифицируем наш пример, добавив к выводу на экран ключи с помощью функции key():

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 
				'yellow' => 'Банан', 'green' => 'Груша');

function print_all_next($array)
{
	$current = current($array);
	$current_key = key($array);
	
	if ($current)
		echo "<b>$current_key</b> => ".$current.'<br>';
	else
		echo 'Указатель не найден';
		
	while ($current = next($array))
	{
		$current_key = key($array);
		echo "<b>$current_key</b> => ".$current.'<br>';
	}
	
	echo '<br>';
}

print_all_next($fruits);

Средства преобразования массивов

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

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

Давайте на примерах рассмотрим эти функции более подробно.

Выборка ключей и значений

Функция array_keys() возвращает ключи массива, заданного в качестве входного параметра, в форме нового массива, ключами которого являются хранимые значения. Ключами нового массива становятся обычные индексы в виде автоматически наращиваемых целых чисел, которые начинаются с нуля. Функция array_values() выполняет точно такое же действие, если не считать того, что хранимыми значениями становятся значения из первоначального массива:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 
				'yellow' => 'Банан', 'green' => 'Груша');

echo 'Массив ключей: <br>';
foreach (array_keys($fruits) as $key => $value)
{
	echo '<b>'.$key.'</b> => '.$value.'<br>';
}

echo '<br>Массив значений: <br>';
foreach (array_values($fruits) as $key => $value)
{
	echo '<b>'.$key.'</b> => '.$value.'<br>';
}

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

Немного более полезную операцию (способную оказать большую помощь при решении задачи упорядочения) можно выполнить с помощью функции array_count_values(). Эта функция принимает в качестве параметра массив и возвращает новый массив, в котором старые значения преобразованы в новые ключи, а новые значения показывают, сколько раз каждое старое значение встречается в первоначальном массиве.

Зеркальное отображение, обращение и случайное перемешивание

Более редко применяемой функцией по сравнению с описанными выше является функция array_flip(), которая преобразует ключи массива в значения, и наоборот. Следует отметить, что гарантируется уникальность ключей массива, а на значения массива такая гарантия не распространяется. В связи с этим любые дублирующиеся значения в первоначальном массиве преобразуются в один и тот же ключ в новом массиве. Поэтому сохраняется только один из первоначальных ключей, который становится соответствующим новым значением.

Операция обращения массива является менее сложной: функция array_reverse() возвращает новый массив, в котором пары "ключ-значение" находятся в обратном порядке.

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

В следующем примере показано применение этих функций:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 
				'yellow' => 'Банан', 'green' => 'Груша');

// array_flip()
echo 'Исходный массив: <br>';
foreach ($fruits as $key => $value)
{
	echo '<b>'.$key.'</b> => '.$value.'<br>';
}

echo '<br>Массив после использования функции <b>array_flip()</b>: <br>';
$fruits = array_flip($fruits);
foreach ($fruits as $key => $value)
{
	echo '<b>'.$key.'</b> => '.$value.'<br>';
}

// array_reverse()
echo '<br>Исходный массив: <br>';
$array = range(1,5);
foreach ($array as $value)
{
	echo $value.' ';
}

echo '<br>Массив после использования функции <b>array_reverse()</b>: <br>';
$array = array_reverse($array);
foreach ($array as $value)
{
	echo $value.' ';
}

// shuffle()
echo '<br><br>Исходный массив: <br>';
$array = range(1,10);
foreach ($array as $value)
{
	echo $value.' ';
}

echo '<br>Массив после использования функции <b>shuffle()</b>: <br>';

srand((double)microtime()*1000000);  // Применяется для выработки случайных чисел
shuffle($array);

foreach ($array as $value)
{
	echo $value.' ';
}

В отличие от многих других функций работы с массивами, приведенных в данной статье, функция shuffle() является деструктивной. Это означает, что она применяется непосредственно к массиву, заданному в качестве параметра, и изменяет его, а не возвращает вновь созданный массив. (Функции, возвращающие новый объект и не изменяющие свои параметры, принято называть конструктивными, или недеструктивными.) Кроме всего прочего, это означает, что правильный способ вызова рассматриваемой функции случайного перемешивания элементов не является таковым:

$array = shuffle($array); // Неправильная конструкция!

Слияние, дополнение, вырезка и вставка элементов массивов

Если требуется объединить два массива, например для получения более полного списка, то можно воспользоваться функцией array_merge(). Эта функция принимает в качестве параметров два или несколько массивов и возвращает новый массив с перенумерованными ключами, в котором второй массив присоединен к концу первого. Например:

$new_array = array_merge(range(0,2), array(5,6,7), array(10,11));  // [0,1,2,5,6,7,10,11]

Функция array_pad() используется для создания определенного количества ведущих или заключительных пар "ключ-значение" в целях увеличения размера массива. Эта функция принимает в качестве первого параметра входной массив. Вслед за этим параметром должно быть указано количество элементов, на которое увеличивается массив, а затем — значение, присваиваемое дополнительным элементам. Если в качестве второго параметра задано положительное целое число, то массив дополняется в конце, а в случае указания отрицательного целого числа массив дополняется в начале. Если второй параметр меньше размера массива, дополнение не выполняется:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 
				'yellow' => 'Банан', 'green' => 'Груша');

foreach (array_pad($fruits, 10, 'empty') as $key => $value)
{
	echo '<b>'.$key.'</b> => '.$value.'<br>';
}

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

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

Стеки и очереди

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

Стек представляет собой контейнер, который сохраняет значения и поддерживает операции доступа к этим значениям по принципу обратной очереди (last-in-first-out — LIFO). Это означает, что стек поддерживает порядок сохраняемых в нем значений и предоставляет единственный способ выборки сохраненного в нем значения — извлечение (и удаление) последнего по времени сохраненного значения:

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

Очередь аналогична стеку, но действует по принципу последовательной очереди (first-in-first-out — FIFO). Обычно для описания такой очереди применяется аналогия с цепочкой людей, ожидающих обслуживания, которую в Англии обозначают queue, а в США — line. Общее правило обслуживания людей, стоящих в очереди, состоит в том, что следующим должен обслуживаться тот, кто простоял в очереди дольше всех:

Для работы со стеками применяются функции array_push() и array_pop(). Функция array_push() принимает в качестве параметра исходный массив, за которым может быть указано любое количество элементов, заталкиваемых в стек. Элементы вставляются в конце массива, в последовательности слева направо. Функция array_pop() принимает в качестве параметра такой массив и удаляет элемент, находящийся в конце массива, возвращая этот элемент.

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

Наконец, в языке PHP предусмотрено множество функций для сортировки массивов. Как было указано выше, иногда бывает сложно учесть различие между ситуацией, в которой применяются ассоциации "ключ-значение" в массиве, и ситуацией, в которой числовые ключи рассматриваются в качестве информации об упорядочении, подлежащей изменению после изменения порядка элементов. К счастью, в языке PHP предусмотрены варианты функций сортировки, в которых учитываются особенности ситуаций каждого из этих типов. Кроме того, язык PHP позволяет сортировать элементы по возрастанию или по убыванию, а также использовать функции упорядочения, предоставленные пользователем. Имена функций сортировки являются сокращенными, но содержат специальные буквенные обозначения (кроме части имени со словом sort), которые позволяют определить назначение функции. Ниже приведено краткое описание указанных буквенных обозначений:

• Начальная буква "a" означает, что функция выполняет сортировку по значениям, но сохраняет ассоциации между парами "ключ-значение" в том виде, в котором они существуют.

• Начальная буква "k" означает, что сортировка осуществляется по ключам, но ассоциации "ключ-значение" сохраняются.

• Отсутствие начальной буквы "a" или "k" означает, что сортировка выполняется по значениям, но ассоциации "ключ-значение" не сохраняются. В частности, числовые ключи перенумеровываются, отражая новое упорядочение.

• Буква "r" перед словом sort означает, что применяется обратный порядок сортировки.

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

Эти простые правила помогут не запутаться в следующих функциях сортировки:

Ниже показан простой пример сортировки в алфавитном порядке:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 
				'yellow' => 'Банан', 'green' => 'Груша');

sort($fruits);

foreach ($fruits as $key => $value)
{
	echo '<b>'.$key.'</b> => '.$value.'<br>';
}

Как видите функция sort() не только отсортировала значения, но и заменила текстовые ключи на числовые индексы. Если такое поведение нежелательно, то следует использовать функцию asort().