Давно я не писал в бложек. Работа и учеба не дают покоя. Последнее время получаю много заказов на PHP, и частенько приходится работать с массивами данных. Знания мои в PHP не изумительные, поэтому постоянно лезу в документацию. Сегодня пришла в голову мысль — написать себе мини-шпаргалку с полезными функциями для работы с массивами в PHP. Думаю, эта шпаргалка пригодится не только мне.

Самая часто используемая функция на мой взгляд — это count(«массив») . Функция count возвращает количество элементов в массиве. Пример работы:

$myArr = array("John", "Ivan", "Oleg"); echo count($myArr);

$ myArr = array ("John" , "Ivan" , "Oleg" ) ;

echo count ($ myArr ) ;

На самом деле, функция count может работать не только с массивами, но и с обыкновенными переменными, а так же с многомерными массивами. Приведу еще парочку примеров:

$myArr = array(array(1, 2, 3), array(1, 2), 3); echo count($myArr); //Выведет 3 echo count($myArr, COUNT_RECURSIVE); //Выведет общее количество элементов (8) $myVar = "Ivan"; echo count($myVar); //Выведет 1 echo count(NULL); //Выведет 0

$ myArr = array (array (1 , 2 , 3 ) , array (1 , 2 ) , 3 ) ;

echo count ($ myArr ) ; //Выведет 3

echo count ($ myArr , COUNT_RECURSIVE ) ; //Выведет общее количество элементов (8)

$ myVar = "Ivan" ;

echo count ($ myVar ) ; //Выведет 1

echo count (NULL ) ; //Выведет 0

Если кто не понял, почему count($myArr, COUNT_RECURSIVE) возвращает 8 — объясняю. Массив $myArr состоит из 3-х элементов (два массива и одно число). Первый элемент массива $myArr — это массив из 3 элементов. Значит всего элементов уже 6. Прибавляем сюда еще два элемента из второго массива и получаем 8.

Идем дальше. Следующая полезная функция — in_array(«искомое значение», «массив», [«совпадение по типу»]) . Функция in_array ищет элемент по искомому значению в переданном ей массиве. Если находит — возвращает TRUE, в противном случае FALSE. Третий аргумент отвечает за необходимость совпадения по типу. Если он установлен в TRUE — значит, искомое значение должно совпадать не только по значению, но и по типу. Кроме того, сравнение строк — чувствительно к регистру. Примеры:

$myArr = array("Abc", "3", 2); echo in_array("Abc", $myArr); //Выведет 1 echo in_array("abc", $myArr); //Ничего не выведет echo in_array("2", $myArr); //Выведет 1 echo in_array("2", $myArr, TRUE); //Ничего не выведет

echo in_array ("Abc" , $ myArr ) ; //Выведет 1

echo in_array ("abc" , $ myArr ) ; //Ничего не выведет

echo in_array ("2" , $ myArr ) ; //Выведет 1

echo in_array ("2" , $ myArr , TRUE ) ; //Ничего не выведет

$myArr = array("Abc", "3", 2); echo array_search("Abc", $myArr); //Выведет 0 echo array_search("abc", $myArr); //Ничего не выведет echo array_search("2", $myArr); //Выведет 2 echo array_search("2", $myArr, TRUE); //Ничего не выведет

$ myArr = array ("Abc" , "3" , 2 ) ;

echo array_search ("Abc" , $ myArr ) ; //Выведет 0

echo array_search ("abc" , $ myArr ) ; //Ничего не выведет

echo array_search ("2" , $ myArr ) ; //Выведет 2

echo array_search ("2" , $ myArr , TRUE ) ; //Ничего не выведет

Ничего сложного. Следующей гости нашей статьи это array_values(«массив») и array_keys(«массив») . Не трудно догадаться, как они работают. Функция array_values возвращает новый массив, содержащий все значение переданного ей массива, а array_keys — ключи, переданного ей массива. Примеры:

$myArr = array("A" => 1, "B" => 2, "C" => 3); $valuesArr = array_values($myArr); $keysArr = array_keys($myArr); print_r($valuesArr); print_r($keysArr);

$ myArr = array ("A" =& gt ; 1 , "B" =& gt ; 2 , "C" =& gt ; 3 ) ;

$ valuesArr = array_values ($ myArr ) ;

