Робота з асоціативними масивами в PHP
Зміст
Асоціативні масиви в PHP
В У PHP індексом масиву може бути не тільки число, а й рядок. Причому на такий рядок не накладаються ніякі обмежень: він може містити пробіли, довжина такого рядка може бути будь-яка.
Асоціативні масиви особливо зручні в ситуаціях, коли елементи масиву зручніше пов'язувати зі словами, а не з числами.
Отже, масиви, індексами яких є рядки, називаються асоціативними масивами.</ins>.
Одновимірні асоціативні масиви::
Одновимірні асоціативні масиви містять тільки один ключ (елемент), відповідний конкретному індексу асоціативного масиву. Наведемо приклад:
<?php
// Ассоциативный массив
$names["Иванов"]="Иван";
$names["Сидоров"]="Николай";
$names["Петров"]="Петр";
// В данном примере: фамилии - ключи ассоциативного массива
// , а имена - элементы массива names
?>
Доступ до елементів одновимірних асоціативних масивів здійснюється так само, як і до елементів звичайних масивів, і має назвудоступом по ключу:
echo $names["Иванов"];
Багатовимірні асоціативні масиви:
Багатовимірні асоціативні масиви можуть містити кілька ключів, відповідних конкретному індексу асоціативного масиву. Розглянемо приклад багатовимірного асоціативного масиву:
<?php
// Многомерный массив
$A["Ivanov"] = array("name"=>"Иванов И.И.", "age"=>"25", "email"=>"[email protected]");
$A["Petrov"] = array("name"=>"Петров П.П.", "age"=>"34", "email"=>"[email protected]");
$A["Sidorov"] = array("name"=>"Сидоров С.С.", "age"=>"47", "email"=>"[email protected]");
?>
Багатовимірні масиви схожі на записи в мові Pascal або структури в мові C.
Доступ до елементів багатовимірного асоціативного масиву здійснюється таким чином:
echo $A["Ivanov"]["name"]; // Выводит Иванов И.И.
echo $A["Petrov"]["email"]; // Выводит [email protected]
Як ви вже помітили, для створення багатовимірного асоціативного масиву ми використовували спеціальну функцію array, ми її розглянемо пізніше, коли будемо розглядати операції над масивами.
Асоціативні багатовимірні масиви можна створювати і класичним способом, хоча це не так зручно:
<?php
// Многомерный ассоциативный массив
$A["Ivanov"]["name"]="Иванов И.И.";
$A["Ivanov"]["age"]="25";
$A["Ivanov"]["email"]="[email protected]";
$A["Petrov"]["name"]="Петров П.П.";
$A["Petrov"]["age"]="34";
$A["Petrov"]["email"]="[email protected]";
$A["Sidorov"]["name"]="Сидоров С.С.";
$A["Sidorov"]["age"]="47";
$A["Sidorov"]["email"]="[email protected]";
// Получаем доступ к ключам многомерного ассоциативного массива
echo $A["Ivanov"]["name"]."<br>"; // Выводит Иванов И.И.
echo $A["Sidorov"]["age"]."<br>"; // Выводит 47
echo $A["Petrov"]["email"]."<br>"; // Выводит [email protected]
?>
Фукціі для роботи з масивами і операції над масивами
Функції для роботи з масивами
Розглянемо деякі основні функції для роботи з масивами.
Функція list()
Припустимо, у нас є масив, що складається з трьох елементів:
$names[0]="Александр";
$names[1]="Николай";
$names[2]="Яков";
Припустимо, в якийсь момент нам потрібно передати значення всіх трьох елементів масиву, відповідно трьом змінним: $alex, $nick, $yakov. Это можно сделать так:
$alex = $names[0];
$nick = $names[1];
$yakov = $names[2];
Якщо масив великий, то такий спосіб привласнення елементів масиву змінним не дуже зручний.
Є більш раціональний підхід - використання функції.:
list ($alex, $nick, $yakov) = $names;
Якщо нам потрібні тільки "Николай" и "Яков", тоді ми можемо зробити так:
list (, $nick, $yakov) = $names;
Функція array()
Функція використовується спеціально для створення масивів. При цьому вона дозволяє створювати порожні масиви. Методи використання функції Array():
<?php
// Создает пустой массив:
$arr = array();
// Создает список с тремя элементами. Индексы начинаются с нуля:
$arr2 = array("Иванов","Петров","Сидоров");
// Создает ассоциативный массив с тремя элементами:
$arr3 = array("Иванов"=>"Иван", "Петров"=>"Петр", "Сидоров"=>"Сидор");
// Создает многомерный ассоциативный массив:
$arr4 = array("name"=>"Иванов", "age"=>"24", "email"=>"[email protected]");
$arr4 = array("name"=>"Петров", "age"=>"34", "email"=>"[email protected]");
$arr4 = array("name"=>"Сидоров", "age"=>"47", "email"=>"[email protected]");
?>
Операции над массивами
Сортировка массивов
Начнем с самого простого — сортировки массивов. В PHP для этого существует очень много функций. С их помощью можно сортировать ассоциативные массивы и списки в порядке возрастания или убывания, а также в том порядке, в каком вам необходимо — посредством пользовательской функции сортировки.
Сортировка массива по значениям c помощью функций asort() и arsort():
Функция asort() сортирует массив, указанный в ее параметре, так, чтобы его значения шли в алфавитном (если это строки) или в возрастающем (для чисел) порядке.
При этом сохраняются связи между ключами и соответствующими им значениями, т. е. некоторые пары ключ=>значение просто "всплывают" наверх, а некоторые — наоборот, "опускаются". Например:
$A=array("a"=>"Zero","b"=>"Weapon","c"=>"Alpha","d"=>"Processor");
asort($A);
foreach($A as $k=>$v) echo "$k=>$v ";
// выводит "c=>Alpha d=>Processor b=>Weapon a=>Zero"
// как видим, поменялся только порядок пар ключ=>значение
Функция arsort() выполняет то же самое, за одним исключением: она упорядочивает массив не по возрастанию, а по убыванию.
Сортировка по ключам с помощью функций ksort() и krsort():
Функция ksort() практически идентична функции asort(), с тем различием, что сортировка осуществляется не по значениями, а по ключам (в порядке возрастания).
Например:
$A=array("d"=>"Zero", "c"=>"Weapon", "b"=>"Alpha", "a"=>"Processor");
ksort($A);
for(Reset($A); list($k,$v)=each($A);) echo "$k=>$v ";
// выводит "a=>Processor b=>Alpha c=>Weapon d=>Zero"
Функция для сортировки по ключам в обратном порядке называется krsort() и применяется точно в таком же контексте, что и ksort().
Сортировка по ключам при помощи функции uksort():
Довольно часто нам приходится сортировать что-то по более сложному критерию, чем просто по алфавиту. Например, пусть в $Files хранится список имен файлов и подкаталогов в текущем каталоге. Возможно, мы захотим вывести этот список не только в лексикографическом порядке, но также и чтобы все каталоги предшествовали файлам. В этом случае нам стоит воспользоваться функцией uksort(), написав предварительно функцию сравнения с двумя параметрами, как того требует uksort().
<?php
// Эта функция должна сравнивать значения $f1 и $f2 и nbsp;возвращать:
// -1, если $f1<$f2,
// 0, если $f1==$f2
// 1, если $f1>$f2
// Под < и > понимается следование этих имен в выводимом списке
function FCmp($f1,$f2)
{ // Каталог всегда предшествует файлу
if(is_dir($f1) && !is_dir($f2)) return -1;
// Файл всегда идет после каталога
if(!is_dir($f1) && is_dir($f2)) return 1;
// Иначе сравниваем лексикографически
if($f1<$f2) return -1; elseif($f1>$f2) return 1; else return 0;
}
// Пусть $Files содержит массив с ключами — именами файлов
// в текущем каталоге. Отсортируем его.
uksort($Files, "FCmp"); // передаем функцию сортировки "по ссылке"
?>
Конечно, связи между ключами и значениями функцией uksort() сохраняются, т. е., опять же, некоторые пары просто "всплывают" наверх, а другие — "оседают".
Сортировка по значениям при помощи функции uasort()
Функция uasort() очень похожа на uksort(), с той разницей, что сменной (пользовательской) функции сортировки "подсовываются" не ключи, а очередные значения из массива. При этом также сохраняются связи в парах ключ=>значение.
Переворачивание массива с помощью функции array_reverce()
Функция array_reverse() возвращает массив, элементы которого следуют в обратном порядке относительно массива, переданного в параметре. При этом связи между ключами и значениями, конечно, не теряются. Например, вместо того, чтобы ранжировать массив в обратном порядке при помощи arsort(), мы можем отсортировать его в прямом порядке, а затем перевернуть:
$A=array("a"=>"Zero","b"=>"Weapon","c"=>"Alpha","d"=>"Processor");
asort($A);
$A=array_reverse($A);
Конечно, указанная последовательность работает дольше, чем один-единственный вызов arsort().
Сортировка списка при помощи функций sort() и rsort()
Эти две функции предназначены в первую очередь для сортировки списков.
Функция sort() сортирует список (разумеется, по значениям) в порядке возрастания, а rsort() — в порядке убывания. Пример для функции sort():
<?php
$A=array("40", "20", "10", "30");
sort($A);
for($i=0; $i<count($A); $i++) echo "$A[$i]"."<br>";
// выводит 10 20 30 40
?>
Перемешивание списка с помощью функции shuffle()
Функция shuffle() "перемешивает" список, переданный ей первым параметром, так, чтобы его значения распределялись случайным образом. Обратите внимание, что, во-первых, изменяется сам массив, а во вторых, ассоциативные массивы восприимаются как списки. Пример:
$A=array(10,20,30,40,50);
shuffle($A);
foreach($A as $v) echo "$v ";
Приведенный фрагмент кода выводит числа 10, 20, 30, 40 и 50 в случайном порядке.
Выполнив этот фрагмент несколько раз, вы можете обнаружить, что от запуска к запуску очередность следования чисел не изменяется. Это свойство обусловлено тем, что функция shuffle() использует стандартный генератор случайных чисел, который перед работой необходимо инициализировать при
помощи вызова srand().
Операции с ключами и значениями массива
array_flip(array $arr)
Функция array_flip() "пробегает" по массиву и меняет местами его ключи и значения. Исходный массив $arr не изменяется, а результирующий массив просто возвращается.
Конечно, если в массиве присутствовали несколько элементов с одинаковыми значениями, учитываться будет только последний из них:
$A=array("a"=>"aaa", "b"=>"aaa", "c"=>"ccc");
$A=array_flip($A);
// теперь $A===array("aaa"=>"b", "ccc"=>"c");
array_keys(array $arr [,mixed $SearchVal])
Функция array_keys() возвращает список, содержащий все ключи массива $arr. Если задан необязательный параметр $SearchVal, то она вернет только те ключи, которым соответствуют значения $SearchVal.
Фактически, эта функция с заданным вторым параметром является обратной по отношению к оператору [] — извлечению значения по его ключу.
array_values(array $arr)
Функция array_values() возвращает список всех значений в ассоциативном массиве $arr. Очевидно, такое действие бесполезно для списков, но иногда оправдано для хэшей.
in_array(mixed $val, array $arr)
Функция in_array() возвращает true, если элемент со значением $val присутствует в массиве $arr.
Впрочем, если вам часто приходится проделывать эту операцию, подумайте: не лучше ли будет воспользоваться ассоциативным массивом и хранить данные в его ключах, а не в значениях? На этом вы можете сильно выиграть в быстродействии.
array_count_values(list $List)
Функция array_count_values() подсчитывает, сколько раз каждое значение встречается в списке $List, и возвращает ассоциативный массив с ключами — элементами списка и значениями — количеством повторов этих элементов. Иными словами, функция array_count_values() подсчитывает частоту появления значений в списке $List. Пример:
$List=array(1, "hello", 1, "world", "hello");
array_count_values($array);
// возвращает array(1=>2, "hello"=>2, "world"=>1)
Слияние массивов
Слияние (конкатенация) массивов - это операция создания массива, состоящего из элементов нескольких других массивов. Слияние массивов - это очень опасная операция, поскольку результат слияния подчиняется своей логике, забыв о которой можно потерять данные. Слияние массивов реализуется при помощи оператора "+" или с помощью функции array_merge(). Слияние списков может осуществляться только с помощью функции array_merge().
Предположим, мы имеем два массива:
$A = array("1"=>"первый", "2"=>"Второй");
$B = array("1"=>"первый", "2"=>"Второй");
Теперь сольем данные два массива в один массив $C:
$C = $A + $B;
Оператор "+" для массивов не коммутативен. Это означает, что $A + $B не равно $B + $A.
В результате рассмотренного примера мы получим массив $C следующего вида:
"1"=>"Первый", "2"=>"Второй", "3"=>"Третий", "4"=>"Четвертый"
А в результате $B + $A мы получим такой массив:
"3"=>"Третий", "4"=>"Четвертый", "1"=>"Первый", "2"=>"Второй"
При слиянии списков такой метод не работает. Поясним данный факт на примере:
Предположим, у нас есть два массива:
$A = array(10,11,12);
$B = array(13,14,15);
В результате слияния списков $A и $B ( $A + $B ) мы получим: 10,11,12. А это совсем не тот результат, который мы хотели получить... Связано это с тем, что при слиянии списков с одинаковыми индексами в результирующем массиве остается элемент первого массива, причем на том же месте. В таком случае нам необходимо использовать функцию array_merge()
Функция array_merge()
Функция array_merge() призвана устранить все недостатки, присущие оператору "+" для слияния массивов. А именно, она сливает массивы, перечисленные в ее аргументах, в один большой массив и возвращает результат. Если в массивах встречаются одинаковые ключи, в результат помещается пара ключ=>значение из того массива, который расположен правее в списке аргументов. Однако это не затрагивает числовые ключи: элементы с такими ключами помещаются в конец результирующего массива в любом случае.
Таким образом, с помощью array_merge() мы можем избавиться от всех недостатков оператора "+" для массивов. Вот пример, сливающий два списка в один:
$L1=array(100,200,300);
$L2=array(400,500,600);
$L=array_merge($L1,$L2);
// теперь $L===array(100,200,300,400,500,600);
Всегда используйте эту функцию, если вам нужно работать именно со списками, а не с обычными ассоциативными массивами.
Получение части массива
Для получения части массива можно использовать функцию <a href="/functions/?array_slice">array_slice()</a>
array_slice(array $Arr, int $offset [, int $len])
Эта функция возвращает часть ассоциативного массива, начиная с пары ключ=>значения со смещением (номером) $offset от начала и длиной $len (если последний параметр не задан - до конца массива).
Параметры $offset и $len задаются по точно таким же правилам, как и аналогичные параметры в функции substr(). А именно, они могут быть отрицательными (в этом случае отсчет осуществляется от конца массива), и т. д. Вот несколько примеров:
$input = array ("a", "b", "c", "d", "e");
$output = array_slice ($input, 2); // "c", "d", "e"
$output = array_slice ($input, 2, -1); // "c", "d"
$output = array_slice ($input, -2, 1); // "d"
$output = array_slice ($input, 0, 3); // "a", "b", "c"
Вставка и удаление элементов массивов
Мы уже знаем несколько операторов, которые отвечают за вставку и удаление элементов. Например, оператор [] (пустые квадратные скобки) добавляет элемент в конец массива, присваивая ему числовой ключ, а оператор Unset() вместе с извлечением по ключу удаляет нужный элемент. Язык PHP поддерживает и многие другие функции, которые иногда бывает удобно использовать.
array_push(alist &$Arr, mixed $var1 [, mixed $var2, …])
Эта функция добавляет к списку $Arr элементы $var1, $var2 и т. д. Она присваивает им числовые индексы — точно так же, как это происходит для стандарных []. Если вам нужно добавить всего один элемент, наверное, проще и будет воспользоваться этим оператором:
array_push($Arr,1000); // вызываем функцию…
$Arr[]=100; // то же самое, но короче
Обратите внимание, что функция array_push() воспринимает массив, как стек, и добавляет элементы всегда в его конец. Она возвращает новое число элементов в массиве.
array_pop(list &$Arr)
Функция array_pop(), является противоположностью array_push(), снимает элемент с "вершины" стека (то есть берет последний элемент списка) и возвращает его, удалив после этого его из $Arr. С помощью этой функции мы можем строить конструкции, напоминающие стек. Если список $Arr был пуст, функция возвращает пустую строку.
array_unshift(list &$Arr, mixed $var1 [, mixed $var2, …])
Функция array_unshift очень похожа на array_push(), но добавляет перечисленные элементы не в конец, а в начало массива. При этом порядок следования $var1, $var2 и т. д. остается тем же, т. е. элементы как бы "вдвигаются" в список слева. Новым элементам списка, как обычно, назначаются числовые индексы, начиная с 0; при этом все ключи старых элементов массива, которые также были числовыми, изменяются (чаще всего они увеличиваются на число вставляемых значений). Функция возвращает новый размер массива. Вот пример ее применения:
$A=array(10,"a"=>20,30);
array_unshift($A,"!","?");
// теперь $A===array(0=>"!", 1=>"?", 2=>10, a=>20, 3=>30)
mixed array_shift(list &$Arr)
Функция mixed array_shift извлекает первый элемент массива $Arr и возвращает его. Она сильно напоминает array_pop(), но только получает начальный, а не конечный элемент, а также производит довольно сильную "встряску" всего массива: ведь при извлечении первого элемента приходится корректировать все числовые индексы у всех оставшихся элементов…
array_unique(array $Arr)
Функция array_unique() возвращает массив, составленный из всех уникальных значений массива $Arr вместе с их ключами. В результирующий массив помещаются первые встретившиеся пары ключ=>значение:
$input=array("a" => "green", "red", "b" => "green", "blue", "red");
$result=array_unique($input);
// теперь $result===array("a"=>"green", "red", "blue");
array_splice(array &$Arr, int $offset [, int $len] [, int $Repl])
Функция array_splice, также как и array_slice(), возвращает подмассив $Arr, начиная с индекса $offset максимальной длины $len, но, вместе с тем, она делает и другое полезное действие. А именно, она заменяет только что указанные элементы на то, что находится в массиве $Repl (или просто удаляет, если $Repl не указан). Параметры $offset и $len задаются так же, как и в функции substr() — а именно, они могут быть и отрицательными, в этом случае отсчет начинается от конца массива. Вот некоторые примеры:
<?php
$input=array("red", "green", "blue", "yellow");
array_splice($input,2);
// Теперь $input===array("red", "green")
array_splice($input,1,-1);
// Теперь $input===array("red", "yellow")
array_splice($input, -1, 1, array("black", "maroon"));
// Теперь $input===array("red", "green", "blue", "black", "maroon")
array_splice($input, 1, count($input), "orange");
// Теперь $input===array("red", "orange")
?>
Последний пример показывает, что в качестве параметра $Repl мы можем указать и обычное, строковое значение, а не массив из одного элемента.
Переменные и массивы
compact(mixed $vn1 [, mixed $vn2, …])
Функция compact() упаковывает в массив переменные из текущего контекста (глобального или контекста функции), заданные своими именами в $vn1, $vn2 и т. д. При этом в массиве образуются пары с ключами, равными содержимому $vnN, и значениями соответствующих переменных. Вот пример использования этой функции:
$a="Test string";
$b="Some text";
$A=compact("a","b");
// теперь $A===array("a"=>"Test string", "b"=>"Some text")
Почему же тогда параметры функции обозначены как mixed? Дело в том, что они могут быть не только строками, но и списками строк. В этом случае функция последовательно перебирает все элементы этого списка, и упаковывает те переменные из текущего контекста, имена которых она встретила. Более того — эти списки могут, в свою очередь, также содержать списки строк, и т. д. Правда, последнее используется сравнительно редко, но все же вот пример:
$a="Test";
$b="Text";
$c="CCC";
$d="DDD";
$Lst=array("b",array("c","d"));
$A=compact("a",$Lst);
// теперь $A===array("a"=>"Test", "b"=>"Text", "c"=>"CCC", "d"=>"DDD")
extract(array $Arr [, int $type] [, string $prefix])
Функция extract() производит действия, прямо противоположные compact(). А именно, она получает в параметрах массив $Arr и превращает каждую его пару ключ=>значение в переменную текущего контекста.
Создание списка – диапазона чисел
range(int $low, int $high)
Эта функция очень простая. Она создает список, заполненный целыми числами от $low до $high включительно.
Счетчик элементов массива
Для подсчета элементов массива предназначена функция count().
Пример использования функции count():
<?php
$arr[]=5;
$arr[]=4;
$arr[]=8;
$arr[]=3;
$arr[]=8;
echo "<h2>Число элементов массива: ".count($arr)."</h2>";
// Выводит: Число элементов массива: 5
?>
Удаление массива и его элементов
Если вы хотите удалить массив целиком, воспользуйтесь функцией unset().
Если вы хотите удалить пару ключ/значение, вы также можете использовать функцию unset(). Приведем конкретные примеры:
<?php
$arr = array(5 => 1, 12 => 2);
$arr[] = 56; // В этом месте скрипта это
// эквивалентно $arr[13] = 56;
$arr["x"] = 42; // Это добавляет к массиву новый
// элемент с ключом "x"
unset($arr[5]); // Это удаляет элемент из массива
unset($arr); // Это удаляет массив полностью
?>
Некоторые особенности работы с массивами
Преобразование в массив (тип array)
Для любого из типов: integer, float</a>, string, boolean и resource, если вы преобразуете значение в массив, вы получите массив с одним элементом (с индексом 0), являющимся скалярным значением, с которого вы начали.
Если вы преобразуете в массив объект (object), вы получите в качестве элементов массива свойства (переменные-члены) этого объекта. Ключами будут имена переменных-членов.
Если вы преобразуете в массив значение NULL, вы получите пустой массив.
Сравнение массивов
Массивы можно сравнивать при помощи функции array_diff() и операторов массивов:
Операторы, работающие с массивами:
| Пример | Название | Результат |
|---|---|---|
| $a + $b | Объединение | Объединение массива $a и массива $b. |
| $a == $b | Равно | TRUEв случае, если $a и $b содержат одни и те же элементы. |
| $a === $b | Тождественно равно | TRUE в случае, если $a и $b содержат одни и те же элементы в том же самом порядке. |
| $a != $b | Не равно | TRUE если массив $a не равен массиву $b. |
| $a <> $b | Не равно | TRUE если массив $a не равен массиву $b. |
| $a !== $b | Тождественно не равно | TRUE если массив $a не равен тождественно массиву $b. |
Пример сравнения массивов:
<?php
$a = array("apple", "banana");
$b = array(1 => "banana", "0" => "apple");
var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>
Некоторые полезные практические примеры по работе с массивами
<?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')
?>
Еще один практический пример:
<?php
// Массив как карта (свойств)
$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();
?>
Коллекция:
<?php
$colors = array('красный', 'синий', 'зеленый', 'желтый');
foreach ($colors as $color) {
echo "Вам нравится $color?\n";
}
?>
Результат работы рассмотренного скрипта:
Вам нравится красный? Вам нравится синий? Вам нравится зеленый? Вам нравится желтый?
Следующий пример создает начинающийся с единицы массив:
<?php
$firstquarter = array(1 => 'Январь', 'Февраль', 'Март');
print_r($firstquarter);
?>
Результат работы приведенного скрипта будет следующий:
Array
(
[1] => 'Январь'
[2] => 'Февраль'
[3] => 'Март'
) |
Пример заполнения массива:
<?php
// заполняет массив всеми элементами директории
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
$files[] = $file;
}
closedir($handle);
?>
Массивы упорядочены. Вы можете изменять порядок элементов, используя различные функции сортировки. Для дополнительной информации смотрите раздел <a href="/learnphp/datatypes/?array3" target="_blank">функции для работы с массивами</a>. Вы можете подсчитать количество элементов в массиве, используя функцию <a href="/functions/?count" target="_blank">count()</a>.
Рекурсивные и многомерные массивы:
<?php
$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
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 изменился,
// $arr1 по прежнему array(2,3)
$arr3 = &$arr1;
$arr3[] = 4; // теперь $arr1 и $arr3 эквивалентны
?>
