Массив представляет собой совокупность объектов, имеющих одинаковые размер и тип. Каждый объект в массиве называется элементом массива. Создать новый массив в PHP несложно. При объявлении индексируемого массива после имени переменной ставится пара квадратных скобок ():

$languages = "Spanish";

// $languages = "Spanish"

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

$languages = "English"; // $1anguages[l] = "English";

$languagest ] = "Gaelic"; // $languages = "Gaelic";

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

$languages = "Italian";

$languages = "French";

Ассоциативные массивы создаются аналогичным образом:

$languages["Spain"] = "Spanish";

$languages["France"] = "French";

При создании массивов используются три стандартные языковые конструкции:

• аrrау();
• list();
• range().

Хотя все три случая приводят к одному результату -- созданию массива, в некоторых случаях одна конструкция может оказаться предпочтительнее других. Далее приведены описания и примеры использования каждой конструкции.

Функция array() получает ноль или более элементов и возвращает массив, состоящий из указанных элементов. Ее синтаксис:

array array ([элемент1, элемент2...])

Вероятно, array() является всего лишь более наглядной записью для создания массива, используемой для удобства программиста. Ниже показан пример использования array() для создания индексируемого массива:

$languages = array ("English". "Gaelic". "Spanish");

// $languages = "English". $languages = "Gaelic",

// $languages = "Spanish"

А вот как array() используется при создании ассоциативных массивов:

$languages = array("Spain" => "Spanish",

"Ireland" => "Gaelic".

"United States" => "English");

// $languages["Spain"] = "Spanish"

// $languages["Ireland"] = "Gaelic"

// $languages["United States"] = "English"

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

Конструкция list() похожа на аrrау(), однако ее главная задача -- одновременное присваивание значений, извлеченных из массива, сразу нескольким переменным. Синтаксис команды list():

void list (переменная1 [. переменная2 , ...])

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

профессия и любимый цвет); компоненты записи разделяются вертикальной чертой (|). Типичная строка выглядит так:

Nino Sanzi|Professional Golfer|green

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

while ($line = fgets ($user_file. 4096)) :

// Разделить строку функцией split().

// Компоненты присваиваются переменным Sname. $occupation и Scolor.

list ($name, $occupation, $color) = split("|", $line);

// Отформатировать и вывести данные

print "Name: Sname
";

print "Occupation: Soccupation
";

print "Favorite color: Scolor
";

Каждая строка файла читается, форматируется и выводится в следующем виде:

Name: Nino Sanzi

Occupation: Professional Golfer

Favorite color: green

В приведенном примере применение list() зависит от разделения строки на элементы функцией split(). Элементы, полученные в результате деления, присваиваются, соответственно, переменным $name, $occupation и $color. Дальше все сводится к форматированию данных для вывода в конкретном браузере. Удобные средства лексического анализа текстовых файлов являются одной из сильных сторон PHP. Эта тема подробно рассматривается в главах 7 и 8.

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

array range (int нижняя_граница, int верхняяграница)

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

$lottery = range(0,9);

// $lottery = array(0,1,2,3,4,5,6,7,8,9)

Как видно из приведенного фрагмента, в параметрах range() был указан интервал от 0 до 9 и массив $lottery был заполнен целыми числами из этого интервала.

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

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

$chessboard = "King"; // Двухмерный массив

$capitals["USA"] ["Ohio"] = "Columbus": // Двухмерный массив

$streets["USA"]["Ohio"]["Columbus"] = "Harrison"; // Трехмерный массив

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