$ keysArr = array_keys ($ myArr ) ;

print_r ($ valuesArr ) ;

print_r ($ keysArr ) ;

Результат выполнения:

Array ( => 1 => 2 => 3) Array ( => A => B => C).

Идем дальше. Функции сортировки массивов. Первой рассмотрим sort(«массив», [«флаги»]) . Сортирует массив по возрастанию, или по алфавиту, если это строка. В качестве дополнительных флагов можно задать следующие параметры: SORT_REGULAR (о бычное сравнение элементов), SORT_NUMERIC (числовое сравнение элементов), SORT_STRING (строковое сравнение элементов). Подробнее можно прочитать в официальной документации, по вот этой ссылке . Примеры использования функции:


"; sort($myArr); print_r($myArr); echo "
"; sort($myArr, SORT_STRING); print_r($myArr); echo "
";

print_r ($ myArr ) ;

echo "
" ;

sort ($ myArr ) ;

print_r ($ myArr ) ;

echo "
" ;

sort ($ myArr , SORT_STRING ) ;

print_r ($ myArr ) ;

echo "
" ;

Результат работы:

Array ( => 10 => 1 => 12 => 13 => 2 => 3 => 11 => 100)
Array ( => 1 => 2 => 3 => 10 => 11 => 12 => 13 => 100)
Array ( => 1 => 10 => 100 => 11 => 12 => 13 => 2 => 3)

Все просто, не так ли? Есть аналогичная функция, но сортирует она в обратном порядке — rsort(«массив», [«флаги»]) . А так же еще две функции, выполняющие аналогичные действия, но при этом они сохраняют значения ключей. Это asort(«массив», [«флаги»]) — простая сортировка с сохранением ключей и arsort(«массив», [«флаги»]) — сортировка в обратном порядке, с сохранением ключей. Аналогичный пример работы функций asort и arsort:

$myArr = array(10, 1, 12, 13, 2, 3, 11, 100); print_r($myArr); echo "
"; asort($myArr); print_r($myArr); echo "
"; arsort($myArr); print_r($myArr); echo "
";

$ myArr = array (10 , 1 , 12 , 13 , 2 , 3 , 11 , 100 ) ;

print_r ($ myArr ) ;

echo "
" ;

asort ($ myArr ) ;

print_r ($ myArr ) ;

echo "
" ;

arsort ($ myArr ) ;

print_r ($ myArr ) ;

echo "
" ;

Результат работы немного другой:

Array ( => 10 => 1 => 12 => 13 => 2 => 3 => 11 => 100)
Array ( => 1 => 2 => 3 => 10 => 11 => 12 => 13 => 100)
Array ( => 100 => 13 => 12 => 11 => 10 => 3 => 2 => 1)

Обратите внимание, что в этом примере я не использовал флаг SORT_STRING. Кроме этих функций, существует возможность сортировка массива по ключам. Для этого есть функции ksort(«массив», [«флаги»]) и krsort(«массив», [«флаги»]) , которые работают аналогично, поэтому обойдемся без примера:).

А что если я хочу отсортировать массив каким-либо своим способом? В этом мне могут помочь функции usort(«массив», «функция») и uksort(«массив», «функция») , которые выполняют сортировку в соответствии пользовательской функции сравнения элементов. То есть, программист должен описать функцию, которая будет сравнивать элементы массива по очереди, а сами usort или uksort будут располагать элементы в массиве, в зависимости от результатов сравнения. Пример немного посложнее. Сначала объясню устройство массива. Он будет состоять из массивов, содержащих строку и число. Например, вот такой:

$myArr = array(array(1, "String1"), array(2, "String2"), array(3, "String3"));

$ myArr = array (array (1 , "String1" ) , array (2 , "String2" ) , array (3 , "String3" ) ) ;

Теперь поменяем элементы местами и отсортируем его по первому элементу внутренних массивов. Код:

//Наш массив $myArr = array(array(2, "String2"), array(3, "String3"), array(1, "String1")); //Функция сравнения элементов function compare($a, $b) { if ($a < $b) return -1; elseif ($a > $b) return 1; return 0; } //Сортируем массив usort($myArr, "compare"); //Выводим на экран print_r($myArr);

//Наш массив

$ myArr = array (array (2 , "String2" ) , array (3 , "String3" ) , array (1 , "String1" ) ) ;

