И операторов массивов:
Пример | Название | Результат |
---|---|---|
$a + $b | Объединение | Объединение массива $a и массива $b. |
$a == $b | Равно | TRUE в случае, если $a и $b содержат одни и те же элементы. |
$a === $b | Тождественно равно | TRUE в случае, если $a и $b содержат одни и те же элементы в том же самом порядке. |
$a != $b | Не равно | TRUE |
$a <> $b | Не равно | TRUE если массив $a не равен массиву $b. |
$a !== $b | Тождественно не равно | TRUE если массив $a не равен тождественно массиву $b. |
Пример сравнения массивов:
Некоторы полезные практические примеры по работе с массивами
// это
$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")
?>
Еще один практический пример:
// Массив как карта (свойств)
$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();
?>
Коллекция:
$colors = array("красный" , "синий" , "зеленый" , "желтый" );
Foreach ($colors
as
$color
) {
echo
"Вам нравится $color?\n"
;
}
?>
Результат работы рассмотренного скрипта:
Вам нравится красный? Вам нравится синий? Вам нравится зеленый? Вам нравится желтый?
Следующий пример создает начинающийся с единицы массив:
$firstquarter
= array(1
=>
"Январь"
,
"Февраль"
,
"Март"
);
print_r
($firstquarter
);
?>
Результат работы приведенного скрипта будет следующий:
Пример заполнения массива:
// заполняет массив всеми элементами директории
$handle
=
opendir
("."
);
while (false
!== ($file
=
readdir
($handle
))) {
$files
=
$file
;
}
closedir
($handle
);
?>
Массивы упорядочены. Вы можете изменять порядок элементов, используя различные функции сортировки. Для дополнительной информации смотрите раздел функции для работы с массивами . Вы можете подсчитать количество элементов в массиве, используя функцию count() .
Рекурсивные и многомерные массивы:
$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
[
"яблоко"
][
"зеленое"
] =
"хорошее"
;
?>
Обратите внимание, что при присваивании массива всегда происходит копирование значения. Чтобы копировать массив по ссылке, вам нужно использовать оператор ссылки:
$arr1
= array(2
,
3
);
$arr2
=
$arr1
;
$arr2
=
4
;
// $arr2 изменился,
// $arr1 по прежнему array(2,3)
$arr3
= &
$arr1
;
$arr3
=
4
;
// теперь $arr1 и $arr3 эквивалентны
?>
Мы рассмотрели основные возможности по работе с массивами. Некоторую дополнительную информацию вы можете найти в разделе "Работа с переменными " статей по PHP.
Есть еще вопросы или что-то непонятно - добро пожаловать на наш | |
|
Сравнение двух массивов с одинаковыми значениями (дублируемыми или нет, с учетом ввода-манипуляции) может быть выполнено с помощью array_diff() в оба направления:
Array_diff($a, $b) && !array_diff($b, $a);
Это дает TRUE , если оба массива имеют одинаковые значения (после манипуляции с типом). FALSE в противном случае. Примеры:
Function array_equal_values(array $a, array $b) { return !array_diff($a, $b) && !array_diff($b, $a); } array_equal_values(, ); # FALSE array_equal_values(, ); # FALSE array_equal_values(["1"], ); # TRUE array_equal_values(["1"], ); # TRUE
Как показывает этот пример, array_diff оставляет ключи массива из уравнения и не заботится о порядке значений и ни о том, что значения дублируются, либо нет.
Если дублирование должно иметь значение, это становится более сложным. Что касается "простых" значений (работают только строковые и целочисленные значения), array_count_values() входит в игру для сбора информации о том, какое значение как часто внутри массива. Эта информация легко сравнивается с == :
Array_count_values($a) == array_count_values($b);
Это дает TRUE , если оба массива имеют одинаковые значения (после манипуляции с типом) за такое же количество времени. FALSE в противном случае. Примеры:
Function array_equal_values(array $a, array $b) { return array_count_values($a) == array_count_values($b); } array_equal_values(, ); # TRUE array_equal_values(, ); # TRUE array_equal_values(["2", "2"], ); # FALSE array_equal_values(["2.0", "2"], ); # TRUE
Это может быть дополнительно оптимизировано путем сравнения количества первых двух массивов, которое является относительно дешевым, и быстрого теста, чтобы рассказать большинству массивов обособленно, если подсчет дублирования значений имеет значение.
Эти примеры до сих пор частично ограничены строковыми и целочисленными значениями, и строгое сравнение с array_diff невозможно. Более строгое сравнение для array_search . Таким образом, значения нужно подсчитывать и индексировать так, чтобы их можно было сравнить, просто превратив их в ключ (как это делает array_search).
Это немного больше работы. Однако в итоге сравнение будет таким же, как и раньше:
$count($a) == $count($b);
Это просто $count , что делает разницу:
$table = ; $count = function (array $array) use (&$table) { $exit = (bool)$table; $result = ; foreach ($array as $value) { $key = array_search($value, $table, true); if (FALSE !== $key) { if (!isset($result[$key])) { $result[$key] = 1; } else { $result[$key]++; } continue; } if ($exit) { break; } $key = count($table); $table[$key] = $value; $result[$key] = 1; } return $result; };
Это сохраняет таблицу значений, чтобы оба массива могли использовать один и тот же индекс. Также возможно выйти с первого раза в первый раз во втором массиве с новым значением.
Эта функция также может добавить строгий контекст, добавив дополнительный параметр. И добавив еще один дополнительный параметр, вы можете позволить искать дубликаты или нет. Полный пример:
Function array_equal_values(array $a, array $b, $strict = FALSE, $allow_duplicate_values = TRUE) { $add = (int)!$allow_duplicate_values; if ($add and count($a) !== count($b)) { return FALSE; } $table = ; $count = function (array $array) use (&$table, $add, $strict) { $exit = (bool)$table; $result = ; foreach ($array as $value) { $key = array_search($value, $table, $strict); if (FALSE !== $key) { if (!isset($result[$key])) { $result[$key] = 1; } else { $result[$key] += $add; } continue; } if ($exit) { break; } $key = count($table); $table[$key] = $value; $result[$key] = 1; } return $result; }; return $count($a) == $count($b); }
Примеры использования:
Array_equal_values(["2.0", "2", 2], ["2", "2.0", 2], TRUE); # TRUE array_equal_values(["2.0", "2", 2, 2], ["2", "2.0", 2], TRUE); # TRUE array_equal_values(["2.0", "2", 2, 2], ["2", "2.0", 2], TRUE, FALSE); # FALSE array_equal_values(["2"], ["2"], TRUE, FALSE); # TRUE array_equal_values(, ["2", 2]); # TRUE array_equal_values(, ["2", 2], FALSE); # TRUE array_equal_values(, ["2", 2], FALSE, TRUE); # FALSE
» Сравнение массивов в PHP
Сравнение массивов производится с помощью привычных для нас операторов отношений. Наибольший интерес в этом плане вызывают операторы равенства (==) и эквивалентности (===).
Массивы считаются равными, в том случае, если каждый элемент одного массива имеет один равный ему во втором, и наоборот. Равенство элементов подразумевает соответственно совпадение ключа и значения. Порядок расположения элементов при этом не играет роли (листинг 8.12).
Листинг 8.12. Сравнение массивов.
‹html›
‹head›
‹title›Сравнение массивов‹/title›
‹/head›
‹body›
‹?php
$closets_1 = array ("Ботинки","Футболка");
$closets_2 = array ("1" => "Футболка", "0" => "Ботинки");
if ($closets_1 == $closets_2)
{
echo "Массивы равны";
}
else
{
echo "Массивы неравны";
}
?›
‹/body›
‹/html›
Заметьте, что индексы второго массива находятся в двойных кавычках, а значит имеют тип String. Но в данном случае сравниваются значения, а не типы, поэтому программа все равно выведет сообщение о равенстве массивов. То же самое относится к значениям элементов в массиве.
Иначе дело обстоит с оператором эквивалентности, который требует от своих операндов не только равенства значений, но и одинаковый порядок следования элементов в массиве (листинг 8.13).
Листинг 8.13. Эквивалентность массивов.
‹html›
‹head›
‹title›Эквивалентность массивов‹/title›
‹/head›
‹body›
‹?php
$closets_1=
array ("Ботинки", "Футболка");
$closets_2=
array("1" => "Футболка", "0" => "Ботинки");
if ($closets_1 === $closets_2)
{
echo "Массивы эквивалентны";
}
else
{
echo "Массивы неэквивалентны";
}
?›
‹/body›
‹/html›
В этом случае программа выведет, что массивы неэквивалентны. Наряду с разобранными операторами существуют также операторы неравенства (!=) и неэквивалентности (!==), которые работают аналогично, но результат выполнения будет противоположный.