Робота з асоціативними масивами в 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>

<a name="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"

Вставка и удаление элементов массивов

Мы уже знаем несколько операторов, которые отвечают за вставку и удаление элементов. Например, оператор [] (пустые квадратные скобки) добавляет элемент в конец массива, присваивая ему числовой ключ, а оператор <a href="/functions/?unset" target="_blank">Unset()</a> вместе с извлечением по ключу удаляет нужный элемент. Язык PHP поддерживает и многие другие функции, которые иногда бывает удобно использовать.

<a name="array_push"></a>array_push(alist &$Arr, mixed $var1 [, mixed $var2, …])

Эта функция добавляет к списку $Arr элементы $var1, $var2 и т. д. Она присваивает им числовые индексы — точно так же, как это происходит для стандарных []. Если вам нужно добавить всего один элемент, наверное, проще и будет воспользоваться этим оператором:

array_push($Arr,1000); // вызываем функцию…
$Arr[]=100; // то же самое, но короче

Обратите внимание, что функция <a href="/functions/?array_push" target="_blank">array_push()</a> воспринимает массив, как стек, и добавляет элементы всегда в его конец. Она возвращает новое число элементов в массиве.

<a name="array_pop"></a>array_pop(list &$Arr)

Функция <a href="/functions/?array_pop" target="_blank">array_pop()</a>, является противоположностью <a href="#array_push">array_push()</a>, снимает элемент с "вершины" стека (то есть берет последний элемент списка) и возвращает его, удалив после этого его из $Arr. С помощью этой функции мы можем строить конструкции, напоминающие стек. Если список $Arr был пуст, функция возвращает пустую строку.

array_unshift(list &$Arr, mixed $var1 [, mixed $var2, …])

Функция <a href="/functions/?array_unshift" target="_blank">array_unshift</a> очень похожа на <a href="#array_push">array_push()</a>, но добавляет перечисленные элементы не в конец, а в начало массива. При этом порядок следования $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)

Функция <a href="/functions/?mixed%20array_shift" target="_blank">mixed array_shift</a> извлекает первый элемент массива $Arr и возвращает его. Она сильно напоминает <a href="#array_pop">array_pop()</a>, но только получает начальный, а не конечный элемент, а также производит довольно сильную "встряску" всего массива: ведь при извлечении первого элемента приходится корректировать все числовые индексы у всех оставшихся элементов…

array_unique(array $Arr)

Функция <a href="/functions/?array_unique" target="_blank">array_unique()</a> возвращает массив, составленный из всех уникальных значений массива $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])

Функция <a href="/functions/?array_splice" target="_blank">array_splice</a>, также как и <a href="#array_slice">array_slice()</a>, возвращает подмассив $Arr, начиная с индекса $offset максимальной длины $len, но, вместе с тем, она делает и другое полезное действие. А именно, она заменяет только что указанные элементы на то, что находится в массиве $Repl (или просто удаляет, если $Repl не указан). Параметры $offset и $len задаются так же, как и в функции <a href="/functions/?substr" target="_blank">substr()</a> — а именно, они могут быть и отрицательными, в этом случае отсчет начинается от конца массива. Вот некоторые примеры:

<?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 мы можем указать и обычное, строковое значение, а не массив из одного элемента.

Переменные и массивы

<a name="compact"></a>compact(mixed $vn1 [, mixed $vn2, …])

Функция <a href="/function/?compact" target="_blank">compact()</a> упаковывает в массив переменные из текущего контекста (глобального или контекста функции), заданные своими именами в $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])

Функция <a href="/functions/?extract" target="_blank">extract()</a> производит действия, прямо противоположные <a href="#compact">compact()</a>. А именно, она получает в параметрах массив $Arr и превращает каждую его пару ключ=>значение в переменную текущего контекста.

Создание списка – диапазона чисел

range(int $low, int $high)

Эта функция очень простая. Она создает список, заполненный целыми числами от $low до $high включительно.

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

Для подсчета элементов массива предназначена функция <a href="/functions/?count" target="_blank">count()</a>.

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

<?php
$arr[]=5;
$arr[]=4;
$arr[]=8;
$arr[]=3;
$arr[]=8;
echo "<h2>Число элементов массива: ".count($arr)."</h2>";
// Выводит: Число элементов массива: 5
?>

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

Если вы хотите удалить массив целиком, воспользуйтесь функцией <a href="/functions/?unset" target="_blank">unset()</a>.

Если вы хотите удалить пару ключ/значение, вы также можете использовать функцию unset(). Приведем конкретные примеры:

<?php
$arr = array(5 => 1, 12 => 2);

$arr[] = 56;    // В этом месте скрипта это
                 // эквивалентно $arr[13] = 56;

$arr["x"] = 42; // Это добавляет к массиву новый
                 // элемент с ключом "x"
                
unset($arr[5]); // Это удаляет элемент из массива

unset($arr);    // Это удаляет массив полностью
?>