//Функция сравнения элементов

function compare ($ a , $ b ) {

if ($ a [ 1 ] & lt ; $ b [ 1 ] )

return - 1 ;

elseif ($ a [ 1 ] & gt ; $ b [ 1 ] )

return 1 ;

return 0 ;

//Сортируем массив

usort ($ myArr , "compare" ) ;

//Выводим на экран

print_r ($ myArr ) ;

Результат работы программы:

Array ( => Array ( => 1 => String1) => Array ( => 2 => String2) => Array ( => 3 => String3))

Как видите ничего сложного. Массив сортируется по первому элементу внутреннего массива. Функция сравнения может возвращать 3 значения. Если «положительное» — значит, функция сортировка считает, что первый элемент больше второго, если «отрицательное» — значит наоборот и если «0» — значит, элементы равны. Функция ursort работает также, только сортирует в обратном порядке. Кстати, можно отсортировать по убыванию, используя usort, просто задав правильную функцию сравнения для этого случая.

Дальше нас ждет array_walk(«массив», «функция», [«дополнительный аргумент»]) . Эта функция пробегается по массиву, передавая пару значения и ключа в пользовательскую функцию. Дополнительный аргумент, если он задан, передастся в качестве третьего в пользовательскую функцию. Если ошибок во время работы не возникло — вернет TRUE, иначе — FALSE. Рассмотрим пример, что бы было понятнее:

$myArr = array("A" => "Ivan", "B" => "John", "C" => "Bob"); function walker_function($value, $key, $additional) { echo $key." ".$additional." ".$value."
"; } array_walk($myArr, "walker_function", "is");

$ myArr = array ("A" =& gt ; "Ivan" , "B" =& gt ; "John" , "C" =& gt ; "Bob" ) ;

function walker_function ($ value , $ key , $ additional ) {

echo $ key . " " . $ additional . " " . $ value . "
" ;

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

Что такое массив?
Если не задротничать и объяснять понятным языком, то массив - это переменная, содержащая в себе сколько угодно других переменных, а те в свою очередь, тоже могут быть массивами. Таким образом, массив может быть просто гиганских объемов и вмещать в себя очень много информации. А благодаря функциям PHP для работы с массивами, с ними становится очень удобно работать. Сортировать, чистить, находить нужные ключи, перебирать и еще очень много чего.

Некоторые примеры
Рассмотрим пример:

$b = "test b" ; ?>

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

1
2
3

$test_array [ "a" ] = "test a" ;
$test_array [ "b" ] = "test b" ; ?>

А тут мы создали массив $test_array и создали 2 ключа с некоторыми значениями.
Первоначально может показаться что с массивом все выглядит както громоздко, но давайте представим ситуацию когда нам надо вывести на экран 1000 переменных. Если все это отдельные переменные, то мы можем просто исписать целую простыню пока напишем что-то вроде

1
2
3
4
5

echo $b ;
echo $c ;
echo $d ;
... ?>

А вот если бы все этти переменные были ключами массива, то мы просто написали:

1
2
3

echo $value ;
} ?>

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

Сортировка данных
Один из самых лучших способов применить массив - это применить его для сортировки данных или для объединения каких то данных, что бы потом не путаться. Рассмотрим пример с машинами. Допустим у нас есть 2 машины и на каждую из них по два варианта салона. И у каждого по 3 возможных цвета.

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

"Машина1" => array(
"салон1" => array(
"цвет1" => "черный" ,
"цвет2" => "красный" ,
"цвет3" => "зеленый"
),
"салон2"
),
"Машина2" => array(
//и так далее
); ?>

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

//выведет "черный" ?>

Поиск
Как и в любых данных, в массивах важен поиск и тут в PHP предусмотрен ряд функций для поиска по массивам. Например функция array_key_exists() проверяет есть ли в массиве определенный ключ, а функция in_array() проверяет есть ли в массиве определенное значение. Для тех кто еще не понял, все данные в массивах хранятся в виде ключ=значение

На самом деле массив в PHP - это упорядоченное отображение, которое устанавливает соответствие между значением и ключем . Этот тип оптимизирован в нескольких направлениях, поэтому вы можете использовать его как собственно массив, список (вектор), хэш-таблицу (являющуюся реализацией карты), словарь, коллекцию, стэк, очередь или, возможно, как что-то еще. Поскольку вы можете иметь в качестве значения другой массив PHP, вы можете также легко эмулировать деревья. Объяснение этих структур данных выходит за рамки данного справочного руководства, но вы найдете как минимум один пример каждой из них. За дополнительной информацией вы можете обратиться к соответствующей литературе по этой обширной теме.

Синтаксис

Определение при помощи array()

Массив может быть создан языковой конструкцией array() . В качестве параметров она принимает определенное количество разделенных запятыми пар key => value (ключ => значение). $arr = array("foo" => "bar" , 12 => true );$arr [ "foo" ]; // bar
echo $arr [ 12 ]; // 1
?>

Key может быть либо integer , либо string . Если ключ - это стандартное представление integer , он так и будет интерпретироваться (т.е. "8" будет восприниматься как 8 , тогда как "08" будет интерпретироваться как "08"). В PHP нет разницы между индексными и ассоциативными массивами; существует только один тип массива, который может содержать и числовые, и строковые индексы. Значение может быть любого имеющегося в PHP типа.

$arr = array("somearray" => array(6 => 5 , 13 => 9 , "a" => 42 ));$arr [ "somearray" ][ 6 ]; // 5
echo $arr [ "somearray" ][ 13 ]; // 9
echo $arr [ "somearray" ][ "a" ]; // 42
?>

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

// Этот массив эквивалентен...
array(5 => 43 , 32 , 56 , "b" => 12 );// ...этому массиву
array(5 => 43 , 6 => 32 , 7 => 56 , "b" => 12 );
?>

Используя в качестве ключа TRUE вы получите ключ 1 типа integer . Используя в качестве ключа FALSE вы получите ключ 0 типа integer . Используя в качестве ключа NULL , вы получите пустую строку. Использование в качестве ключа пустой строки создаст (или перезапишет) ключ с пустой строкой и его значение; это не то же самое, что использование пустых квадратных скобок. Вы не можете использовать в качестве ключей массивы или объекты. Это вызовет предупреждение: Illegal offset type ("Недопустимый тип смещения").

Создание/модификация с помощью синтаксиса квадратных скобок

Также вы можете изменять существующий массив, явно устанавливая значения в нем. Это выполняется присвоением значений массиву при указании в скобках ключа. Кроме того, вы можете опустить ключ, в этом случае добавьте к имени переменной пустую пару скобок (" "). Если массив $arr еще не существует, он будет создан. Таким образом, это еще один способ определить массив. Для изменения определенного значения просто присвойте элементу с его ключом новое значение. Если вы хотите удалить пару ключ/значение, вам нужно использовать функцию unset() .
Замечание: Как уже говорилось выше, если вы не укажите в скобках ключа, то будет взят максимальный из существующих целочисленных индексов, и новым ключом будет это максимальное значение + 1. Если целочисленных индексов еще нет, то ключом будет 0 (ноль). Если вы укажите ключ, которому уже присвоено значение, оно будет перезаписано.

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

// Создаем простой массив.
$array = array(1 , 2 , 3 , 4 , 5 );
print_r ($array );// Теперь удаляем каждый элемент, но сам массив оставляем нетронутым:
foreach ($array as $i => $value ) {
unset($array [ $i ]);
}
print_r ($array );// Создаем элемент (обратите внимание, что новым ключом будет 5,
// а не 0, как вы возможно ожидали).
$array = 6 ;
print_r ($array );// Переиндексация:
$array = array_values ($array );
$array = 7 ;
print_r ($array );
?>
Вышеприведенный пример выведет следующее: Array ( => 1 => 2 => 3 => 4 => 5) Array () Array ( => 6) Array ( => 6 => 7)

Полезные функции

Для работы с массивами существует достаточное количество полезных функций. Смотрите раздел функции для работы с массивами .
Замечание: Функция unset() позволяет удалять ключи массива. Обратите внимание, что массив НЕ будет переиндексирован. Если вы использовали только "обычные числовые индексы" (увеличивающиеся на единицу, начиная с нуля), вы можете переиндексировать массив используя array_values() .

Управляющая конструкция foreach существует специально для массивов. Она предоставляет возможность легко пройтись по массиву.

Массив делает и не делает

Почему $foo это неверно?

Вы всегда должны заключать индекс ассоциативного массива в кавычки. К примеру, пишите $foo["bar"], а не $foo. Но почему $foo это неверно? Возможно, вы встречали в старых скриптах следующий синтаксис: $foo [ bar ] = "враг" ;
echo $foo [ bar ];
// и т. д.
?>

Это неверно, хотя и работает. Тогда почему же это неверно? Причина в том, что этот код содержит неопределенную константу (bar), а не строку ("bar" - обратите внимание на кавычки), и PHP в будущем может определить константу, которая к несчастью для вашего кода будет иметь то же самое имя. Это работает, потому что PHP автоматически преобразует голую строку (не заключенную в кавычки строку, которая не соответствует ни одному из известных символов) в строку, которая содержит голую строку. Например, если константа с именем bar не определена, то PHP заменит bar на строку "bar" и использует ее.

Замечание: Это не означает, что нужно всегда заключать ключ в кавычки. Нет необходимости заключать в кавычки константы или переменные , поскольку это помешает PHP обрабатывать их. error_reporting (E_ALL );
ini_set ("display_errors" , true );
ini_set ("html_errors" , false );
// Простой массив:
$array = array(1 , 2 );
$count = count ($array );
for ($i = 0 ; $i < $count ; $i ++) {
echo "\nПроверяем $i: \n" ;
echo "Плохо: " . $array [ "$i" ] . "\n" ;
echo "Хорошо: " . $array [ $i ] . "\n" ;
echo "Плохо: {$array["$i"]}\n" ;
echo "Хорошо: {$array[$i]}\n" ;
}
?>

Замечание: Вышеприведенный код выведет следующее:

Дополнительные примеры, демонстрирующие этот факт:

// Давайте покажем все ошибки
error_reporting (E_ALL );$arr = array("fruit" => "apple" , "veggie" => "carrot" );// Верно

print $arr [ "veggie" ]; // carrot

// Неверно. Это работает, но из-за неопределенной константы с
// именем fruit также вызывает ошибку PHP уровня E_NOTICE
// Notice: Use of undefined constant fruit - assumed "fruit" in...

print $arr [ fruit ]; // apple

// Давайте определим константу, чтобы продемонстрировать, что
// происходит. Мы присвоим константе с именем fruit значение "veggie".

define ("fruit" , "veggie" );// Теперь обратите внимание на разницу
print $arr [ "fruit" ]; // apple
print $arr [ fruit ]; // carrot

// Внутри строки это нормально. Внутри строк константы не
// рассматриваются, так что ошибки E_NOTICE здесь не произойдет

print "Hello $arr" ; // Hello apple

// С одним исключением: фигурные скобки вокруг массивов внутри
// строк позволяют константам находится там

print "Hello {$arr}" ; // Hello carrot
print "Hello {$arr["fruit"]}" ; // Hello apple

// Это не будет работать и вызовет ошибку обработки, такую как:
// Parse error: parse error, expecting T_STRING" or T_VARIABLE" or T_NUM_STRING"
// Это, конечно, также приложимо и к использованию в строках автоглобальных переменных

print "Hello $arr["fruit"]" ;
print "Hello $_GET["foo"]" ;// Еще одна возможность - конкатенация
print "Hello " . $arr [ "fruit" ]; // Hello apple
?>

Когда вы переведете error_reporting() в режим отображения ошибок уровня E_NOTICE (такой как E_ALL), вы увидите эти ошибки. По умолчанию error_reporting установлена их не отображать. Как указано в разделе синтаксис , внутри квадратных скобок (" [ " и " ] ") должно быть выражение. Это означает, что вы можете писать подобно этому:

Обратите внимание, что E_ERROR - это такой же верный идентификатор, как и bar в первом примере. Но последний пример по сути эквивалентен такой записи:

Поскольку E_ERROR соответствует 1 и т. д. Как мы уже объяснили в вышеприведенных примерах, $foo по-прежнему работает, но это неверно. Это работает, поскольку в соответствии со своим синтаксисом bar ожидается как константа. Однако, в данном случае константы с именем bar не существует. В таком случае PHP предполагает, что, написав bar , вы имели ввиду строку "bar" , но забыли указать кавычки.

Так что же в этом плохого?

Когда-нибудь в будущем команда разработчиков PHP возможно пожелает добавить еще одну константу или ключевое слово, либо вы можете ввести в ваше приложение еще одну константу и тогда у вас могут возникнуть проблемы. Например, вы уже не можете использовать таким образом слова empty и default , поскольку они являются зарезервированными ключевыми словами .
Замечание: Повторим, внутри строки (string ), заключенной в двойные кавычки правильным является не окружать индексы массива кавычками, поэтому "$foo" является верным. Более подробно почему - смотрите вышеприведенные примеры, а также раздел обработка переменных в строках .

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

Для любого из типов: integer , float , string , boolean и , если вы преобразуете значение в массив, вы получите массив с одним элементом (с индексом 0), являющимся скалярным значением, с которого вы начали. Если вы преобразуете в массив объект (object ), вы получите в качестве элементов массива свойства (переменные-члены) этого объекта. Ключами будут имена переменных-членов. Если вы преобразуете в массив значение NULL , вы получите пустой массив.

Примеры

Тип массив в PHP является очень гибким, поэтому мы приведем здесь несколько примеров, чтобы продемонстрировать вам все возможности массивов. // это
$a = array("color" => "red" ,
"taste" => "sweet" ,
"shape" => "round" ,
"name" => "apple" ,
4 // ключом будет 0
);// полностью соответствует
$a [ "color" ] = "red" ;
$a [ "taste" ] = "sweet" ;
$a [ "shape" ] = "round" ;
$a [ "name" ] = "apple" ;
$a = 4 ; // ключом будет 0$b = "a" ;
$b = "b" ;
$b = "c" ;
// создаст массив array(0 => "a" , 1 => "b" , 2 => "c"),
// или просто array("a", "b", "c")
?>

Пример 11-4. Использование array()

// Массив как карта (свойств)
$map = array("version" => 4 ,
"OS" => "Linux" ,
"lang" => "english" ,
"short_tags" => true
);// исключительно числовые ключи
$array = array(7 ,
8 ,
0 ,
156 ,
- 10
);
// это то же самое, что и array(0 => 7, 1 => 8, ...)$switching = array(10 , // ключ = 0
5 => 6 ,
3 => 7 ,
"a" => 4 ,
11 , // ключ = 6 (максимальным числовым индексом был 5)
"8" => 2 , // ключ = 8 (число!)
"02" => 77 , // ключ = "02"
0 => 12 // значение 10 будет перезаписано на 12
);// пустой массив
$empty = array();
?>
Результат работы приведенного скрипта будет следующий: Обратите внимание, что в настоящее время невозможно изменять значения массива в таком цикле напрямую. Однако можно сделать так: Следующий пример создает начинающийся с единицы массив.

= sort ($files );
print_r ($files );
?>

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

Пример 11-10. Рекурсивные и многомерные массивы

$fruits = array ("фрукты" => array ("a" => "апельсин" ,
"b" => "банан" ,
"c" => "яблоко"
),
"числа" => array (1 ,
2 ,
3 ,
4 ,
5 ,
6
),
"дырки" => array ("первая" ,
5 => "вторая" ,
"третья"
);// Несколько примеров доступа к значениям предыдущего массива
echo $fruits [ "дырки" ][ 5 ]; // напечатает "вторая"
echo $fruits [ "фрукты" ][ "a" ]; // напечатает "апельсин"
unset($fruits [ "дырки" ][ 0 ]); // удалит "первая"

// Создаст новый многомерный массив

$juices [ "яблоко" ][ "зеленое" ] = "хорошее" ;
?>
Обратите внимание, что при присваивании массива всегда происходит копирование значения. Чтобы копировать массив по ссылке, вам нужно использовать оператор ссылки.

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

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

"; ?>

Здесь создается массив $phones из четыре элементов. Каждый элемент в массиве представляет собой пару ключ - значение . Так, первый элемент $phones = "Nokia N9" имеет ключ - число 0, а значение - строку "Nokia N9". В таких массивах числовые ключи еще называются индексами.

С помощью функции count() можно узнать количество элементов в массиве. А благодаря тому, что ключи идут по порядку от 0 до 3, и зная размер массива, можно вывести элементы массивы в цикле for .

Чтобы было более понятно отношения ключей и значений элементов, выведем массив с помощью функции print_r :

Print_r($phones);

У нас получится следующий вывод:

Array ( => Nokia N9 => Samsung Galaxy ACE II => Sony Xperia Z3 => Samsung Galaxy III)

Данное создание массива будет также эквивалентно следующему:

"; ?>

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

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

// получим элемент по ключу 1 $myPhone = $phones; echo "$myPhone
"; // присвоение нового значения $phones = "Samsung X650"; echo "$phones
";

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

Подобные массивы еще называют ассоциативными.

Оператор array

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

Оператор array() принимает набор элементов. Здесь также явным образом не указаны ключи. Поэтому PHP автоматически нумерует элементы с нуля. Но мы также можем указать для каждого элемента ключ:

"iPhone5", "samsumg"=>"Samsung Galaxy III", "nokia" => "Nokia N9", "sony" => "Sony XPeria Z3"); echo $phones["samsumg"]; ?>

Операция => позволяет сопоставить ключ с определенным значением.

Перебор ассоциативных массивов

Выше мы посмотрели, как с помощью цикла for вывести все элементы массива, где ключи заданы последовательно числами от 0 до 3. Однако с ассоциативными массивами это не работает. И для них в PHP предназначен специальный тип цикла - foreach...as :

"iPhone5", "samsumg"=>"Samsung Galaxy III", "nokia" => "Nokia N9", "sony" => "Sony XPeria Z3"); foreach($phones as $item) echo "$item
"; ?>