$desserts = аrrау(

"Fruit Cup" => array (

"calories" => "low",

"served" -> "cold",

"preparation" => "10 minutes"

"Brownies" => array (

"calories" -> "high",

"served" => "piping hot",

"preparation" => "45 minutes"

После создания массива к его элементам можно обращаться по соответствующим ключам:

$desserts["Fruit Cup"]["preparation"] // возвращает "10 minutes"

$desserts["Brownies"]["calories"] // возвращает "high"

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

$desserts["Cake"]["calories"] = "too many";

// Присваивает свойству "calories" объекта "Cake" значение "too many"

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

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

print "Brownies are good, but the calories content is ".

$desserts["Brownies"]["calories"];

print "Brownies are good, but the calories content is

{$desserts}";

Обратите внимание на отсутствие кавычек вокруг ключей. Также следует помнить, что между фигурными скобками и ссылкой не должно быть лишних пробелов. Если хотя бы одно из этих условий не выполняется, произойдет ошибка. Впрочем, годятся оба способа. Я рекомендую выбрать один формат и придерживаться его, чтобы ваши программы выглядели более последовательно. Если не использовать какой-либо из этих способов форматирования, ссылки на многомерные массивы будут интерпретироваться буквально, что наверняка приведет к непредвиденным результатам.

Поиск элементов массива

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

Функция i n_array () проверяет, присутствует ли в массиве заданный элемент. Если поиск окажется удачным, функция возвращает TRUE, в противном случае возвращается FALSE. Синтаксис функции in_array():

bool in_array(mixed элемент, array массив)

Эта функция особенно удобна тем, что вам не приходится в цикле перебирать весь массив в поисках нужного элемента. В следующем примере функция in_array() ищет элемент "Russian" в массиве $languages:

$languages = array("English", "Gaelic", "Spanish"):

$exists = in_array("Russian", $languages); // $exists присваивается FALSE

$exists = in_array("English", $languages): // $exists присваивается TRUE

Функция in_array() часто встречается в управляющих конструкциях, когда ее возвращаемое значение (TRUE/FALSE) используется для выбора одного из двух вариантов продолжения. В следующем примере функция in_array() используется для выбора одного из двух вариантов в условной команде if:

// Ввод данных пользователем

$language = "French"; $email = "[email protected]";

// Если язык присутствует в массиве

if (in_array($language. $languages)) :

// Подписать пользователя на бюллетень.

// Обратите внимание: в PHP нет стандартной функции с именем

// subscribe_user(). В данном примере эта функция просто имитирует

// процесс подписки.

subscribe_user($email, $language);

print "You are now subscribed to the $language edition of the newsletter.";

// Язык отсутствует в массиве

print "We"re sorry, but we don"t yet offer a $language edition of the newsletter".

Что происходит в этом примере? Допустим, переменные $language и $email содержат данные, введенные пользователем. Вы хотите убедиться в том, что указанный язык поддерживается вашей системой, и используете для этой цели функцию in_array(). Если название языка присутствует в массиве, пользователь подписывается на бюллетень и получает соответствующее сообщение. В противном случае программа сообщает, что на указанном языке бюллетень не распространяется. Конечно, в настоящей программе пользователь не должен гадать, какие языки поддерживаются вашей программой. Задача решается при помощи раскрывающегося списка -- эта тема подробно рассматривается в главе 10. Здесь этот пример всего лишь демонстрирует возможности работы с массивами.

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

array array_keys (array массив [, mixed искомый_элемент])

Рассмотрим пример использования функции array_keys() для получения ключа заданного элемента:

$great_wines = array ("Australia" => "Clarendon Hills 96",

"France" => "Comte George de Vogue 97",

"Austria" => "Feiler Artinger 97");

$great_labels = array_keys($great_wines);

// $great_labels = array("Australia", "France", "Austria");

$great_labels = array_keys($great_wines, "Clarendon Hills 96");

// $great_labels = array("Australia");

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

Функция array_values() возвращает массив, состоящий из всех значений исходного массива, переданного в качестве параметра. Синтаксис функции array_values():

array array_values(array массив)

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

// $great_wines = array ("Australia" => "Clarendon Hills 96",

// "France" => "Comte George de Vogue 97",

// "Austria" => "Feiler Artinger 97");

$great_labels = array_values($great_wines);

// $great_labels = аrrау("Clarendon Hills 96",

// "Comte George de Vogue 97",

// "Feiler Artinger 97");

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

Добавление и удаление элементов

К счастью, в PHP при создании массива не нужно указывать максимальное количество элементов. Это увеличивает свободу действий при операциях с массивами, поскольку вам не приходится беспокоиться о случайном выходе за границы массива, если количество элементов превысит ожидаемый порог. В PHP существует несколько функций для увеличения размеров массива. Некоторые из них были созданы для удобства программистов, привыкших работать с различными типами очередей и стеков (FIFO, FILO и т. д.), что отражается в названиях функций (push, pop, shift и unshift). Но даже если вы не знаете, что такое «очередь» или «стек», не огорчайтесь -- в этих функциях нет ничего сложного.

Очередью (queue) называется структура данных, из которой элементы извлекаются в порядке поступления. Стеком (stack) называется структура данных, из которой элементы извлекаются в порядке, обратном порядку их поступления.

Функция array_push() присоединяет (то есть дописывает в конец массива) один или несколько новых элементов. Синтаксис функции array_push():

int array_push(array массив, mixed элемент [, ...])

Длина массива возрастает прямо пропорционально количеству его элементов. Это продемонстрировано в следующем примере:

$languages = array("Spanish", "English", "French");

array_push($languages, "Russian", "German", "Gaelic");

// $languages = array("Spanish", "English", "French",

// "Russian", "German", "Gaelic")

У функции array_push(), как и у многих стандартных функций PHP, существует «двойник» -- функция аrrау_рор(), предназначенная для извлечения элементов из массива. Главное различие между этими функциями заключается в том, что array_push() может добавлять несколько элементов одновременно, а аrrау_рор() удаляет элементы только по одному.

аrrау_рор()

Результат работы функции аrrау_рор() прямо противоположен array_push() -- эта функция извлекает (то есть удаляет) последний элемент из массива. Извлеченный элемент возвращается функцией. Синтаксис функции аrrау_рор():

аrrау_рор(аrrау массив)

При каждом выполнении аrrау_рор() размер массива уменьшается на 1. Рассмотрим пример:

$languages = array("Spanish", "English", "French",

"Russian", "German", "Gaelic");

$a_language = array_pop($languages): // $a_language = "Gaelic"

$a_language = array_pop($languages): // $a_language = "German"

// $languages = array ("Spanish", "English", "French", "Russian");

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

Функция array_shift() аналогична аrrау_рор() с одним отличием: элемент удаляется из начала (левого края) массива. Все остальные элементы массива сдвигаются на одну позицию к началу массива. У функции array_shift() такой же синтаксис, как и у аггау_рор():

array_shift(array массив)

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

$languages = array("Spanish", "English", "French", "Russian");

$a_language = array_shift($languages); // $a_language = "Spanish";

// $languages = array("English", "French", "Russian");

Функция array_unshift() дополняет array_shift() -- новый элемент вставляется в начало массива, а остальные элементы сдвигаются на одну позицию вправо. Синтаксис команды array_unshift():

1nt array_unshift(array массив, mixed переменная1 [....переменная2])

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

$ languages = array("French", "Italian", "Spanish");

array_unshift($languages, "Russian", "Swahili", "Chinese");

// $languages = array("Russian", "Swahili", "Chinese",

// "French", "Italian", "Spanish");

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

array arrap_pad(array массив, int размер, mixed значение):

Параметр размер определяет новую длину массива. Параметр значение задает стандартное значение, присваиваемое элементам во всех новых позициях массива. При использовании array_pad() необходимо учитывать некоторые обстоятельства:

Если размер положителен, массив дополняется справа, а если отрицателен -- слева.

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

Абсолютным значением (модулем) целого числа называется его значение без знака. Например, абсолютное значение чисел 5 и -5 равно 5.

Пример дополнения массива с конца:

$weights = array_pad($weights. 10, 100);

// Результат: $weights = array(1, 3, 5, 10, 15, 25, 50, 100, 100, 100);

Пример дополнения массива с начала:

$weights = array(1, 3, 5, 10, 15, 25, 50);

$weights = array_pad($weights, -10, 100);

// Результат: $weights = array(100, 100, 100, 1, 3, 5, 10, 15, 25, 50);

Неправильная попытка дополнения массива:

$weights = array(1, 3, 5, 10, 15, 25, 50);

$weights = array_pad($weigtits, 3, 100);

// Массив $weights не изменяется:

// $weights = array(1, 3, 5, 10, 15, 25, 50);

Перебор элементов

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

Функция reset() переводит внутренний указатель текущей позиции в массиве к первому элементу. Кроме того, она возвращает значение первого элемента. Синтаксис функции reset():

mixed reset (array массив)

Рассмотрим следующий массив:

$fruits = array("apple", "orange", "banana");

Допустим, указатель текущей позиции в этом массиве установлен на элемент "orange". Команда:

$a_fruit = reset($fruits);

вернет указатель в начало массива, то есть на элемент "apple", и вернет это значение, если результат вызова reset() используется в программе. Возможен и упрощенный вариант вызова:

В этом случае указатель переходит к первому элементу массива, а возвращаемое значение не используется.

Функция each() при каждом вызове выполняет две операции: она возвращает пару «ключ/значение», на которую ссылается указатель текущей позиции, и перемещает указатель к следующему элементу. Синтаксис функции each():

array each (array массив)

Для удобства each () возвращает ключ и значение в виде массива из четырех элементов; ключами этого массива являются 0, 1, value и key. Возвращаемый ключ ассоциируется с ключами 0 и key, а возвращаемое значение -- с ключами 1 и value.

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

// Объявить массив из пяти элементов

$spices = array("parsley", "sage", "rosemary", "thyme", "pepper");

// Установить указатель на первый элемент массива

// Создать массив $a_sp1ce. состоящий из четырех элементов

$a_spice = each($spices);

В результате выполнения приведенного фрагмента массив $a_spice будет содержать следующие пары «ключ/значение»:

• 0 => 0;
• 1 => "parsley";
• key => 0;
• value => "parsley".

После этого строку "parsley" можно вывести любой из следующих команд:

print $a_spice: print $a_spice["value"];

Функция each() обычно используется в сочетании с list() в циклических конструкциях для перебора всех или некоторых элементов массива. При каждой итерации each() возвращает либо следующую пару «ключ/значение», либо логическую ложь при достижении последнего элемента массива. Вернемся к массиву $spices; чтобы вывести все элементы на экран, можно воспользоваться следующим сценарием:

// Сбросить указатель текущей позиции

// Перебрать пары "ключ/значение", ограничиваясь выводом значения

while (list ($key, $val) = each ($spices)) :

print "$val
"

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

Листинг 5.1. Построение таблицы HTML по содержимому массива

// Объявить ассоциативный массив стран и языков $languages = array ("Country" => "Language",

"Spain" => "Spanish",

"USA" => "English",

"France" => "French",

"Russia" => "Russian");

// Начать новую таблицу

print "

";

// Переместить указатель к позиции первого элемента

$hdl = key ($languages);

Shd2 = $languages[$hd1];

// Вывести первый ключ и элемент в виде заголовков таблицы

print "

";

next($languages);

// Выводить строки таблицы с ключами и элементами массива

while (list ($ctry,$lang) = each ($languages)) :

print "

";

// Завершить таблицу print "

$hd1	$hd2
Sctry	$lang

";

В результате выполнения этого кода будет построена следующая таблица HTML.

Country	Language
Spain	Spanish
USA	English
France	French
Russia	Russian

Этот пример дает представление о самой сильной стороне PHP -- возможности объединения динамического кода с HTML для получения наглядного, отформатированного представления прочитанных данных.

Функция end() перемещает указатель к позиции последнего элемента массива. Синтаксис функции end():

end (array массив)

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

указатель выйдет за пределы массива, next () возвращает ложное значение. Синтаксис функции next ():

mixed next (array массив)

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

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

mixed prev (array массив)

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

Функция array_walk() позволяет применить функцию к нескольким (а возможно, всем) элементам массива. Синтаксис функции array_walk():

int array_walk(array массив, string имя_функции [, mixed данные])

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

function delete_dupes($element) {

static $last=""; if ($element == $last)

unset($element); else . ""

$emails = array("[email protected]", "[email protected]", "[email protected]");

array_walk($emails,"delete_dupes");

// $emails = array("[email protected]", "[email protected]");

Функция array_reverse() позволяет легко перейти к противоположному порядку элементов, составляющих массив. Синтаксис функции array_reverse():

array array_reverse(array массив)

Рассмотрим пример использования функции array_reverse():

$us_wireproducers = array ("California", "Oregon", "New York". "Washington");

$us_wine_producers - array_reverse (Sus_wine_producers);

// $us_wine_producers = array ("Washington". "New York", "Oregon". "California");

При вызове array_reverse() для ассоциативного массива пары «ключ/значение» сохраняются, изменяется только порядок элементов массива.

Функция array_flip() меняет местами ключи и значения элементов массива. Синтаксис функции array_flip():

array array_flip(array массив)

В следующем примере функция array_flip() меняет местами все ключи и значения элементов:

$languages = array("Spain" => "Spanish", "France" => "French", "Italy" => "Italian");

$languages = array_flip($languages);

// $languages = array("Spanish" => "Spain", // "French" => "France", // "Italian" => "Italy");

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

Размер массива

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

$us_wine_producers = array ("Washington". "New York", "Oregon", "California");

for (Si = 0; Si < sizeof ($us_wine_producers); $i++) :

print "$us_wine_producers[$i]";

Поскольку массив $us_wine_producers индексируется целыми числами, мы можем воспользоваться циклом for для циклического увеличения переменной-счетчика ($i) и вывода каждого элемента в массиве.

Функция sizeof () возвращает количество элементов в массиве. Синтаксис функции sizeof ():

int sizeof (array массив)

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

$pasta = array("bowties", "angelhair", "rigatoni");

$pasta_size = sizeof($pasta);

// $pasta_size = 3

У функции sizeof () существует и другая, расширенная форма -- count () (см. ниже).

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

int count (mixed переменная)

Единственное различие между sizeof () и count() заключается в том, что в некоторых ситуациях count () возвращает дополнительную информацию:

• если переменная существует и является массивом, count () возвращает количество элементов в массиве;
• если переменная существует, но не является массивом, функция возвращает значение 1;
• если переменная не существует, возвращается значение 0.

array_count_values()

Функция array_count_values() является разновидностью sizeof () и count (). Вместо общего количества элементов она подсчитывает количество экземпляров каждого значения в массиве. Синтаксис функции array_count_values():

array array_count_values(array массив):

В возвращаемом массиве ключами будут значения исходного массива, а значениями -- их частоты:

$states = аrrау("ОН", "ОК", "СА", "РА", "ОН", "ОН", "РА", "АК");

$state_freq = array_count_values($states);

Массив $state_freq заполняется следующими ассоциативными парами «ключ/значение»:

$state_freq = аrrау("ОН" => 3, "ОК" => 1, "СА" => 1, "РА" => 2, "АК" => 1);

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

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

Таблица 5.1. Функции сортировки

	Сортировка	Обратный порядок	Сохранение пар «ключ/значение»
	Значение
	Значение
	Значение
	Значение
	Значение
	Значение

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

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

Простейшая функция sort() сортирует элементы массива по возрастанию (от меньших к большим). Синтаксис функции sort ():

void sort (array массив)

Нечисловые элементы сортируются в алфавитном порядке в соответствии с ASCII-кодами. Следующий пример демонстрирует применение функции sort() при сортировке:

// Создать массив городов.

// Отсортировать города по возрастанию

// Перебрать содержимое массива и вывести все пары "ключ/значение".

for (reset($cities); $key = key ($cities); next ($cities)):

print("cities[$key] = $cities[$key]
";

Этот фрагмент выводит следующий результат:

cities = Aprilia

cities = Nettuno

cities = Venezia

Как видите, массив $cities сортируется в алфавитном порядке. Одна из разновидностей этого способа сортировки реализована в функции asort(), описанной ниже.

Функция rsort () работает точно так же, как функция sort (), за одним исключением: элементы массива сортируются в обратном порядке. Синтаксис функции rsort ():

void rsort (array массив)

Вернемся к массиву $cities из предыдущего примера:

$cities array("Aprilia", "Nettuno", "Roma", "Venezia", "Anzio");

cities = Venezia

cities = Nettuno

cities = Aprilia

Массив $cities также сортируется, но на этот раз в порядке, обратном алфавитному. Одна из разновидностей этого способа сортировки реализована в функции arsort(), описанной ниже.

Функция asort() работает почти так же, как упоминавшаяся выше функция sort(), однако она сохраняет исходную ассоциацию индексов с элементами независимо от нового порядка элементов. Синтаксис функции asort():

void asort(array массив)

Вернемся к массиву $cities:

$cities = array("Aprilia", "Nettuno", "Roma", "Venezia", "Anzio");

В результате сортировки массива $cities функцией rsort() элементы будут расположены в следующем порядке:

cities = Aprilia

cities = Nettuno

cities = Venezia

Обратите внимание на индексы и сравните их с приведенными в описании функции sort (). Именно в этом и состоит различие между двумя функциями.

Функция arsort () представляет собой разновидность asort(), которая сохраняет исходную ассоциацию индексов, но сортирует элементы в обратном порядке. Синтаксис функции arsort():

void arsort (array массив)

Воспользуемся функцией arsort() для сортировки массива $cities:

$cities = array("Aprilia", "Nettuno", "Roma", "Venezia", "Anzio");

arsort($cities);

cities = Venezia

cities[l] = Nettuno

cities = Aprilia

Обратите внимание на индексы и сравните их с приведенными в описании функции rsort(). Именно в этом и состоит различие между двумя функциями.

Функция ksort() сортирует массив по ключам, сохраняя исходные ассоциации ключей со значениями. Синтаксис функции ksort():

void ksort (array массив)

Для примера рассмотрим массив, слегка отличающийся от исходного массива

$wine_producers = array ("America" => "Napa Valley",

"Italy" => "Tuscany",

"Australia" => "Ruthgerlen",

"France" => "Loire",

"Chile" => "Rapel Valley");

В результате сортировки массива функцией ksort() элементы будут расположены в следующем порядке:

"America" => "Napa Valley"

"Australia" => "Ruthgerlen"

"Chile" => "Rapel Valley"

"France" => "Loire"

"Italy" => "Tuscany"

Сравните с результатами сортировки $wine_producers функцией sort ():

"America" => "Napa Valley"

"Australia" => "Tuscany"

"Chile" => "Ruthgerlen"

"France" => "Loire"

"Italy" => "Rapel Valley"

Более чем сомнительный результат!

Функция krsort() почти аналогична ksort(), однако ключи сортируются в обратном порядке. Синтаксис функции krsort():

void krsort (array $массив)

Рассмотрим сортировку массива $wi reproducers функцией krsort():

$wine_producers = array ("America" => "Napa Valley",

"Italy" => "Tuscany",

"Australia" => "Ruthgerlen",

"France" => "Loire".

"Chile" => "Rapel Valley");

krsort($wine_producers);

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

"Italy" => "Tuscany"

"France" => "Loire"

"Chile" => "Rapel Valley"

"Australia" => "Ruthgerlen"

"America" => "Napa Valley"

Вероятно, описанных выше функций сортировки будет вполне достаточно для большинства случаев. Тем не менее, в некоторых ситуациях может возникнуть необходимость в определении собственных критериев сортировки. В PHP такая возможность реализована в трех стандартных функциях: usort(), uasort() и uksort().

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

void usort (array массив, string имя_функции)

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

Листинг 5.2. Определение критерия сортировки для функции usort()

$vocab = аrrау("Socrates", "Aristophanes", "Plato", "Aeschylus", "Thesmophoriazusae");

function compare_length($str1, $str2) {

// Получить длину двух следующих слов

$length1 = strlen($str1);

$length2 = strlen($str2);

// Определить, какая строка имеет меньшую длину

if ($length1 == $length2) :

elseif ($length1 < $length2) :

// Вызвать usort() с указанием функции compare_length()

// в качестве критерия сортировки

usort ($vocab, "compare_length") :

// Вывести отсортированный список

while (list ($key, $val) = each ($vocab)) {

echo "$val
";

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

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

Функции uasort() и uksort() представляют собой разновидности usort() с тем же синтаксисом. Функция uasort() сортирует массив по пользовательскому критерию с сохранением ассоциаций «ключ/значение». Функция uksort() также сортирует массив по пользовательскому критерию, однако сортируются не значения, а ключи.

Другие полезные функции

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

Функция arrayjnerge() сливает от 1 до N массивов, объединяя их в соответствии с порядком перечисления в параметрах. Синтаксис функции array_merge():

array array_merge(array массив1, array массив2, ..., array массивN]

Рассмотрим пример простого объединения массивов функцией arrayjnerge();

$arr_1 = array("strawberry", "grape", "lemon");

$arr_2 = array("banana", "cocoa", "lime");

$arr_3 = array("peach", "orange");

$arr_4 = array_merge ($arr2, $arr_1, $arr_3):

// $arr_4 = array("banana", "cocoa", "lime", "strawberry", "grape", "lemon", "peach", "orange");

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

array array_slice(array массив, int смещение [, int длина])

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

Функция array_spl ice() отдаленно напоминает array_slice() -- она заменяет часть массива, определяемую начальной позицией и необязательной длиной, элементами необязательного параметра-массива. Синтаксис функции array_splice():

array_splice(array входной_массив, int смещение, , );

Значения параметров задаются по определенным правилам:

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

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

Удаление всех элементов с пятой позиции до конца массива:

$pasta = array_splice($pasta, 5);

Удаление пятого и шестого элементов:

$pasta = array_splice($pasta. 5, 2);

Замена пятого и шестого элементов новыми значениями:

$pasta = array_splice($pasta, 5, 2, array("element1", "element2"));

Удаление всех элементов, начиная с пятого, до третьего элемента с конца массива:

$pasta = array_splice($pasta, 5, -3);

Как видно из приведенных примеров, функция array_splice() обеспечивает гибкие возможности удаления элементов из массива при минимальном объеме кода.

Функция shuffle() сортирует элементы массива в случайном порядке. Синтаксис функции shuffle():

void shuffle(array массив);

Итоги

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

• создание индексируемых и ассоциативных массивов;
• многомерные массивы;
• отображение содержимого многомерных массивов;
• поиск элементов;
• добавление и удаление элементов;
• размер массива;
• сортировка;
• другие полезные функции для работы с массивами.

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

В главе 6 мы продолжим знакомиться с базовыми средствами PHP. На этот раз речь пойдет об объектно-ориентированных возможностях языка.

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

Для начала разберём простейшую функцию, которая проверяет находится ли элемент в массиве. Функция называется in_array() :

$arr = array("Num", "Str", "Int");
if (in_array("Str", $arr)) echo "Элемент найден";
?>

Как видно из примера, данная функция проверяет наличие первого параметра среди значений массива, заданного вторым параметром. И возвращает true , если элемент найден, либо false , если не был найден. Особо продвинутые спросят: "А как же быть с такими вещами, как 0 и false , ведь это разные значения, но PHP их считает одинаковыми?". Для этого в функции in_array() существует ещё третий параметр, необязательный, который если имеет значение true , то функция сверяет не только значения, но и типы:

$arr = array(0, "Str", "Int");
if (in_array(false, $arr, true)) echo "Элемент найден";
else echo "Элемент не найден";
?>

Ещё одна очень полезная функция - array_unique() , которая принимает массив и возвращает массив без дублирующихся значений:

$arr = array(3, 5, "Val", 3, "Val", 7);
$arr_uniq = array_unique($arr);
print_r($arr_uniq);
?>

Как можно заметить, запустив скрипт, в получившемся массиве нет повторяющихся значений.

Очень важные функции - это функции извлечения части массива из исходного (аналог функции substr() , только она для строк):

$arr_2 = array_slice($arr, 3);
print_r($arr_2);
?>

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

$arr = array(12, 10, 15, "Name", "Some", -0.5);
$arr_2 = array_slice($arr, 3, 2);
print_r($arr_2);
?>

В результате, Вы увидите: "Array ( => Name => Some) ".

Теперь перейдём к последней группе функций - функциям сортировки массивов . Но для начала напоминаю разницу между списками и ассоциативными массивами. Список - это массив, у которого индексами являются числа, которые упорядочены по возрастанию, начиная с 0 . А ассоциативный массив - это массив, у которого индексами является, вообще говоря, строки, которые называются ключами. Почему это так важно при сортировке? Если Вы сортируете список, то Вам совершенно не важно, чтобы сохранялась связка: "ключ - значение ", так как индексы не служат для идентификации значения, а служат лишь для обращения к нему. А в ассоциативном массиве первостепенное значение имеет именно связка: "ключ-значение ", поэтому необходимо, чтобы при сортировке она сохранялась.

Давайте начнём с простого: сортировки списков. Для этого существуют функции sort() и rsort() . Первая функция сортирует массив по возрастанию, а вторая по убыванию:

$arr = array(15, 12, "String", 40, -2, 0, 12);
sort($arr);
print_r($arr);
echo "
";
rsort($arr);
print_r($arr);
?>

Думаю, что здесь всё понятно.

Теперь перейдём к функциям сортировки ассоциативных массивов : asort() и arsort() . Делают они всё тоже самое, но связь "ключ-значение " сохраняется:

$arr = array("Name" => "Tommy", "Age" => "34", "Level" => "15");
asort($arr);
print_r($arr);
echo "
";
arsort($arr);
print_r($arr);
?>

Теперь давайте рассмотрим функции сортировки по ключам ассоциативных массивов : ksort() и krsort() :

$arr = array("Name" => "Tommy", "Age" => "34", "Level" => "15");
ksort($arr);
print_r($arr);
echo "
";
krsort($arr);
print_r($arr);
?>

Уверен, что здесь всё прозрачно. А если что-то непонятно, то запустите скрипт, и проанализируйте результат.

И, напоследок, рассмотрим функции пользовательской сортировки : uasort() и uksort() . Обе функции принимают два параметра: массив и пользовательскую функцию сортировки . Функция сортирует массив по значениям, а функция uksort() сортирует массив по ключам. В качестве примера рассмотрим такой скрипт:

function cmp($x, $y) {
if ($x == $y) return 0;
if ($x == 1) return 1;
if ($y == 1) return -1;
if ($x > $y) return 1;
else return -1;
}
$arr = array("A" => 1, "C" => 3, "B" => 2);
uasort($arr, "cmp");
print_r($arr);
echo "
";
uksort($arr, "cmp");
print_r($arr);
?>

Как видите, мы написали свои правила сортировки, по которым число "1 " всегда больше любого другого значения. Если ни одно из чисел не является "1 ", то тогда сравниваем по обычным правилам. Таким образом, PHP сортирует наш массив по правилам, описанным в функции сравнения, название которой мы передали в функциях uasort() и uksort() .

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

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

Но прежде я расскажу вам интересную историю.

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

Я проанализировал его стратегию. Владелец магазина классифицировал все DVD-диски по разным жанрам, а также указал специальные идентификаторы / коды для разных полок. Он держит похожие фильмы на одних полках. Каждая полка маркируется по названию категории, например, Romantic Movies, Horror Movies и т. д.. Каждый DVD имеет уникальный идентификатор, который можно использовать для отслеживания.

Поэтому, если вы когда-нибудь откроете свой магазин DVD, сделайте следующее:

• Храните похожие DVD-диски на одной полке.
• Обозначьте каждую категорию по ее названию.
• Обозначьте ряды DVD.
• Назначьте идентификаторы всем DVD-дискам.

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

1. Организуйте данные в различные категории.
2. Определите ряды (строки).
3. Назначьте уникальные идентификаторы для каждого значения данных.

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

Корректное определение массива

«Набор различных переменных с одной меткой, позволяющий организовать значения для их более простой обработки».

Это мое собственное определение массивов. Хотя некоторые определяют их как «переменную, которая содержит в себе другие переменные».

Синтаксис массива:

$arrayName = array (”value1?,”value2?,”value3?);

Мы используем символ $, чтобы задать имя массива. После этого идет знак равенства, а затем ключевое слово «array» . Оно сообщает парсеру, что мы работаем с массивом.

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

Пример определения и вывода массивов в PHP:

Результат приведенной выше программы будет следующим:

Array ( => fastcreators.com => howtoforge.com => scriptsbible.com)

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

echo $Top3Sites; //fastcreators.com

Помните, что номер индекса начинается с 0, а не 1.

Каждое значение массива получает уникальный идентификатор, который известен как INDEX NUMBER.
Еще одним способом может быть определение трех переменных, присвоение им значений и использование разных операторов для их отображения. Это может быть приемлемым в случае трех значений, принимаемых аргументом. Но не подходит, когда мы имеем дело с полусотней или сотнями значений.

В приведенном выше примере мы определили массив и присвоили ему значения за один шаг. Хотя можно сделать это следующим образом:

Типы массивов

В PHP существует три типа массивов:

• Числовой: массив с числовым ключом идентификатора.
• Ассоциативный: массив, в котором каждый ключ идентификатора связан со значением.
• Многомерный: массив, состоящий из одного или нескольких массивов.

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

white => black => blue) */ ?>

В приведенном выше коде индексы для white , black и blue соответствуют 0,1,2.Поэтому мы называем такие массивы числовыми.

Ассоциативные массивы

Иногда лучше использовать индексные имена вместо чисел. Например, если вы хотите сохранить имена и номера трех учеников.

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

print_r($_POST); print_r($_GET);

и вы получите ассоциативный массив.

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

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

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

Используем пример из реальной жизни. У Дэвида есть два сына — Ричи и Мейсон. У Ричи есть две дочери — Сью и Наташа, в то время как у Мейсона три дочери — Николь, Сальма и Эмбер. Их семейное древо выглядит следующим образом:

Если мы хотим отобразить семейное древо Дэвида с помощью многомерного PHP-массива, то можем определить массив следующим образом:

$david = array (“richie”=>array (“Sue”, “Natasha”), “Mason”=>array (“Nichole”, “Salma”, “Amber”));

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

Цикл FOREACH

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

Основной синтаксис цикла FOREACH следующий:

foreach($arraynameas $temporaryVarName) { // тело цикла foreach //$temporaryVarName содержит значения массива и //при каждой следующей итерации принимает следующее доступное значение из массива }

Напишем программу, используя цикл FOREACH:

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

Результатом работы приведенного выше кода:

david kevin julie nayyar

Цикл FOREACH завершается при достижении последнего значения в массиве. В нашем случае это значение NAYYAR .

Вы можете прервать цикл в любое время с помощью оператора break . Например, когда обрабатывается имя julie , вы можете включить в приведенный выше код оператор IF, как показано ниже:

Существуют и другие удобные функции для работы с массивами.

Важные функции массива

1) Сохранение вывода функции print_r :

Ранее мы использовали print_r для отображения значений массива. Но можно добавить к print_r дополнительный аргумент и сохранить результат в переменной. Например:

Print_r будет отображать сам массив, если вы не используете TRUE — второй аргумент. Но, если указано TRUE, функция сохраняет вывод в переменной.

2) Как определить размер массива?

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

Приведенный выше кода выводит 3, потому что в массиве есть три элемента.

3) Функция var_dump :

Это функция, аналогичная print_r() . В основном она делает то же самое, но:

• выводит размеры переменных;
• не выводит не публичные данные в объектах;
• не поддерживает второй параметр для возврата вывода.

Изменив первый скрипт с использованием var_dump() , получим следующий результат:

array(3) { => string(6) “Apples” => string(7) “Oranges” => string(5) “Pears” }

Функция var_dump() отобразила, что массив имеет три значения, а также вывела длину каждой строки.

4) Функция var_export :

Существует функция var_export() , которая похожа на var_dump() и print_r() . Она отличается тем, что выводит информацию о переменной в виде результата, который может использоваться в качестве PHP- кода. Например, если бы мы использовали var_export() вместо print_r (), то получили бы следующее:

array (0 => ‘Apples’, 1 => ‘Oranges’, 2 => ‘Pears’,)

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

"Apples", 1 => "Oranges", 2 => "Pears",); ?>

5) Функция array_shift :

