Как вывести многомерный массив php. Массивы в примерах. Цикл по значениям элементов
$arr
[
1
] =
"PHP"
;
$arr
[
2
] =
"MySQL"
;
$arr
[
3
] =
"Apache"
;
?>
Элементы массива можно использовать в двойных кавычках как обычные переменные, так код
echo
"$arr $arr $arr"
;
?>
$arr
[
"first"
] =
"PHP"
;
$arr
[
"second"
] =
"MySQL"
;
$arr
[
"third"
] =
"Apache"
;
?>
В этом случае массив называется ассоциативным , а его индексы называются ключами . Для вывода элемента массива в строке кавычки (ни двойные, ни одинарные) указывать не следует:
echo
"$arr $arr $arr"
;
?>
Так как у ассоциативных массивов нет индексов, для обхода их введён специальный вид цикла - foreach :
foreach($arr
as
$key
=>
$value
)
{
echo
"$key =
$value
"
;
}
?>
В результате работы цикла будет выведено три строки
first = PHP
second = MySQL
third = Apache
Конструкция "$key =>", позволяющая получить доступ к ключу массива на каждом из циклов является не обязательно и может быть опущена:
foreach($arr
as
$value
)
{
echo
"$value
"
;
}
?>
Ряд функций, также позволяют возвращать массивы, например, функция file() , которая читает файл и возвращает его содержимое в виде массива. Каждый элемент массива соответствует одной строке.
$arr
=
file
("text.txt"
);
for($i
=
0
;
$i
<
count
($arr
);
$i
++)
{
echo
$arr
[
$i
].
"
"
;
}
?>
Другой полезной функцией является функция explode() , которая позволяет разбить строку на несколько фрагментов, каждый из которых помещается в отдельный элемент массива:
$str
=
"345|[email protected]|http://www.softtime.ru|login|password"
;
$arr
=
explode
("|"
,
$str
);
for($i
=
0
;
$i
<
count
($arr
);
$i
++)
{
echo
$arr
[
$i
].
"
"
;
}
?>
Результат работы скрипта может выглядеть следующим образом:
345
[email protected]
http://www.softtime.ru
login
password
Существует и обратная функция - implode(), которая объединяет, элементы массива в строку, используя для этого заданный разделитель:
$arr
=
"345"
;
$arr
=
"[email protected]"
;
$arr
=
"http://www.softtime.ru"
;
$arr
=
"login"
;
$arr
=
"password"
;
$str
=
implode
("##"
,
$arr
);
echo
$str
;
//345##[email protected]##http://www.softtime.ru##login##password
?>
Замечание
Вообще функций, которые потрошат строку превеликое множество, рассмотрение всех их выходят за рамки данной статьи.
Удалить отдельный элемент массива можно при помощи функции unset() , а проверить существование массива можно при помощи функции isset() . Определим массив из 10 элементов и уничтожим каждый чётный элемент.
unset($arr
[
0
],
$arr
[
2
],
$arr
[
4
],
$arr
[
6
],
$arr
[
8
]);
// Проверяем существуют ли элементы массива
for($i
=
0
;
$i
<
10
;
$i
++)
{
if(isset($arr
[
$i
])) echo
"Элемент $arr[$i] определён
"
;
else echo
"Элемент $arr[$i] не определён
"
;
}
?>
Результатом работы скрипта из будут следующие строки
Элемент $arr не определён
Элемент $arr определён
Элемент $arr не определён
Элемент
$arr определён
Элемент $arr не определён
Элемент $arr
определён
Элемент $arr не определён
Элемент $arr определён
Элемент $arr не определён
Элемент $arr определён
При помощи функции unset() можно уничтожить весть массив сразу.
$arr
= array(9
,
8
,
7
,
6
,
5
,
4
,
3
,
2
,
1
,
0
);
unset($arr
);
if(isset($arr
)) echo
"Массив определён"
;
else echo
"Массив не
определён"
;
?>
До этого массивы выводились при помощи цикла, однако в PHP предусмотрена специальная функция для вывода дампа массива print_r() . Функция ориентирована на вывод в консольный поток, поэтому при выводе результатов в окно браузера лучше обрамить её тэгами
И:
$arr = "345";
$arr =
"[email protected]";
$arr = "http://www.softtime.ru";
$arr =
"login";
$arr = "password";
echo "
";";
print_r($arr);
echo "
?>
Результат работы скрипта выглядит следующим образом:
Array
=> 345
=> [email protected]
=>
http://www.softtime.ru
=> login
=> password
)
Многомерные массивы
В качестве элементов массива могут выступать не только скалярные величины, но и сами массивы. В этом случае получаются так называемые многомерные массивы.
Пусть необходимо получить такую таблицу:
Для этого создадим двумерный массив:
$arr
= array(array(‘Вася’
,
‘слесарь’
,
2500
),
array(‘Миша’
,
’строитель’
,
3000
),
array(‘Андрей’
,
‘шофер’
,
2700
));
?>
Теперь таблицу можно вывести при помощи следующего кода:
for ($i
=
0
;
$i
<
3
;
$i
++)
{
for
($j
=
0
;
$j
<
3
;
$j
++)
{
echo
" | "
.
$arr
[
$i
][
$j
];
}
echo
"
"
;
}
?>
Результат:
| Вася | слесарь | 2500
|
Миша | строитель | 3000
| Андрей | шофер | 2700
Также можно использовать трехмерные, четырехмерные и т.п. массивы.
Операции над массивами (сборник рецептов)
1) Определения числа элементов в массиве count() :
Создадим массив $name:
?>
Чтобы определить число элементов в массиве можно поступить следующим образом:
echo
‘Число элементов в массиве
-
’
.
count
($name
);
?>
Результат:
Число элементов в массиве – 8
2) Объединение массивов
a) Создадим два ассоциативных массива $a и $b:
$a
= array(“a”
=>
”aa”
,
“b”
=>
“bb”
);
$b
=
array(“c”
=>
”cc”
,
“d”
=>
“dd”
);
?>
Пусть необходимо создать массив $c, которые будет содержать как элементы массива $a так и массива $b:
$a
= array("a"
=>
"aa"
,
"x"
=>
"xx"
);
$b
=
array("c"
=>
"cc"
,
"d"
=>
"dd"
);
$c
=
$a
+
$b
;
echo
"
" ;" ;
print_r ($c );
echo "
?>
Результат:
Array
[a] => aa
[x]
=> xx
[c] => cc
[d] => dd
)
b) Создадим два числовых массива $a и $b:
$a
= array(10
,
20
);
$b
= array(100
,
200
,
300
,
400
,
500
);
?>
Их уже не получится объединить при помощи конструкции $c = $a + $b;. Для их объединения потребуется воспользоваться функцией array_merge() :
$c
=
array_merge
($a
,
$b
);
?>
3) Сортировка массива
Воспользуемся массивом $name:
$name
= array("Boss"
,
"Lentin"
,
"NAV"
,
"Endless"
,
"Dragons"
,
"SiLeNT"
,
"Doctor"
,
"Lynx"
);
?>
Пусть требуется отсортировать массив в алфавитном порядке, для этого можно воспользоваться следующим кодом:
sort
($name
);
echo
"
" ;" ;
print_r ($name );
echo "
?>
Результат:
Array
=> Boss
=> Doctor
=> Dragons
=> Endless
=> Lentin
=> Lynx
=> NAV
=> SiLeNT
)
Пусть необходимо из массива $name выбрать самый короткий элемент(у которого наименьшее количество символов), в этом случае можно воспользоваться кодом:
$name
= array("Boss"
,
"Lentin"
,
"NAV"
,
"Endless"
,
"Dragons"
,
"SiLeNT"
,
"Doctor"
,
"Lynx"
);
$min
=
strlen
($name
[
0
]);
$nam
=
$name
[
0
];
for ($i
=
1
;
$i
<
count
($name
);
$i
++)
{
$len
=
strlen
($name
[
$i
]);
if ($len
<
$min
)
{
$nam
=
$name
[
$i
];
$min
=
strlen
($nam
);
}
}
echo
"Наименьшая длина -
"
.
$nam
;
?>
4) Перемещение внутри массива
Создадим массив $num:
?>
Пусть требуется отобразить элементы массива в обратном порядке, в этом случае можно воспользоваться кодом:
$end
=
end
($num
);
While
($end
)
{
echo
$end
.
"
- "
;
$end
=
prev
($num
);
}
?>
Результат:
10 - 9 - 8 - 7 - 6 - 5 - 4 - 3 - 2 – 1
Приведённый выше код можно модифицировать:
$num
=
range
(1
,
10
);
print_r
(array_reverse
($num
));
?>
Функция range(1,10) создает массив (1,2,3,4,5,6,7,8,9,10) со случайным расположением элементов. Функция array_reverse() принимает массив и располагает элементы в обратном порядке (10,9,8,7,6,5,4,3,2,1)
Функции next() , each() перемещают указатель на один элемент вперед. Функция reset() возвращает указатель на 1 элемент в массиве. Воспользуемся массивом $num:
$num
= array(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 "
$arr
[
1
] =
"PHP"
;
$arr
[
2
] =
"MySQL"
;
$arr
[
3
] =
"Apache"
;
?>
Элементы массива можно использовать в двойных кавычках как обычные переменные, так код
echo
"
$arr
[
1
]
$arr
[
2
]
$arr
[
3
]
"
;
?>
$arr
[
"first"
] =
"PHP"
;
$arr
[
"second"
] =
"MySQL"
;
$arr
[
"third"
] =
"Apache"
;
?>
В этом случае массив называется ассоциативным , а его индексы называются ключами . Для вывода элемента массива в строке кавычки (ни двойные, ни одинарные) указывать не следует:
echo
"
$arr
[
first
]
$arr
[
second
]
$arr
[
third
]
"
;
?>
Так как у ассоциативных массивов нет индексов, для обхода их введён специальный вид цикла - foreach :
foreach($arr
as
$key
=>
$value
)
{
echo
"
$key
=
$value
"
;
}
?>
В результате работы цикла будет выведено три строки
First = PHP
second = MySQL
third = Apache
Конструкция "$key =>", позволяющая получить доступ к ключу массива на каждом из циклов является не обязательно и может быть опущена:
foreach($arr
as
$value
)
{
echo
"
$value
"
;
}
?>
Ряд функций, также позволяют возвращать массивы, например, функция file() , которая читает файл и возвращает его содержимое в виде массива. Каждый элемент массива соответствует одной строке.
$arr
=
file
("text.txt"
);
for($i
=
0
;
$i
<
count
($arr
);
$i
++)
{
echo
$arr
[
$i
].
"
"
;
}
?>
Другой полезной функцией является функция explode() , которая позволяет разбить строку на несколько фрагментов, каждый из которых помещается в отдельный элемент массива:
$str
=
"345|[email protected]|http://www.сайт|login|password"
;
$arr
=
explode
("|"
,
$str
);
for($i
=
0
;
$i
<
count
($arr
);
$i
++)
{
echo
$arr
[
$i
].
"
"
;
}
?>
Результат работы скрипта может выглядеть следующим образом:
345
[email protected]
http://www.сайт
login
password
Существует и обратная функция - implode(), которая объединяет, элементы массива в строку, используя для этого заданный разделитель:
$arr
=
"345"
;
$arr
=
"[email protected]"
;
$arr
=
"http://www.сайт"
;
$arr
=
"login"
;
$arr
=
"password"
;
$str
=
implode
("##"
,
$arr
);
echo
$str
;
//345##[email protected]##http://www.
?>
Замечание
Вообще функций, которые потрошат строку превеликое множество, рассмотрение всех их выходят за рамки данной статьи.
Удалить отдельный элемент массива можно при помощи функции unset() , а проверить существование массива можно при помощи функции isset() . Определим массив из 10 элементов и уничтожим каждый чётный элемент.
unset($arr
[
0
],
$arr
[
2
],
$arr
[
4
],
$arr
[
6
],
$arr
[
8
]);
// Проверяем существуют ли элементы массива
for($i
=
0
;
$i
<
10
;
$i
++)
{
if(isset($arr
[
$i
])) echo
"Элемент
$arr
[
$i
]
определён
"
;
else echo
"Элемент
$arr
[
$i
]
не определён
"
;
}
?>
Результатом работы скрипта из будут следующие строки
Элемент $arr не определён
Элемент $arr определён
Элемент $arr не определён
Элемент $arr определён
Элемент $arr не определён
Элемент $arr определён
Элемент $arr не определён
Элемент $arr определён
Элемент $arr не определён
Элемент $arr определён
При помощи функции unset() можно уничтожить весть массив сразу.
$arr
= array(9
,
8
,
7
,
6
,
5
,
4
,
3
,
2
,
1
,
0
);
unset($arr
);
if(isset($arr
)) echo
"Массив определён"
;
else echo
"Массив не определён"
;
?>
До этого массивы выводились при помощи цикла, однако в PHP предусмотрена специальная функция для вывода дампа массива print_r() . Функция ориентирована на вывод в консольный поток, поэтому при выводе результатов в окно браузера лучше обрамить её тэгами
И:
$arr = "345";
$arr = "[email protected]";
$arr = "http://www.сайт";
$arr = "login";
$arr = "password";
echo "
print_r($arr);
echo " ";
?>
Результат работы скрипта выглядит следующим образом:
Array
=> 345
=> [email protected]
=> http://www.сайт
=> login
=> password
)
Многомерные массивы
В качестве элементов массива могут выступать не только скалярные величины, но и сами массивы. В этом случае получаются так называемые многомерные массивы.
Пусть необходимо получить такую таблицу:
Для этого создадим двумерный массив:
$arr
= array(array(‘Вася’
,
‘слесарь’
,
2500
),
array(‘Миша’
,
’строитель’
,
3000
),
array(‘Андрей’
,
‘шофер’
,
2700
));
?>
Теперь таблицу можно вывести при помощи следующего кода:
for ($i
=
0
;
$i
<
3
;
$i
++)
{
for ($j
=
0
;
$j
<
3
;
$j
++)
{
echo
" | "
.
$arr
[
$i
][
$j
];
}
echo
"
"
;
}
?>
Результат:
| Вася | слесарь | 2500
| Миша | строитель | 3000
| Андрей | шофер | 2700
Также можно использовать трехмерные, четырехмерные и т.п. массивы.
Операции над массивами (сборник рецептов)
1) Определения числа элементов в массиве count() :
Создадим массив $name:
?>
Чтобы определить число элементов в массиве можно поступить следующим образом:
echo
‘Число элементов в массиве
-
’
.
count
($name
);
?>
Результат:
Число элементов в массиве – 8
2) Объединение массивов
a) Создадим два ассоциативных массива $a и $b:
$a
= array(“a”
=>
”aa”
,
“b”
=>
“bb”
);
$b
= array(“c”
=>
”cc”
,
“d”
=>
“dd”
);
?>
Пусть необходимо создать массив $c, которые будет содержать как элементы массива $a так и массива $b:
$a
= array("a"
=>
"aa"
,
"x"
=>
"xx"
);
$b
= array("c"
=>
"cc"
,
"d"
=>
"dd"
);
$c
=
$a
+
$b
;
echo
"
" ;" ;
print_r ($c );
echo "
?>
Результат:
Array
[a] => aa
[x] => xx
[c] => cc
[d] => dd
)
b) Создадим два числовых массива $a и $b:
$a
= array(10
,
20
);
$b
= array(100
,
200
,
300
,
400
,
500
);
?>
Их уже не получится объединить при помощи конструкции $c = $a + $b;. Для их объединения потребуется воспользоваться функцией array_merge() :
$c
=
array_merge
($a
,
$b
);
?>
3) Сортировка массива
Воспользуемся массивом $name:
$name
= array("Boss"
,
"Lentin"
,
"NAV"
,
"Endless"
,
"Dragons"
,
"SiLeNT"
,
"Doctor"
,
"Lynx"
);
?>
Пусть требуется отсортировать массив в алфавитном порядке, для этого можно воспользоваться следующим кодом:
sort
($name
);
echo
"
" ;" ;
print_r ($name );
echo "
?>
Результат:
Array
=> Boss
=> Doctor
=> Dragons
=> Endless
=> Lentin
=> Lynx
=> NAV
=> SiLeNT
)
Пусть необходимо из массива $name выбрать самый короткий элемент(у которого наименьшее количество символов), в этом случае можно воспользоваться кодом:
$name
= array("Boss"
,
"Lentin"
,
"NAV"
,
"Endless"
,
"Dragons"
,
"SiLeNT"
,
"Doctor"
,
"Lynx"
);
$min
=
strlen
($name
[
0
]);
$nam
=
$name
[
0
];
for ($i
=
1
;
$i
<
count
($name
);
$i
++)
{
$len
=
strlen
($name
[
$i
]);
if ($len
<
$min
)
{
$nam
=
$name
[
$i
];
$min
=
strlen
($nam
);
}
}
echo
"Наименьшая длина - "
.
$nam
;
?>
4) Перемещение внутри массива
Создадим массив $num:
$num
= array(1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
);
?>
Пусть требуется отобразить элементы массива в обратном порядке, в этом случае можно воспользоваться кодом:
$end
=
end
($num
);
While ($end
)
{
echo
$end
.
" - "
;
$end
=
prev
($num
);
}
?>
Результат:
10 - 9 - 8 - 7 - 6 - 5 - 4 - 3 - 2 – 1
Приведённый выше код можно модифицировать:
$num
=
range
(1
,
10
);
print_r
(array_reverse
($num
));
?>
Функция range(1,10) создает массив (1,2,3,4,5,6,7,8,9,10) со случайным расположением элементов. Функция array_reverse() принимает массив и располагает элементы в обратном порядке (10,9,8,7,6,5,4,3,2,1)
Функции next() , each() перемещают указатель на один элемент вперед. Функция reset() возвращает указатель на 1 элемент в массиве. Воспользуемся массивом $num.
Массив не обязательно должен представлять из себя простой список ключей и простых значений. Каждый элемент массива может содержать в качестве значения другой массив, который в свою очередь может тоже содержать массив и так далее. Таким образом можно создавать двумерные и трехмерные массивы.
Двумерные массивы
Двумерный массив - массив, который в качестве значений хранит в себе другие массивы. Рассмотрим создание двумерного массива с помощью конструктора array() :
$flowers = array(array("розы", 100 , 15), array("тюльпаны", 60 , 25), array("орхидеи", 180 , 7));
Массив $flowers содержит три массива. Как вы помните, для доступа к элементам одномерного массива надо указывать имя массива и ключ. То же самое верно и в отношении двумерных массивов, с одним исключением: каждый элемент имеет два ключа: первый для выбора строки, второй для выбора столбца.
Чтобы вывести элементы этого массива можно вручную прописать доступ к каждому из них, но лучше воспользоваться вложенными циклами:
Ручной доступ к элементам
";
echo $flowers." цена ".$flowers." количество ".$flowers."
";
echo $flowers." цена ".$flowers." количество ".$flowers."
";
echo "
Использование циклов для вывода элементов
"; echo "- ";
for ($row = 0; $row < 3; $row++) {
echo "
- Номер строки $row";
echo "
- ";
for ($col = 0; $col < 3; $col++) {
echo "
- ".$flowers[$row][$col]." "; } echo "
";
}
echo "
Вместо номеров столбцов (индексы, присвоенные им по умолчанию) можно задавать им нужные ключи. Для этой цели используются ассоциативные массивы. Следующий массив будет хранить те же данные, но уже с использованием ключей для именования столбцов с информацией:
$flowers = array(array("Название" => "розы", "Цена" => 100, "Количество" => 15), array("Название" => "тюльпаны", "Цена" => 60, "Количество" => 25,), array("Название" => "орхидеи", "Цена" => 180, "Количество" => 7));
Ключи создают дополнительное удобство для работы с массивом в тех случаях, когда нужно получить одно из значений. Необходимые данные можно легко найти, если обратиться к правильной ячейке, используя значимые имена строки и столбца. Однако при этом мы теряем возможность последовательно обхода массива с помощью цикла for .
Мы можем перебрать с помощью цикла for только дочерние массивы. Так как они, в свою очередь, являются ассоциативными, то для перебора их элементов нужно воспользоваться циклом foreach , или перебрать элементы вручную:
"розы", "Цена" => 100, "Количество" => 15), array("Название" => "тюльпаны", "Цена" => 60, "Количество" => 25,), array("Название" => "орхидеи", "Цена" => 180, "Количество" => 7)); echo "
Ручной доступ к элементам ассоциативного массива
"; for ($row = 0; $row < 3; $row++) { echo $flowers[$row]["Название"]." цена ".$flowers[$row]["Цена"] ." количество ".$flowers[$row]["Количество"]; echo ""; } echo "
Использование цикла foreach для доступа к элементам
"; echo "- ";
for ($row = 0; $row < 3; $row++) {
echo "
- Номер строки $row";
echo "
- ";
foreach($flowers[$row] as $key => $value) {
echo "
- ".$value." "; } echo "
";
}
echo "
Необязательно использовать для создания двумерного массива конструктор array() , можно воспользоваться и коротким синтаксисом - квадратными скобками:
$flowers = [ [ "Название" => "розы", "Цена" => 100, "Количество" => 15 ], [ "Название" => "тюльпаны", "Цена" => 60, "Количество" => 25, ], [ "Название" => "орхидеи", "Цена" => 180, "Количество" => 7 ] ];
Трёхмерные массивы
Не обязательно ограничиваться только двумя измерениями: так же, как элементы массива могут содержать массивы, эти массивы, в свою очередь, могут содержать новые массивы.
Трёхмерный массив характеризует ширину, высоту и глубину. Если представлять двумерный массив в виде таблицы, то трёхмерный добавляет к этой таблице слои. Каждый элемент такого массива будет ссылаться на слой, строку и столбец.
Если немного модифицировать наш массив с цветами, то можно переделать его в трёхмерный. В коде, представленном ниже видно, что трёхмерный массив - массив, содержащий массив массивов:
$flowers = [ [ ["розы", 100 , 15], ["тюльпаны", 60 , 25], ["орхидеи", 180 , 7] ], [ ["розы", 100 , 15], ["тюльпаны", 60 , 25], ["орхидеи", 180 , 7], ], [ ["розы", 100 , 15], ["тюльпаны", 60 , 25], ["орхидеи", 180 , 7] ] ];
Поскольку этот массив содержит только числовые индексы, мы можем использовать для его отображения вложенные циклы:
"; for ($layer = 0; $layer < 3; $layer++) { echo "
- ";
for ($row = 0; $row < 3; $row++)
{
echo "
- Номер строки $row";
echo "
- ";
for ($col = 0; $col < 3; $col++)
{
echo "
- ".$flowers[$layer][$row][$col]." "; } echo "
";
}
echo "
Массив представляет собой совокупность объектов, имеющих одинаковые размер и тип. Каждый объект в массиве называется элементом массива. Создать новый массив в PHP несложно. При объявлении индексируемого массива после имени переменной ставится пара квадратных скобок ():
$languages = "Spanish";
// $languages = "Spanish"
После этого в массив можно добавлять новые элементы, как показано ниже. Обратите внимание: новые элементы добавляются без явного указания индекса. В этом случае новый элемент добавляется в позицию, равную длине массива плюс 1:
$languages = "English"; // $1anguages[l] = "English";
$languagest ] = "Gaelic"; // $languages = "Gaelic";
Кроме того, новые элементы можно добавлять в конкретную позицию массива. Для этого указывается индекс нрвого элемента:
$languages = "Italian";
$languages = "French";
Ассоциативные массивы создаются аналогичным образом:
$languages["Spain"] = "Spanish";
$languages["France"] = "French";
При создании массивов используются три стандартные языковые конструкции:
- аrrау();
- list();
- range().
Хотя все три случая приводят к одному результату -- созданию массива, в некоторых случаях одна конструкция может оказаться предпочтительнее других. Далее приведены описания и примеры использования каждой конструкции.
Функция array() получает ноль или более элементов и возвращает массив, состоящий из указанных элементов. Ее синтаксис:
array array ([элемент1, элемент2...])
Вероятно, array() является всего лишь более наглядной записью для создания массива, используемой для удобства программиста. Ниже показан пример использования array() для создания индексируемого массива:
$languages = array ("English". "Gaelic". "Spanish");
// $languages = "English". $languages = "Gaelic",
// $languages = "Spanish"
А вот как array() используется при создании ассоциативных массивов:
$languages = array("Spain" => "Spanish",
"Ireland" => "Gaelic".
"United States" => "English");
// $languages["Spain"] = "Spanish"
// $languages["Ireland"] = "Gaelic"
// $languages["United States"] = "English"
Ассоциативные массивы особенно удобны в тех ситуациях, когда числовые индексы не имеют логического соответствия. Например, в предыдущем примере названия стран вполне естественно ассоциируются с языками. Попробуйте-ка воплотить эту логическую связь при помощи цифр!
Конструкция list() похожа на аrrау(), однако ее главная задача -- одновременное присваивание значений, извлеченных из массива, сразу нескольким переменным. Синтаксис команды list():
void list (переменная1 [. переменная2 , ...])
Конструкция list() особенно удобна при чтении информации из базы данных или файла. Допустим, вы хотите отформатировать и вывести данные, прочитанные из текстового файла. Каждая строка файла содержит сведения о пользователе (имя,
профессия и любимый цвет); компоненты записи разделяются вертикальной чертой (|). Типичная строка выглядит так:
Nino Sanzi|Professional Golfer|green
При помощи list () можно написать простой цикл, который будет читать каждую строку, присваивать ее компоненты переменным, форматировать и отображать данные. Приведенный ниже листинг демонстрирует возможность одновременного присваивания нескольким переменным с использованием list ():
while ($line = fgets ($user_file. 4096)) :
// Разделить строку функцией split().
// Компоненты присваиваются переменным Sname. $occupation и Scolor.
list ($name, $occupation, $color) = split("|", $line);
// Отформатировать и вывести данные
print "Name: Sname
";
print "Occupation:
Soccupation
";
print "Favorite
color: Scolor
";
Каждая строка файла читается, форматируется и выводится в следующем виде:
Name: Nino Sanzi
Occupation: Professional Golfer
Favorite color: green
В приведенном примере применение list() зависит от разделения строки на элементы функцией split(). Элементы, полученные в результате деления, присваиваются, соответственно, переменным $name, $occupation и $color. Дальше все сводится к форматированию данных для вывода в конкретном браузере. Удобные средства лексического анализа текстовых файлов являются одной из сильных сторон PHP. Эта тема подробно рассматривается в главах 7 и 8.
Конструкция range() позволяет легко и быстро создать массив целых чисел из интервала, определяемого верхней и нижней границами. Range() возвращает массив, состоящий из всех целых чисел указанного интервала. Синтаксис range():
array range (int нижняя_граница, int верхняяграница)
Следующий пример наглядно показывает, насколько удобна эта конструкция:
$lottery = range(0,9);
// $lottery = array(0,1,2,3,4,5,6,7,8,9)
Как видно из приведенного фрагмента, в параметрах range() был указан интервал от 0 до 9 и массив $lottery был заполнен целыми числами из этого интервала.
Многомерные массивы
Со временем ваши программы станут более сложными, и возможностей простых одномерных массивов окажется недостаточно для хранения необходимой информации. Многомерный массив (массив массивов) предоставляет в распоряжение про граммиста более эффективные средства для хранения информации, требующей дополнительного структурирования. Создать многомерный массив несложно -- просто добавьте дополнительную пару квадратных скобок, чтобы вывести массив в новое измерение:
$chessboard = "King"; // Двухмерный массив
$capitals["USA"] ["Ohio"] = "Columbus": // Двухмерный массив
$streets["USA"]["Ohio"]["Columbus"] = "Harrison"; // Трехмерный массив
В качестве примера рассмотрим массив, в котором хранится информация о десертах и особенностях их приготовления. Обойтись одномерным массивом было бы довольно трудно, но двухмерный массив подходит как нельзя лучше:
$desserts = аrrау(
"Fruit Cup" => array (
"calories" => "low",
"served" -> "cold",
"preparation" => "10 minutes"
"Brownies" => array (
"calories" -> "high",
"served" => "piping hot",
"preparation" => "45 minutes"
После создания массива к его элементам можно обращаться по соответствующим ключам:
$desserts["Fruit Cup"]["preparation"] // возвращает "10 minutes"
$desserts["Brownies"]["calories"] // возвращает "high"
Присваивание значений элементам многомерных массивов выполняется так же, как и в одномерных массивах:
$desserts["Cake"]["calories"] = "too many";
// Присваивает свойству "calories" объекта "Cake" значение "too many"
Хотя в многомерных массивах появляются новые уровни логической организации данных, многомерные массивы создаются практически так же, как и одномерные. Впрочем, ссылки на многомерные массивы в строках требуют особого внимания; этой теме посвящен следующий раздел.
Ссылки на многомерные массивы
print "Brownies are good, but the calories content is ".
$desserts["Brownies"]["calories"];
print "Brownies are good, but the calories content is
{$desserts}";
Обратите внимание на отсутствие кавычек вокруг ключей. Также следует помнить, что между фигурными скобками и ссылкой не должно быть лишних пробелов. Если хотя бы одно из этих условий не выполняется, произойдет ошибка. Впрочем, годятся оба способа. Я рекомендую выбрать один формат и придерживаться его, чтобы ваши программы выглядели более последовательно. Если не использовать какой-либо из этих способов форматирования, ссылки на многомерные массивы будут интерпретироваться буквально, что наверняка приведет к непредвиденным результатам.
Поиск элементов массива
Поиск элементов относится к числу важнейших операций с массивами. В PHP существует несколько стандартных функций, позволяющих легко находить в массиве нужные ключи и значения.
Функция i n_array () проверяет, присутствует ли в массиве заданный элемент. Если поиск окажется удачным, функция возвращает TRUE, в противном случае возвращается FALSE. Синтаксис функции in_array():
bool in_array(mixed элемент, array массив)
Эта функция особенно удобна тем, что вам не приходится в цикле перебирать весь массив в поисках нужного элемента. В следующем примере функция in_array() ищет элемент "Russian" в массиве $languages:
$languages = array("English", "Gaelic", "Spanish"):
$exists = in_array("Russian", $languages); // $exists присваивается FALSE
$exists = in_array("English", $languages): // $exists присваивается TRUE
Функция in_array() часто встречается в управляющих конструкциях, когда ее возвращаемое значение (TRUE/FALSE) используется для выбора одного из двух вариантов продолжения. В следующем примере функция in_array() используется для выбора одного из двух вариантов в условной команде if:
// Ввод данных пользователем
$language = "French"; $email = "[email protected]";
// Если язык присутствует в массиве
if (in_array($language. $languages)) :
// Подписать пользователя на бюллетень.
// Обратите внимание: в PHP нет стандартной функции с именем
// subscribe_user(). В данном примере эта функция просто имитирует
// процесс подписки.
subscribe_user($email, $language);
print "You are now subscribed to the $language edition of the newsletter.";
// Язык отсутствует в массиве
print "We"re sorry, but we don"t yet offer a $language edition of the newsletter".
Что происходит в этом примере? Допустим, переменные $language и $email содержат данные, введенные пользователем. Вы хотите убедиться в том, что указанный язык поддерживается вашей системой, и используете для этой цели функцию in_array(). Если название языка присутствует в массиве, пользователь подписывается на бюллетень и получает соответствующее сообщение. В противном случае программа сообщает, что на указанном языке бюллетень не распространяется. Конечно, в настоящей программе пользователь не должен гадать, какие языки поддерживаются вашей программой. Задача решается при помощи раскрывающегося списка -- эта тема подробно рассматривается в главе 10. Здесь этот пример всего лишь демонстрирует возможности работы с массивами.
Функция array_keys() возвращает массив, содержащий все ключи исходного массива, переданного в качестве параметра. Если при вызове передается дополнительный параметр искомый_элемент, возвращаются только ключи, которым соответствует заданное значение; в противном случае возвращаются все ключи массива. Синтаксис функции array_keys():
array array_keys (array массив [, mixed искомый_элемент])
Рассмотрим пример использования функции array_keys() для получения ключа заданного элемента:
$great_wines = array ("Australia" => "Clarendon Hills 96",
"France" => "Comte George de Vogue 97",
"Austria" => "Feiler Artinger 97");
$great_labels = array_keys($great_wines);
// $great_labels = array("Australia", "France", "Austria");
$great_labels = array_keys($great_wines, "Clarendon Hills 96");
// $great_labels = array("Australia");
Функция array_keys() позволяет очень легко получить все ключи ассоциативного массива -- например, в предыдущем случае ими были названия стран, в которых производятся различные сорта вин.
Функция array_values() возвращает массив, состоящий из всех значений исходного массива, переданного в качестве параметра. Синтаксис функции array_values():
array array_values(array массив)
Вернемся к предыдущему примеру, в котором функция array_keys() использовалась для получения всех значений ключей. На этот раз функция array_values() возвращает все значения, соответствующие ключам:
// $great_wines = array ("Australia" => "Clarendon Hills 96",
// "France" => "Comte George de Vogue 97",
// "Austria" => "Feiler Artinger 97");
$great_labels = array_values($great_wines);
// $great_labels = аrrау("Clarendon Hills 96",
// "Comte George de Vogue 97",
// "Feiler Artinger 97");
Функции array_keys() и array_values() дополняют друг друга, позволяяпри необходимости получить все составляющие той или иной стороны ассоциативного массива.
Добавление и удаление элементов
К счастью, в PHP при создании массива не нужно указывать максимальное количество элементов. Это увеличивает свободу действий при операциях с массивами, поскольку вам не приходится беспокоиться о случайном выходе за границы массива, если количество элементов превысит ожидаемый порог. В PHP существует несколько функций для увеличения размеров массива. Некоторые из них были созданы для удобства программистов, привыкших работать с различными типами очередей и стеков (FIFO, FILO и т. д.), что отражается в названиях функций (push, pop, shift и unshift). Но даже если вы не знаете, что такое «очередь» или «стек», не огорчайтесь -- в этих функциях нет ничего сложного.
Очередью (queue) называется структура данных, из которой элементы извлекаются в порядке поступления. Стеком (stack) называется структура данных, из которой элементы извлекаются в порядке, обратном порядку их поступления.
Функция array_push() присоединяет (то есть дописывает в конец массива) один или несколько новых элементов. Синтаксис функции array_push():
int array_push(array массив, mixed элемент [, ...])
Длина массива возрастает прямо пропорционально количеству его элементов. Это продемонстрировано в следующем примере:
$languages = array("Spanish", "English", "French");
array_push($languages, "Russian", "German", "Gaelic");
// $languages = array("Spanish", "English", "French",
// "Russian", "German", "Gaelic")
У функции array_push(), как и у многих стандартных функций PHP, существует «двойник» -- функция аrrау_рор(), предназначенная для извлечения элементов из массива. Главное различие между этими функциями заключается в том, что array_push() может добавлять несколько элементов одновременно, а аrrау_рор() удаляет элементы только по одному.
аrrау_рор()
Результат работы функции аrrау_рор() прямо противоположен array_push() -- эта функция извлекает (то есть удаляет) последний элемент из массива. Извлеченный элемент возвращается функцией. Синтаксис функции аrrау_рор():
аrrау_рор(аrrау массив)
При каждом выполнении аrrау_рор() размер массива уменьшается на 1. Рассмотрим пример:
$languages = array("Spanish", "English", "French",
"Russian", "German", "Gaelic");
$a_language = array_pop($languages): // $a_language = "Gaelic"
$a_language = array_pop($languages): // $a_language = "German"
// $languages = array ("Spanish", "English", "French", "Russian");
Функции array_push(), и array_pop() удобны тем, что с их помощью можно выполнять операции с элементами и управлять размером массива, не беспокоясь о неинициализированных или пустых элементах. Такое решение работает намного эффективнее, чем любые попытки управления этими факторами со стороны программиста.
Функция array_shift() аналогична аrrау_рор() с одним отличием: элемент удаляется из начала (левого края) массива. Все остальные элементы массива сдвигаются на одну позицию к началу массива. У функции array_shift() такой же синтаксис, как и у аггау_рор():
array_shift(array массив)
При работе с функцией array_shift() необходимо помнить, что элементы удаляются из начала массива, как показывает следующий пример:
$languages = array("Spanish", "English", "French", "Russian");
$a_language = array_shift($languages); // $a_language = "Spanish";
// $languages = array("English", "French", "Russian");
Функция array_unshift() дополняет array_shift() -- новый элемент вставляется в начало массива, а остальные элементы сдвигаются на одну позицию вправо. Синтаксис команды array_unshift():
1nt array_unshift(array массив, mixed переменная1 [....переменная2])
При одном вызове функции можно добавить как один, так и несколько элементов, при этом размер массива возрастает пропорционально количеству добавленных элементов. Пример добавления нескольких элементов:
$ languages = array("French", "Italian", "Spanish");
array_unshift($languages, "Russian", "Swahili", "Chinese");
// $languages = array("Russian", "Swahili", "Chinese",
// "French", "Italian", "Spanish");
Функция array_pad() позволяет быстро увеличить массив до желаемого размера посредством его дополнения стандартными элементами. Синтаксис функции array_pad():
array arrap_pad(array массив, int размер, mixed значение):
Параметр размер определяет новую длину массива. Параметр значение задает стандартное значение, присваиваемое элементам во всех новых позициях массива. При использовании array_pad() необходимо учитывать некоторые обстоятельства:
Если размер положителен, массив дополняется справа, а если отрицателен -- слева.
Если абсолютное значение параметра размер меньше либо равно длине массива, никаких действий не выполняется.
Абсолютным значением (модулем) целого числа называется его значение без знака. Например, абсолютное значение чисел 5 и -5 равно 5.
Пример дополнения массива с конца:
$weights = array_pad($weights. 10, 100);
// Результат: $weights = array(1, 3, 5, 10, 15, 25, 50, 100, 100, 100);
Пример дополнения массива с начала:
$weights = array(1, 3, 5, 10, 15, 25, 50);
$weights = array_pad($weights, -10, 100);
// Результат: $weights = array(100, 100, 100, 1, 3, 5, 10, 15, 25, 50);
Неправильная попытка дополнения массива:
$weights = array(1, 3, 5, 10, 15, 25, 50);
$weights = array_pad($weigtits, 3, 100);
// Массив $weights не изменяется:
// $weights = array(1, 3, 5, 10, 15, 25, 50);
Перебор элементов
В PHP существует несколько стандартных функций, предназначенных для перебора элементов массива. В совокупности эти функции обеспечивают гибкие и удобные средства для быстрой обработки и вывода содержимого массивов. Вероятно, вы будете часто использовать эти функции, поскольку они лежат в основе практически всех алгоритмов работы с массивами.
Функция reset() переводит внутренний указатель текущей позиции в массиве к первому элементу. Кроме того, она возвращает значение первого элемента. Синтаксис функции reset():
mixed reset (array массив)
Рассмотрим следующий массив:
$fruits = array("apple", "orange", "banana");
Допустим, указатель текущей позиции в этом массиве установлен на элемент "orange". Команда:
$a_fruit = reset($fruits);
вернет указатель в начало массива, то есть на элемент "apple", и вернет это значение, если результат вызова reset() используется в программе. Возможен и упрощенный вариант вызова:
В этом случае указатель переходит к первому элементу массива, а возвращаемое значение не используется.
Функция each() при каждом вызове выполняет две операции: она возвращает пару «ключ/значение», на которую ссылается указатель текущей позиции, и перемещает указатель к следующему элементу. Синтаксис функции each():
array each (array массив)
Для удобства each () возвращает ключ и значение в виде массива из четырех элементов; ключами этого массива являются 0, 1, value и key. Возвращаемый ключ ассоциируется с ключами 0 и key, а возвращаемое значение -- с ключами 1 и value.
В следующем примере функция each () возвращает элемент, находящийся в текущей позиции:
// Объявить массив из пяти элементов
$spices = array("parsley", "sage", "rosemary", "thyme", "pepper");
// Установить указатель на первый элемент массива
// Создать массив $a_sp1ce. состоящий из четырех элементов
$a_spice = each($spices);
В результате выполнения приведенного фрагмента массив $a_spice будет содержать следующие пары «ключ/значение»:
- 0 => 0;
- 1 => "parsley";
- key => 0;
- value => "parsley".
После этого строку "parsley" можно вывести любой из следующих команд:
print $a_spice: print $a_spice["value"];
Функция each() обычно используется в сочетании с list() в циклических конструкциях для перебора всех или некоторых элементов массива. При каждой итерации each() возвращает либо следующую пару «ключ/значение», либо логическую ложь при достижении последнего элемента массива. Вернемся к массиву $spices; чтобы вывести все элементы на экран, можно воспользоваться следующим сценарием:
// Сбросить указатель текущей позиции
// Перебрать пары "ключ/значение", ограничиваясь выводом значения
while (list ($key, $val) = each ($spices)) :
print "$val
"
Ниже приведен более интересный пример использования each() в сочетании с другими функциями, описанными в этой главе. Листинг 5.1 показывает, как при помощи этих функций вывести отформатированную таблицу стран и языков.
Листинг 5.1. Построение таблицы HTML по содержимому массива
// Объявить ассоциативный массив стран и языков $languages = array ("Country" => "Language",
"Spain" => "Spanish",
"USA" => "English",
"France" => "French",
"Russia" => "Russian");
// Начать новую таблицу
print "
$hd1 | $hd2 |
---|---|
Sctry | $lang |
В результате выполнения этого кода будет построена следующая таблица HTML.
Country |
Language |
Spain | Spanish |
USA | English |
France | French |
Russia | Russian |
Этот пример дает представление о самой сильной стороне PHP -- возможности объединения динамического кода с HTML для получения наглядного, отформатированного представления прочитанных данных.
Функция end() перемещает указатель к позиции последнего элемента массива. Синтаксис функции end():
end (array массив)
Функция next () смещает указатель на одну позицию вперед, после чего возвращает элемент, находящийся в новой позиции. Если в результате смещения
указатель выйдет за пределы массива, next () возвращает ложное значение. Синтаксис функции next ():
mixed next (array массив)
Недостаток функции next () заключается в том, что ложное значение возвращается и для существующих, но пустых элементов массива. Если вы хотите провести обычный перебор, воспользуйтесь функцией each().
Функция prev() аналогична next () за одним исключением: указатель смещается на одну позицию к началу массива, после чего возвращается элемент, находящийся в новой позиции. Если в результате смещения указатель окажется перед первым элементом массива, prev() вернет ложное значение. Синтаксис функции prev():
mixed prev (array массив)
Недостаток функции prev() заключается в том, что ложное значение возвращается и для существующих, но пустых элементов массива. Если вы хотите провести обычный перебор, воспользуйтесь функцией each().
Функция array_walk() позволяет применить функцию к нескольким (а возможно, всем) элементам массива. Синтаксис функции array_walk():
int array_walk(array массив, string имя_функции [, mixed данные])
Функция, заданная параметром имя_функции, может использоваться для различных целей -- например, для поиска элементов с определенными характеристиками или модификации содержимого массива. В ассоциативных массивах функция имя_функции должна получать минимум два параметра -- элемент массива и ключ. Если указан необязательный третий параметр данные, он становится третьим параметром. В следующем примере функция array_walk() используется для удаления дубликатов из массива:
function delete_dupes($element) {
static $last=""; if ($element == $last)
unset($element); else . ""
$emails = array("[email protected]", "[email protected]", "[email protected]");
array_walk($emails,"delete_dupes");
// $emails = array("[email protected]", "[email protected]");
Функция array_reverse() позволяет легко перейти к противоположному порядку элементов, составляющих массив. Синтаксис функции array_reverse():
array array_reverse(array массив)
Рассмотрим пример использования функции array_reverse():
$us_wireproducers = array ("California", "Oregon", "New York". "Washington");
$us_wine_producers - array_reverse (Sus_wine_producers);
// $us_wine_producers = array ("Washington". "New York", "Oregon". "California");
При вызове array_reverse() для ассоциативного массива пары «ключ/значение» сохраняются, изменяется только порядок элементов массива.
Функция array_flip() меняет местами ключи и значения элементов массива. Синтаксис функции array_flip():
array array_flip(array массив)
В следующем примере функция array_flip() меняет местами все ключи и значения элементов:
$languages = array("Spain" => "Spanish", "France" => "French", "Italy" => "Italian");
$languages = array_flip($languages);
// $languages = array("Spanish" => "Spain", // "French" => "France", // "Italian" => "Italy");
Помните: функция array_flip() не изменяет порядок элементов массива. Для этой цели используется функция array_reverse().
Размер массива
Наличие информации о текущем размере массива часто позволяет повысить эффективность сценария. Вероятно, размер массива чаще всего используется при циклическом переборе элементов:
$us_wine_producers = array ("Washington". "New York", "Oregon", "California");
for (Si = 0; Si < sizeof ($us_wine_producers); $i++) :
print "$us_wine_producers[$i]";
Поскольку массив $us_wine_producers индексируется целыми числами, мы можем воспользоваться циклом for для циклического увеличения переменной-счетчика ($i) и вывода каждого элемента в массиве.
Функция sizeof () возвращает количество элементов в массиве. Синтаксис функции sizeof ():
int sizeof (array массив)
Вероятно, функция sizeof () будет часто встречаться в ваших web-приложениях. Ниже приведен краткий пример ее использования (кстати, предыдущий пример тоже относится к числу стандартных применений sizeof ()):
$pasta = array("bowties", "angelhair", "rigatoni");
$pasta_size = sizeof($pasta);
// $pasta_size = 3
У функции sizeof () существует и другая, расширенная форма -- count () (см. ниже).
Функция count() выполняет ту же операцию, что и sizeof (), -- она возвращает количество значений, содержащихся в массиве. Синтаксис функции count ():
int count (mixed переменная)
Единственное различие между sizeof () и count() заключается в том, что в некоторых ситуациях count () возвращает дополнительную информацию:
- если переменная существует и является массивом, count () возвращает количество элементов в массиве;
- если переменная существует, но не является массивом, функция возвращает значение 1;
- если переменная не существует, возвращается значение 0.
array_count_values()
Функция array_count_values() является разновидностью sizeof () и count (). Вместо общего количества элементов она подсчитывает количество экземпляров каждого значения в массиве. Синтаксис функции array_count_values():
array array_count_values(array массив):
В возвращаемом массиве ключами будут значения исходного массива, а значениями -- их частоты:
$states = аrrау("ОН", "ОК", "СА", "РА", "ОН", "ОН", "РА", "АК");
$state_freq = array_count_values($states);
Массив $state_freq заполняется следующими ассоциативными парами «ключ/значение»:
$state_freq = аrrау("ОН" => 3, "ОК" => 1, "СА" => 1, "РА" => 2, "АК" => 1);
Сортировка массивов
Сортировка занимает важное место в программировании и часто встречается на практике в таких Интернет-приложениях, как коммерческие сайты (сортировка категорий товаров в алфавитном порядке, сортировка цен) или поисковые системы (сортировка программ по количеству загрузок). В PHP существует девять стандартных функций сортировки (табл. 5.1), причем каждая функция сортирует массив особым образом.
Таблица 5.1. Функции сортировки
Сортировка |
Обратный порядок |
Сохранение пар «ключ/значение» |
|
Значение |
|||
Значение |
|||
Значение |
|||
Значение |
|||
Значение |
|||
Значение |
|||
Относится к применению пользовательских функций сортировки, когда порядок сортировки массива зависит от результатов, возвращаемых пользовательской функцией.
Сортировка элементов массива не ограничивается стандартными критериями, поскольку три функции (usort(), uasort() и uksort()) позволяют задать пользовательский критерий и отсортировать информацию произвольным образом.
Простейшая функция sort() сортирует элементы массива по возрастанию (от меньших к большим). Синтаксис функции sort ():
void sort (array массив)
Нечисловые элементы сортируются в алфавитном порядке в соответствии с ASCII-кодами. Следующий пример демонстрирует применение функции sort() при сортировке:
// Создать массив городов.
// Отсортировать города по возрастанию
// Перебрать содержимое массива и вывести все пары "ключ/значение".
for (reset($cities); $key = key ($cities); next ($cities)):
print("cities[$key]
= $cities[$key]
";
Этот фрагмент выводит следующий результат:
cities = Aprilia
cities = Nettuno
cities = Venezia
Как видите, массив $cities сортируется в алфавитном порядке. Одна из разновидностей этого способа сортировки реализована в функции asort(), описанной ниже.
Функция rsort () работает точно так же, как функция sort (), за одним исключением: элементы массива сортируются в обратном порядке. Синтаксис функции rsort ():
void rsort (array массив)
Вернемся к массиву $cities из предыдущего примера:
$cities array("Aprilia", "Nettuno", "Roma", "Venezia", "Anzio");
cities = Venezia
cities = Nettuno
cities = Aprilia
Массив $cities также сортируется, но на этот раз в порядке, обратном алфавитному. Одна из разновидностей этого способа сортировки реализована в функции arsort(), описанной ниже.
Функция asort() работает почти так же, как упоминавшаяся выше функция sort(), однако она сохраняет исходную ассоциацию индексов с элементами независимо от нового порядка элементов. Синтаксис функции asort():
void asort(array массив)
Вернемся к массиву $cities:
$cities = array("Aprilia", "Nettuno", "Roma", "Venezia", "Anzio");
В результате сортировки массива $cities функцией rsort() элементы будут расположены в следующем порядке:
cities = Aprilia
cities = Nettuno
cities = Venezia
Обратите внимание на индексы и сравните их с приведенными в описании функции sort (). Именно в этом и состоит различие между двумя функциями.
Функция arsort () представляет собой разновидность asort(), которая сохраняет исходную ассоциацию индексов, но сортирует элементы в обратном порядке. Синтаксис функции arsort():
void arsort (array массив)
Воспользуемся функцией arsort() для сортировки массива $cities:
$cities = array("Aprilia", "Nettuno", "Roma", "Venezia", "Anzio");
arsort($cities);
cities = Venezia
cities[l] = Nettuno
cities = Aprilia
Обратите внимание на индексы и сравните их с приведенными в описании функции rsort(). Именно в этом и состоит различие между двумя функциями.
Функция ksort() сортирует массив по ключам, сохраняя исходные ассоциации ключей со значениями. Синтаксис функции ksort():
void ksort (array массив)
Для примера рассмотрим массив, слегка отличающийся от исходного массива
$wine_producers = array ("America" => "Napa Valley",
"Italy" => "Tuscany",
"Australia" => "Ruthgerlen",
"France" => "Loire",
"Chile" => "Rapel Valley");
В результате сортировки массива функцией ksort() элементы будут расположены в следующем порядке:
"America" => "Napa Valley"
"Australia" => "Ruthgerlen"
"Chile" => "Rapel Valley"
"France" => "Loire"
"Italy" => "Tuscany"
Сравните с результатами сортировки $wine_producers функцией sort ():
"America" => "Napa Valley"
"Australia" => "Tuscany"
"Chile" => "Ruthgerlen"
"France" => "Loire"
"Italy" => "Rapel Valley"
Более чем сомнительный результат!
Функция krsort() почти аналогична ksort(), однако ключи сортируются в обратном порядке. Синтаксис функции krsort():
void krsort (array $массив)
Рассмотрим сортировку массива $wi reproducers функцией krsort():
$wine_producers = array ("America" => "Napa Valley",
"Italy" => "Tuscany",
"Australia" => "Ruthgerlen",
"France" => "Loire".
"Chile" => "Rapel Valley");
krsort($wine_producers);
В результате сортировки элементы будут расположены в следующем порядке:
"Italy" => "Tuscany"
"France" => "Loire"
"Chile" => "Rapel Valley"
"Australia" => "Ruthgerlen"
"America" => "Napa Valley"
Вероятно, описанных выше функций сортировки будет вполне достаточно для большинства случаев. Тем не менее, в некоторых ситуациях может возникнуть необходимость в определении собственных критериев сортировки. В PHP такая возможность реализована в трех стандартных функциях: usort(), uasort() и uksort().
Функция usort() дает возможность отсортировать массив на основании критерия, определяемого программистом. Для этого usort() в качестве параметра передается имя функции, определяющей порядок сортировки. Синтаксис функции usort():
void usort (array массив, string имя_функции)
В параметре массив передается имя сортируемого массива, а в параметре имя_функции -- имя функции, на основании которой будет осуществляться сортировка. Допустим, у вас имеется длинный список греческих имен, которые необходимо выучить к предстоящему экзамену по истории. Вы хотите отсортировать слова по длине, чтобы начать с самых длинных, а затем учить короткие, когда вы уже устанете. Для сортировки массива по длине можно воспользоваться функцией usort().
Листинг 5.2. Определение критерия сортировки для функции usort()
$vocab = аrrау("Socrates", "Aristophanes", "Plato", "Aeschylus", "Thesmophoriazusae");
function compare_length($str1, $str2) {
// Получить длину двух следующих слов
$length1 = strlen($str1);
$length2 = strlen($str2);
// Определить, какая строка имеет меньшую длину
if ($length1 == $length2) :
elseif ($length1 < $length2) :
// Вызвать usort() с указанием функции compare_length()
// в качестве критерия сортировки
usort ($vocab, "compare_length") :
// Вывести отсортированный список
while (list ($key, $val) = each ($vocab)) {
echo "$val
";
В листинге 5.2 функция compare_length () определяет критерий сортировки массива. В данном случае это делается посредством сравнения длины передаваемых элементов. Функция-критерий должна получать два параметра, представляющих
сравниваемые элементы массива. Также обратите внимание на то, как эти элементы неявно передаются функции-критерию при вызове usort(), и на то, что все элементы автоматически сравниваются этой функцией.
Функции uasort() и uksort() представляют собой разновидности usort() с тем же синтаксисом. Функция uasort() сортирует массив по пользовательскому критерию с сохранением ассоциаций «ключ/значение». Функция uksort() также сортирует массив по пользовательскому критерию, однако сортируются не значения, а ключи.
Другие полезные функции
В этом разделе описаны некоторые функции, которые не принадлежат ни к какому конкретному разделу, но приносят несомненную пользу.
Функция arrayjnerge() сливает от 1 до N массивов, объединяя их в соответствии с порядком перечисления в параметрах. Синтаксис функции array_merge():
array array_merge(array массив1, array массив2, ..., array массивN]
Рассмотрим пример простого объединения массивов функцией arrayjnerge();
$arr_1 = array("strawberry", "grape", "lemon");
$arr_2 = array("banana", "cocoa", "lime");
$arr_3 = array("peach", "orange");
$arr_4 = array_merge ($arr2, $arr_1, $arr_3):
// $arr_4 = array("banana", "cocoa", "lime", "strawberry", "grape", "lemon", "peach", "orange");
Функция array_slice() возвращает часть массива, начальная и конечная позиция которой определяется смещением от начала и необязательным параметром длины. Синтаксис функции array_slice():
array array_slice(array массив, int смещение [, int длина])
- Если смещение положительно, начальная позиция возвращаемого фрагмента отсчитывается от начала массива.
- Если смещение отрицательно, начальная позиция возвращаемого фрагмента отсчитывается от конца массива.
- Если длина не указана, в возвращаемый массив включаются все элементы от начальной позиции до конца массива.
- Если указана положительная длина, возвращаемый фрагмент состоит из заданного количества элементов.
- Если указана отрицательная длина, возвращаемый фрагмент заканчивается в заданном количестве элементов от конца массива.
Функция array_spl ice() отдаленно напоминает array_slice() -- она заменяет часть массива, определяемую начальной позицией и необязательной длиной, элементами необязательного параметра-массива. Синтаксис функции array_splice():
array_splice(array входной_массив, int смещение, , );
Значения параметров задаются по определенным правилам:
- Если смещение положительно, начальная позиция первого удаляемого элемента отсчитывается от начала массива.
- Если смещение отрицательно, начальная позиция первого удаляемого элемента отсчитывается от конца массива.
- Если длина не указана, удаляются все элементы от начальной позиции до конца массива.
- Если указана положительная длина, удаляемый фрагмент состоит из заданного количества элементов.
- Если указана отрицательная длина, из массива удаляются элементы от начальной позиции до позиции, находящейся на заданном расстоянии от конца массива.
- Если заменяющий_массив не указан, то элементы, заданные смещением и необязательной длиной, удаляются из массива.
- Если заменяющий_массив указан, он должен быть заключен в конструкцию аггау() (если он содержит более одного элемента).
Рассмотрим несколько примеров, наглядно демонстрирующих возможности этой функции. В этих примерах будет использоваться массив $pasta (см. выше), с которым будут выполняться различные операции.
Удаление всех элементов с пятой позиции до конца массива:
$pasta = array_splice($pasta, 5);
Удаление пятого и шестого элементов:
$pasta = array_splice($pasta. 5, 2);
Замена пятого и шестого элементов новыми значениями:
$pasta = array_splice($pasta, 5, 2, array("element1", "element2"));
Удаление всех элементов, начиная с пятого, до третьего элемента с конца массива:
$pasta = array_splice($pasta, 5, -3);
Как видно из приведенных примеров, функция array_splice() обеспечивает гибкие возможности удаления элементов из массива при минимальном объеме кода.
Функция shuffle() сортирует элементы массива в случайном порядке. Синтаксис функции shuffle():
void shuffle(array массив);
Итоги
В этой главе рассматривались массивы и стандартные функции PHP для работы с массивами. В частности, рассматривались следующие темы:
- создание индексируемых и ассоциативных массивов;
- многомерные массивы;
- отображение содержимого многомерных массивов;
- поиск элементов;
- добавление и удаление элементов;
- размер массива;
- сортировка;
- другие полезные функции для работы с массивами.
Массивы являются очень удобными и универсальными средствами для работы с данными в web-приложениях. В примерах дальнейших глав массивы будут неоднократно использоваться для повышения эффективности и наглядности кода.
В главе 6 мы продолжим знакомиться с базовыми средствами PHP. На этот раз речь пойдет об объектно-ориентированных возможностях языка.