В цикле foreach из массива последовательно извлекаются все элементы и их значение помещается в переменную, указанную после ключевого слова as . В данном случае в переменную $item по очереди помещаются все четыре значения из массива $phones. Когда будет извлечен последний элемент из массива, цикл завершается.

Цикл foreach позволяет извлекать не только значения, но и ключи элементов:

"iPhone5", "samsumg"=>"Samsung Galaxy III", "nokia" => "Nokia N9", "sony" => "Sony XPeria Z3"); foreach($phones as $key=>$value) echo "$key => $value
"; ?>

Здесь при переборе элементов цикла в переменную $key будет передаваться ключ элемента, а в переменную $value ее значение.

Альтернативу циклу foreach представляет использование функций list и each :

"iPhone5", "samsumg"=>"Samsung Galaxy III", "nokia" => "Nokia N9", "sony" => "Sony XPeria Z3"); while (list($key, $value) = each($phones)) echo "$key => $value
"; ?>

Цикл while будет работать, пока функция each не вернет значение false . Функция each проходит по всем элементам массива $phones и получает его в виде массива, в который входят ключ и значение элемента. Затем этот массив передается функции list и проиcходит присваивает значения массива переменным внутри скобок. Когда функция each закончит перебор элементов массива $phones, она возвратит false , и действие цикла while будет завершено.

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

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