Она удаляет первый элемент из массива и сохраняет его в переменной.

Например, можно удалить Apples из массива, используемого в предыдущих примерах, и сохранить это значение в другой переменной:

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

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

array_unshift

array_pop

array_push

Также я хочу отметить, что цикл FOREACH — не единственный способ обработки массивов. Это можно сделать с помощью цикла FOR или функций list() и each() .

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

Это отлично подходит для числовых массивов, которые имеют целочисленные индексы, но не работает для ассоциативных массивов.

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

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

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

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

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

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

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

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

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

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

Код PHP // Создание и наполнение числового массива $array = 1; $array = 2; $array = "Hello, world!"; // Создание и наполнение ассоциативного массива $arr["fruit"] = "яблоко"; $arr["color"] = "зеленый"; $arr["count"] = 40; // Ассоциативные и числовые массивы можно перемешивать, это не // вызовет ошибки (но лучше такой подход не использовать) $arr = "груша"; $array["ten"] = 10;

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

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

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

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

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

Код PHP

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

Код PHP $fruit = "Апельсин"; $fruit = "Яблоко"; $fruit = "Банан"; $fruit = "Груша";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Код PHP $fruit = array("Апельсин", "Яблоко", "Банан", "Груша"); list($fruit1, $fruit2) = $fruit;

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

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

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

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