array("iPhone5", "iPhone5s", "iPhone6") , "samsumg"=>array("Samsung Galaxy III", "Samsung Galaxy ACE II"), "nokia" => array("Nokia N9", "Nokia Lumia 930"), "sony" => array("Sony XPeria Z3", "Xperia Z3 Dual", "Xperia T2 Ultra")); foreach ($phones as $brand => $items) { echo "

$brand

"; echo "
    "; foreach ($items as $key => $value) { echo "
  • $value
    • "; } echo "
"; } ?>

И при выводе мы получим 4 списка:

Чтобы обратиться к элементу данного, также надо указать ключи в квадратных скобках. Например, обратимся к первому элементу в первом массиве. Так как ключ первого массива - "apple", а ключ первого элемента в первом массиве - число 0 (так как мы явным образом не указали ключи):

Echo $phones["apple"];

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

Echo $phones["nokia"];

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

array("apple" => "iPhone5", "samsumg" => "Samsung Galaxy III", "nokia" => "Nokia N9"), "tablets" => array("lenovo" => "Lenovo IdeaTab A3500", "samsung" => "Samsung Galaxy Tab 4", "apple" => "Apple iPad Air")); foreach ($technics as $tovar => $items) { echo "

$tovar

"; echo "
    "; foreach ($items as $key => $value) { echo "
  • $key: $value
    • "; } echo "
"; } // присвоим одному из элементов другое значение $technics["phones"]["nokia"] = "Nokia Lumnia 930"; // выведем это значение echo $technics["phones"]["nokia"]; ?>