Код PHP // Два простых одномерных массива $counts = array(1, 2, 10, 14, -5); $fruits = array("orange" => "Апельсин", "red" => "Яблоко", "yellow" => "Банан", "green" => "Груша"); // Два двухмерных массива $counts2 = 1; $counts2 = 2; $counts2 = 3; $counts2 = 4; $counts2 = 5; $counts2 = 6; $counts2 = 7; $counts2 = 8; $counts2 = 9; $nature = array("fruit" => array("orange" => "Апельсин", "red" => "Яблоко", "yellow" => "Банан", "green" => "Груша"), "flower" => array("red" => "Астра", "white" => "Роза", "pink" => "Пион", "blue" => "Колокольчик")); // Вывести на экран значение белого цветка echo $nature["flower"]["white"]; Структура одномерных и двухмерных массивов из примера

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

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

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

Простые PHP-функции для получения сведений о массивах

Функция	Описание
is_array()	Принимает единственный параметр любого типа и возвращает истинное значение, если этот параметр является массивом; в противном случае возвращает ложное значение
count()	Принимает в качестве фактического параметра массив и возвращает количество непустых элементов в массиве
sizeof()	Идентична count()
in_array()	Принимает два фактических параметра: элемент (который может быть записан в массив в качестве значения) и массив (который может содержать элемент). Возвращает истинное значение, если элемент содержится в массиве в качестве значения; в противном случае возвращает ложное значение. (Обратите внимание на то, что эта функция не выполняет проверку на наличие в массиве определенных ключей.)
isSet($array[$key])	Принимает форму array и возвращает истинное значение, если часть, обозначенная ключом key, представляет собой допустимый ключ для массива array. (Это - специализированный способ использования более общей функции isSet(), который проверяет, является ли переменная связанной.)

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

Код PHP echo count($nature); // 2 echo count($nature["flower"]); // 4

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

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

Код PHP $my_array = "значение"; $my_array = "это значение нужно удалить"; $my_array = "еще одно значение"; unset($my_array);

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

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

Код PHP $my_array = "";

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

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

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

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

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

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

Цикл foreach

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

Код PHP $fruits = array("orange" => "Апельсин", "red" => "Яблоко", "yellow" => "Банан", "green" => "Груша"); // Использование цикла foreach для извлечения только значений foreach ($fruits as $value) { echo $value."
"; } echo "
"; // Использование цикла foreach для извлечения значений и ключей foreach ($fruits as $key => $f) { echo "".$key." => ".$f."
"; }
Использование цикла foreach

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

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

Функции обработки массивов в цикле

Функция	Параметры	Побочный эффект	Возвращаемое значение
current()		Отсутствует	Значение из пары "ключ-значение", на которую в настоящее время указывает внутренний "текущий" указатель (или ложное значение, если таковое значение отсутствует)
next()	Один фактический параметр с обозначением массива	Продвигает указатель на один элемент. Если указатель уже направлен на последний элемент, эта функция продвигает указатель "за пределы массива", поэтому последующий вызов функции current() возвратит ложное значение	Значение, на которое направлен указатель после его продвижения (или ложное значение, если текущее значение отсутствует, т.е. указатель вышел за пределы массива)
prev()	Один фактический параметр с обозначением массива	Продвигает указатель в обратном направлении на один элемент. Если указатель уже направлен на первый элемент, продвигает указатель за пределы массива, устанавливая его "перед началом массива"	Значение, на которое направлен указатель после его продвижения в обратном направлении (или ложное значение, если текущее значение отсутствует, т.е. указатель вышел за пределы массива)
reset()	Один фактический параметр с обозначением массива	Продвигает указатель в обратном направлении так, чтобы он указывал на первую пару "ключ-значение" (или занял позицию "перед началом массива", если массив пуст)	Первое значение, хранящееся в массиве, или ложное значение, в случае пустого массива
end()	Один фактический параметр с обозначением массива	Перемещает указатель в прямом направлении и устанавливает его на последнюю пару "ключ-значение"	Последнее значение, которое находится в настоящее время в списке пар "ключ-значение"
pos()	Один фактический параметр с обозначением массива	Отсутствует (Эта функция является псевдонимом функции current().)	Значение пары "ключ-значение", на которую в настоящее время направлен указатель
each()	Один фактический параметр с обозначением массива	Перемещает указатель вперед, на следующую пару "ключ-значение"	Массив, который содержит данные о ключе и значении из пары "ключ-значение", которая была текущей до перемещения указателя (или ложное значение, если текущая пара отсутствует, т.е. указатель находится за пределами массива). В возвращенном массиве ключ и значение хранятся под собственными ключами массива, соответственно 0 и 1, а также под собственными ключами массива, соответственно "key" и "value"
array_walk()	Первый параметр - фактический параметр с обозначением массива, второй параметр - имя функции с двумя (или тремя) фактическими параметрами, которая вызывается применительно к каждой паре, состоящей из ключа и значения, а третий параметр - необязательный фактический параметр	Функция array_walk() вызывает функцию, указанную в качестве второго фактического параметра, применительно к каждой паре "ключ-значение". Побочные эффекты зависят от побочных эффектов переданной функции	Возвращает значение 1

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

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

Код PHP $fruits = array("orange" => "Апельсин", "red" => "Яблоко", "yellow" => "Банан", "green" => "Груша"); function print_all_next($array) { $current = current($array); if ($current) echo $current."
"; else echo "Указатель не найден"; while ($current = next($array)) echo $current."
"; echo "
"; } print_all_next($fruits); print_all_next($fruits); // Инициируем повторный вызов, // чтобы посмотреть что произойдет

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

Использование функций current() и next()

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

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

Код PHP $fruits = array("orange" => "Апельсин", "red" => "Яблоко", "yellow" => "Банан", "green" => "Груша"); function print_all_next($array) { $current = current($array); $current_key = key($array); if ($current) echo "$current_key => ".$current."
"; else echo "Указатель не найден"; while ($current = next($array)) { $current_key = key($array); echo "$current_key => ".$current."
"; } echo "
"; } print_all_next($fruits);
Использование функции key() для получения ключей массива

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

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

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

Функции преобразования массивов

Описание	Функция
array_keys()	Принимает единственный параметр в виде массива и возвращает новый массив, значениями которого являются ключи входного массива, а ключами - последовательно возрастающие целые числа, начиная с нуля
array_values()	Принимает единственный параметр в виде массива и возвращает новый массив, значениями которого являются значения входного массива, а ключами - последовательно возрастающие целые числа, начиная с нуля
array_count_values()	Принимает единственный параметр в виде массива и возвращает новый массив, ключами которого являются значения входного массива, а значениями - данные о том, сколько раз первоначальное значение встретилось во входном массиве
array_flip()	Принимает единственный параметр в виде массива и изменяет его так, что ключами становятся значения, и наоборот
array_reverse()	Принимает единственный параметр в виде массива и изменяет внутреннее упорядочение пар "ключ-значение" на противоположное. При наличии в массиве числовых целочисленных ключей происходит также их перенумерация
shuffle()	Принимает единственный параметр в виде массива и изменяет случайным образом внутреннее упорядочение пар "ключ-значение". Происходит также перенумерация целочисленных ключей в соответствии с новым упорядочением. В процессе выполнения функции shuffle() используется генератор случайных чисел rand(), поэтому перед вызовом этой функции необходимо предварительно вызывать функцию srand() для инициализации начального значения генератора (об этом говорится в следующей статье)
array_merge()	Принимает два параметра в виде двух массивов, выполняет их слияние и возвращает новый массив, состоящий из элементов первого массива (в исходном порядке), за которыми следуют элементы второго массива. Данная функция в наибольшей степени применима для обработки массивов, представляющих собой простые связные списки, а не ассоциативных массивов, поскольку при наличии в двух ассоциативных массивах одинаковых ключей в результирующий массив попадает только по одному из значений для каждого дублирующегося ключа, а второе уничтожается. При наличии в результирующем массиве числовых целочисленных ключей происходит их перенумерация в соответствии с новым упорядочением, начиная с нуля
array_pad()	Принимает три параметра: входной массив, количество элементов в дополненном массиве и значение, которое должно содержаться в дополнительных элементах. Возвращает новый массив, который дополнен элементами по следующим правилам. Если количество элементов в дополненном массиве превышает количество элементов во входном массиве, то массив дополняется справа до указанного количества элементов по такому принципу, как если бы были подряд выполнены такие операции присваивания: $my_array = $pad_value. Если заданное значение количества элементов в дополненном массиве является отрицательным, то дополнение осуществляется так же, как и при положительном значении, за исключением того, что дополнение массива происходит слева (в начале), а не справа (в конце). Если количество элементов во входном массиве превышает количество элементов в дополненном массиве, то выполнение данной функции не оказывает никакого эффекта
array_slice()	Принимает три параметра: входной массив, целочисленное смещение и (необязательное) целочисленное значение длины. Возвращает новый массив, который представляет собой фрагмент старого - подпоследовательность его списка пар "ключ-значение". Начальный и конечный элементы фрагмента определяются смещением и длиной. Положительное значение смещения указывает, что начальным элементом является элемент, отсчитываемый с начала массива, а отрицательное значение смещения указывает на элемент, отсчитываемый с конца. Необязательный параметр с обозначением длины также может быть положительным или отрицательным. Положительное значение определяет длину фрагмента, который должен быть получен в результате выполнения функции array_slice(), а отрицательное значение - на каком элементе, отсчитываемом с конца массива, должен закончиться фрагмент. Если параметр с обозначением длины отсутствует, выделяемый фрагмент продолжается до конца массива
array_splice()	Удаляет фрагмент (который рассматривается как вырезаемая часть) массива и заменяет его содержимым другого массива. Принимает четыре параметра: входной массив, смещение, необязательное целочисленное значение длины и необязательный заменяющий массив. Возвращает новый массив, содержащий вырезаемую часть, которая была удалена из входного массива. Правила использования параметров с обозначением смещения и длины, которые определяют фрагмент, подлежащий удалению, являются такими же, как в описанной выше функции array_slice(). Если заменяющий массив не задан, то данная функция просто (деструктивно) удаляет вырезаемую часть входного массива и возвращает ее. При наличии заменяющего массива элементы этого массива вставляются вместо удаленной вырезаемой части

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

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

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

Код PHP $fruits = array("orange" => "Апельсин", "red" => "Яблоко", "yellow" => "Банан", "green" => "Груша"); echo "Массив ключей:
"; foreach (array_keys($fruits) as $key => $value) { echo "".$key." => ".$value."
"; } echo "
Массив значений:
"; foreach (array_values($fruits) as $key => $value) { echo "".$key." => ".$value."
"; }
Получение массива ключей и значений из исходного массива с помощью функций array_keys() и array_values()

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

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

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

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

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

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

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

Код PHP $fruits = array("orange" => "Апельсин", "red" => "Яблоко", "yellow" => "Банан", "green" => "Груша"); // array_flip() echo "Исходный массив:
"; foreach ($fruits as $key => $value) { echo "".$key." => ".$value."
"; } echo "
array_flip():
"; $fruits = array_flip($fruits); foreach ($fruits as $key => $value) { echo "".$key." => ".$value."
"; } // array_reverse() echo "
Исходный массив:
"; $array = range(1,5); foreach ($array as $value) { echo $value." "; } echo "
Массив после использования функции array_reverse():
"; $array = array_reverse($array); foreach ($array as $value) { echo $value." "; } // shuffle() echo "

Исходный массив:
"; $array = range(1,10); foreach ($array as $value) { echo $value." "; } echo "
Массив после использования функции shuffle():
"; srand((double)microtime()*1000000); // Применяется для выработки случайных чисел shuffle($array); foreach ($array as $value) { echo $value." "; }
Использование функций array_flip(), array_reverse(), shuffle()

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

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

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

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

Код PHP $new_array = array_merge(range(0,2), array(5,6,7), array(10,11)); //

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

Код PHP $fruits = array("orange" => "Апельсин", "red" => "Яблоко", "yellow" => "Банан", "green" => "Груша"); foreach (array_pad($fruits, 10, "empty") as $key => $value) { echo "".$key." => ".$value."
"; }
Увеличение размера массива с помощью функции array_pad()

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

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

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

Функции сортировки массивов

Функция	Описание
asort()	Принимает единственный параметр в виде массива. Сортирует пары "ключ-значение" по значениям, но сохраняет отображение "ключ-значение" неизменным. Является очень удобной в работе с ассоциативными массивами
arsort()	То же, что и asort(), но сортирует в порядке по убыванию
ksort()	Принимает единственный параметр в виде массива. Сортирует пары "ключ-значение" по ключам, но поддерживает ассоциации "ключ-значение" неизменными
krsort()	То же, что и ksort(), но сортирует в порядке по убыванию
sort()	Принимает единственный параметр в виде массива. Сортирует пары "ключ-значение" массива по их значениям. Ключи могут быть перенумерованы в соответствии с новым упорядочением значений
rsort()	То же, что и sort(), но сортирует в порядке по убыванию
uasort()	Сортирует пары "ключ-значение" по значениям с использованием функции сравнения. Аналогична asort(), за исключением того, что фактическое упорядочение значений определяется вторым параметром, который представляет собой имя определяемой пользователем функции упорядочения. Эта функция должна возвращать отрицательное число, если ее первый параметр предшествует второму (согласно результатам применения функции сравнения), положительное число, если первый параметр следует за вторым, и нуль, если сравниваемые элементы являются одинаковыми
uksort()	Сортирует пары "ключ-значение" по ключам с использованием функции сравнения. Аналогична uasort(), за исключением того, что упорядочение осуществляется по ключам, а не по значениям
usort()	Сортирует массив по значениям с использованием предоставленной функции сравнения. Аналогична uasort(), за исключением того, что ассоциации "ключ-значение" не сохраняются (как и в функции sort())

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

Код PHP $fruits = array("orange" => "Апельсин", "red" => "Яблоко", "yellow" => "Банан", "green" => "Груша"); sort($fruits); foreach ($fruits as $key => $value) { echo "".$key." => ".$value."
"; }
Использование функции sort()

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

Регулярные выражения Обработка чисел и математические операции 1 2 3 4 5 6 7 8 9 10

1. Что такое массив PHP?
2. Пример массива PHP?
3. Одномерный массив (векторный)
— индексный
— ассоциативный
4. Двумерный массив (массив в массиве, матрица)
5. Функции для работы с массивами (массив в массиве, матрица)

Начать данную тему хотелось бы с отречённых примеров. Допустим, мы рассматриваем какого-либо человека . У него есть имя, фамилия, адрес, телефон, пол, рост, цвет глаз и так далее. Информацию по всем этим пунктам можно отнести к массиву данных о человеке.

Массив может быть другого типа, без какой-либо конкретики по пунктам. Будет только тема. Допустим, это web-прграммирование . А в качестве элементов будут языки — HTML , CSS , JavaScript , PHP , MySQL . Всего 5 элементов.

Исходя из последнего примера предположим массив:

web-программирование
1. HTML
2. CSS
3. JavaScript
4. PHP
5. MySQL

Теперь смотрим на данный пример и анализируем основные понятия.

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

Массив в данном примере будет называться web-программирование .

У каждого элемента есть своё порядковое место, идентификатор.
Индекс (ключ массива) — либо порядковый номер, либо текстовое значение, по которому можно идентифицировать элемент.

Индексами в примере выше будут числовые значение от 1 до 5 . При обращении к индексу 2 мы увидим CSS.

Пример массива в PHP

Теперь давайте рассмотрим вышеуказанный пример в синтаксисе PHP, а не русского языка. Допустим массив будет называться короче — web . В квадратных скобках будет вставлять индекс.

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

$web=’HTML’;
$web=’CSS’;
$web=’JavaScript’;
$web=’PHP’;
$web=’MySQL’;

$web; // данная переменная содержит массив с 5-ю элементами

// чтобы вывести один из элементов массива достаточно указать индекс в массиве
echo $web; // выведет PHP

Одномерный массив

ИНДЕКСНЫЙ МАССИВ

Выше, с web-программированием, мы рассмотрели как раз пример одномерного массива.
Таким способом он создаётся редко. Он скорее наглядно показывает структуру массива. Чаще прибегают к другому методу.

$web=array(‘HTML’,’CSS’,’JavaScript’,’PHP’,’MySQL’);
echo $web; // выведет ‘HTML’
echo $web; // выведет ‘JavaScript’
echo $web; // выведет ‘PHP’

Если Вы хотите задать значения индекса, то их надо указать следующим образом. Знак => является указателем для присваивания индекса значению или наоборот значению индекс.

$web=array(1=>’HTML’,2=>’CSS’,3=>’JavaScript’,4=>’PHP’,5=>’MySQL’);
echo $web; // HTML
echo $web; // CSS
echo $web; // PHP
В примере отсчёт начинается с 1. Переменная с индексом 0 вследствие этого пустая.

В следующем примере мы не будем указывать индекс.

$day=’Понедельник’; // индекс 0
$day=’Вторник’; // 1
$day=’Среда’; // 2
$day=’Четверг’; // 3
$day=’Пятница’; // 4
Можно проследить, что происходит последовательное заполнение с нуля.

АССОЦИАТИВНЫЙ МАССИВ

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

$user[‘nick’]=’Logic’;
$user[‘name’]=’Павел’;
$user[‘age’]=’25’;
$user[‘sex’]=’Мужской’;

$user; // переменная $user содержит массив с 4-мя элементами с буквенными индексами

// выводим элемент массива, указывая его буквенный индекс
echo $web[‘name’]; // выведет ‘Павел’
Как видите, всё достаточно просто. Только значение индекса закавычиваем.

Двумерный массив

Если Вы пропустили первую часть с Одномерным массивом, то настоятельно советую прочитать.
Если говорить проще, то это массив в массиве. То есть элементов большого массива является другой. Подобные массивы очень тормозят работу скрипта, загружая оперативную память, поэтому для быстрой обработки подобных групп данных созданы Базы Данных (Что такое База данных?), но о ней позже. Давайте разберём пример двумерного массива.

// массив с названиями Частей Света
$m = array(‘Европа’,’Азия’,’Африка’,’Америка’,’Австралия и Океания’);

// массив с названиями Стран
$s = array(‘Россия’,’Украина’,’Беларусь’,’Казахстан’);

// массив с названиями Столиц
$с = array(‘Москва’,’Киев’,’Минск’,’Астана’);

// создаём двумерный массив География
$geography = array($m, $s, $с);
?>
Во включенных массивах, как Вы обратили внимание, может быть разное количество элементов. Из части про одномерные массивы следовало, что у каждого элемента массива может быть индекс. Так давайте для каждого включённого массива присвоим своё значение.

Для этого расширим последнюю строчку и напишем её следующим образом.

$geography = array(‘Части Света’=>$m, ‘Страны’=>$s, ‘Столицы’=>$с);

Функции работы с массивами php

Foreach — циклическая функция для работы с массивами, в которой количество циклов равно количеству элементов массива.

Имеет следующий вид.

Код PHP

foreach (массив as $ключ=>$значение)
команды;
Ну и сразу пример работы

// создаём массив со знаменитыми IT
$names["Ритчи"] = "Деннис";
$names["Томпсон"] = "Кен";
$names["Гейтс"] = "Билл";
$names["Джобс"] = "Стив";

foreach ($names as $key => $value) {
echo "$value $key";
}
?>
На экран скрипт выведет

Деннис Ритчи
Кен Томпсон
Билл Гейтс
Стив Джобс
Count — функция, возвращающая количество элементов в массиве.

echo count($names); // в нашем примере с IT вернёт значение 4
Sort — функция, сортирующая элементы массива. Удобна в случае числовых значений индекса.
Arsort — функция, сортирующая элементы массива в обратном порядке.

sort($names); // сортирует по порядку. Удобно если в Индексе числа
arsort($names); // сортировать в обратном порядке. То есть по индексам элементы будут в порядке 3, 2, 1, 0
Unset — функция, удаляющая элемент массива.

unset($massiv); // удаление элемента массива с индексом 2
unset($massiv); // удаление массива целиком
Array_search — функция поиска в массиве.

Урок 7. Массивы в PHP

Имеет два аргумента. Проще говоря, имеет вил array_search(‘что’, где)

$animals=’dog’;
$animals=’cat’;
$animals=’bird’;
echo array_search(‘cat’,$animals); // выведет индекс элемента — цифру 2
Shuffle — функция, которая перемешивает ключи значений массива.

shuffle($animals); // выстроит элементы в случайном порядке
Спасибо за внимание!

Предыдущая статья
Урок 6. Циклы в PHPСледующая статья
Урок 8. Подключение файла в PHP. Include и require

Комментарии к статье (vk.com)

Создает пустой массив.

Вы можете вывести значения в массив позже, например:

На данный момент $ myArray содержит «дерево», «дом» и «собака». Каждая из приведенных выше команд добавляется к массиву, сохраняя элементы, которые уже были там.

Придя с других языков, этот способ добавления массива мне показался странным. Я ожидал сделать что-то вроде $ myArray + = «собака» или что-то еще …

или, может быть, метод «add ()», такой как коллекции Visual Basic. Но этот прямой синтаксис append является коротким и удобным.

Вы действительно должны использовать функцию unset () для удаления элементов:

… удалит «дом» из массива (массивы основаны на нулевом значении).

Основы работы с массивами в PHP

… уничтожит весь массив.

Чтобы быть ясным, синтаксис пустой квадратной скобки для добавления к массиву — это просто способ сообщить PHP, чтобы автоматически присваивать индексы каждому значению, а не присваивать индексы. Покрытия, PHP на самом деле делает это:

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

Поэтому, если вы это сделаете:

… для элемента «собака» будет присвоен индексный номер 21. PHP не выполняет интеллектуального сопоставления шаблонов для поэтапного присвоения индексов, поэтому он не будет знать, что вам, возможно, захотелось присвоить индекс 30 «собаке» ». Вы можете использовать другие функции, чтобы указать шаблон приращения для массива. Я не буду вдаваться в это, но все это в PHP-документах.

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

Массивы в PHP. Работа с массивами в PHP.

В данной статье рассматривается работа с массивами в PHP (основы). Массивы в PHP – это тип данных, который позволяет сохранять несколько переменных в одной.

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

В приведенном выше примере $products – это массив, в котором мы сохранили несколько различных продуктов. Далее мы вывели все эти продукты, обращаясь к каждому через “индексы” (ключи) : 0, 1 и 2.

Конечно, отдельные значения можно хранить и в отдельных переменных, например, так:

Это, конечно, хорошо, но давайте представим, что нам потребовалось вдруг перебрать все эти элементы. Как тут быть? Писать код под каждую переменную? Это долго и неудобно. Решение – использование массивов.
Используя циклы мы можем на каждой итерации (шаге) получить доступ к очередному элементу, благодаря индексам (ключам).

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

В php не требуется делать объявление массива. Создать массив мы можем, используя функцию array():

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

Виды массивов.

1. ”Индексируемые” массивы или “автомассивы”. Примеры такого массива мы уже приводили выше. Особенностью данных массивов является то, что они имеют числовые индексы, которые создаются автоматически (“на лету”). Нумерация элементов начинается с 0.

Как определить длину (размер) индексируемого массива.

Использование массивов

Используем функцию count() :

Перебор элементов. Перебрать все элементы автомассива можно с помощью конструкции for или foreach :

Чтобы добавить новый элемент в массив (осуществить запись в массив), нам достаточно выполнить следующую строку:

Перебор всех элементов ассоциативного массива осуществляется следующим образом:

3. Многомерные массивы содержат в качестве элементов другие массивы:

Мы можем создать и трехмерный массив:

вывод массива в PHP. Вывести любой массив можно с помощью функции print_r() , например:

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

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

Сортировка массивов
array_search – поиск значения в массиве