Массивы

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

Объяснение этих структур данных выходит за рамки этого руководства, но как минимум один пример будет приведён для каждой из них. За дополнительной информацией обращаются к большому объему литературы по этой обширной теме.

Синтаксис

Определение массива через языковую конструкцию array()

Массив (array) создают языковой конструкцией array(). Конструкция принимает как аргументы произвольное количество разделённых запятыми пар ключ => значение.

array(
    key  => value,
    key2 => value2,
    key3 => value3,
    ...
)

Запятая после последнего элемента массива необязательна; пропуск конечной запятой не вызывает ошибок. Конечную запятую часто опускают в определениях однострочных массивов, — лучше предпочесть array(1, 2) вместо array(1, 2, ). Для многострочных массивов, наоборот, часто указывают конечную запятую, поскольку это упрощает добавление новых элементов в конец массива.

Замечание:

PHP поддерживает короткий синтаксис массива, который заменяет языковую конструкцию array() выражением [].

Пример #1 Простой массив

<?php

$array1
= array(
"foo" => "bar",
"bar" => "foo",
);

// Работа с коротким синтаксисом массива
$array2 = [
"foo" => "bar",
"bar" => "foo",
];

var_dump($array1, $array2);

?>

Ключ массива (key) разрешено указывать либо как целочисленное значение (int), либо как строку (string). Значение массива (value) может принадлежать любому типу данных.

Дополнительно произойдут следующие преобразования ключа key:

  • Строки (string), которые содержат целое число (int) (исключая случаи, в которых перед числом указывают знак +), преобразуются в целое число (int). Например, ключ со значением "8" сохранится со значением 8. При этом, значение "08" не преобразуется, поскольку значение не относится к корректным десятичным целым.
  • Числа с плавающей точкой (float) также преобразуются в целочисленные значения (int) — дробная часть будет отброшена. Например, ключ со значением 8.7 будет сохранится со значением 8.
  • Логический тип (bool) также преобразовывается в целочисленный тип (int). Например, ключ со значением true сохранится со значением 1, а ключ со значением false сохранится со значением 0.
  • Тип null преобразуется в пустую строку. Например, ключ со значением null сохранится со значением "".
  • Массивы (array) и объекты (object) нельзя указывать как ключи. Это сгенерирует предупреждение: Недопустимый тип смещения (Illegal offset type).

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

Пример #2 Преобразование типов и перезапись элементов

<?php

$array
= array(
1 => "a",
"1" => "b",
1.5 => "c",
true => "d",
);

var_dump($array);

?>

Результат выполнения приведённого примера:

array(1) {
  [1]=>
  string(1) "d"
}

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

PHP разрешает массивам содержать одновременно целочисленные (int) и строковые (string) ключи, поскольку PHP одинаково воспринимает индексные и ассоциативные массивы.

Пример #3 Смешанные целочисленные (int) и строковые (string) ключи

<?php

$array
= array(
"foo" => "bar",
"bar" => "foo",
100 => -100,
-
100 => 100,
);
var_dump($array);

?>

Результат выполнения приведённого примера:

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

Ключ (key) — необязателен. Если он не указан, PHP инкрементирует предыдущее наибольшее целочисленное (int) значение ключа.

Пример #4 Индексные массивы без ключа

<?php

$array
= array("foo", "bar", "hallo", "world");
var_dump($array);

?>

Результат выполнения приведённого примера:

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hallo"
  [3]=>
  string(5) "world"
}

Разрешено указывать ключ одним элементам и пропускать для других:

Пример #5 Ключи для некоторых элементов

<?php

$array
= array(
"a",
"b",
6 => "c",
"d",
);
var_dump($array);

?>

Результат выполнения приведённого примера:

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

Видно, что последнее значение "d" присвоилось ключу 7. Это произошло потому, что перед этим самым большим значением целочисленного ключа было 6.

Пример #6 Расширенный пример преобразования типов и перезаписи элементов

Приведённый пример показывает все приведения типов ключей и перезаписи элементов.

<?php

$array
= array(
1 => 'a',
'1' => 'b', // Значение "b" перезапишет значение "a"
1.5 => 'c', // Значение "c" перезапишет значение "b"
-1 => 'd',
'01' => 'e', // Строка НЕ перезапишет ключ 1, поскольку она не целочисленная
'1.5' => 'f', // Строка НЕ перезапишет ключ 1, поскольку она не целочисленная
true => 'g', // Значение "g" перезапишет значение "c"
false => 'h',
'' => 'i',
null => 'j', // Значение "j" перезапишет значение "i"
'k', // Значение "k" присваивается ключу 2, потому что самый большой целочисленный ключ до этого был 1
2 => 'l', // Значение "l" перезапишет значение "k"
);

var_dump($array);

?>

Результат выполнения приведённого примера:

array(7) {
  [1]=>
  string(1) "g"
  [-1]=>
  string(1) "d"
  ["01"]=>
  string(1) "e"
  ["1.5"]=>
  string(1) "f"
  [0]=>
  string(1) "h"
  [""]=>
  string(1) "j"
  [2]=>
  string(1) "l"
}

Пример #7 Отрицательные индексы

При назначении отрицательного целочисленного ключа n, PHP позаботится о том, чтобы назначить следующий ключ n + 1.

<?php

$array
= [];

$array[-5] = 1;
$array[] = 2;

var_dump($array);

?>

Результат выполнения приведённого примера:

array(2) {
  [-5]=>
  int(1)
  [-4]=>
  int(2)
}
Внимание

До PHP 8.3.0 назначение отрицательного целочисленного ключа n присвоило бы следующему ключу значение 0, поэтому приведённый пример вывел бы:

array(2) {
  [-5]=>
  int(1)
  [0]=>
  int(2)
}

Доступ к элементам массива через синтаксис квадратных скобок

Доступ к элементам массива получают синтаксисом array[key].

Пример #8 Доступ к элементам массива

<?php

$array
= array(
"foo" => "bar",
42 => 24,
"multi" => array(
"dimensional" => array(
"array" => "foo"
)
)
);

var_dump($array["foo"]);
var_dump($array[42]);
var_dump($array["multi"]["dimensional"]["array"]);

?>

Результат выполнения приведённого примера:

string(3) "bar"
int(24)
string(3) "foo"

Замечание:

До PHP 8.0.0 квадратные и фигурные скобки могли взаимозаменяться при доступе к элементам массива (например, в приведённом примере $array[42] и $array{42} делали одно и то же). Синтаксис фигурных скобок устарел с PHP 7.4.0 и больше не поддерживается с PHP 8.0.0.

Пример #9 Разыменование массива

<?php

function getArray()
{
return array(
1, 2, 3);
}

$secondElement = getArray()[1];

var_dump($secondElement);

?>

Замечание:

Попытка доступа к неопределённому ключу в массиве — то же, что и попытка доступа к неопределённой переменной: выдаётся ошибка уровня E_WARNING или до PHP 8.0.0 ошибка уровня E_NOTICE, и результат равняется null.

Замечание:

Попытка разыменовать не массив, а скалярное значение, которое отличается от строки (string), отдаст null, тогда как разыменование значения string трактует строку как индексный массив. При такой попытке до PHP 7.4.0 не выдавалось сообщение об ошибке. С PHP 7.4.0 выдаётся ошибка уровня E_NOTICE; с PHP 8.0.0 выдаётся ошибка уровня E_WARNING.

Создание или модификация массива синтаксисом квадратных скобок

Массив возможно изменить путём явной установки значений.

Присваивание через ключ в квадратных скобках установит значение массива (array), а пара пустых скобок [] добавит новое значение.

    $arr[key] = value;
    $arr[] = value;
    // В ключе key указывают только значения типов int или string,
    // а в элементе value — значения произвольного типа
   

PHP создаст новый массив, если переменную $arr ещё не определили или присвоили переменной значение null или false, так что это альтернативный способ создать массив array. Однако создавать массив такими способом не рекомендуют, поскольку если переменная $arr уже содержит значение наподобие string-переменной сетевого запроса, это значение или не изменится и вызовет ошибку, или инструкция [] интерпретируется как оператор доступа к символу в строке. Лучше инициализировать переменную прямым присваиванием.

Замечание: Начиная с PHP 7.1.0 оператор пустого индекса на строке выбросит фатальную ошибку. Раньше строка молча преобразовывалась в массив.

Замечание: С PHP 8.1.0 способ, которым создавали новый массив приведением к нему значения false, устарел. Способ, которым создают новый массив приведением к нему значения null и неопределённого значения, по-прежнему доступен.

Для изменения конкретного значения указывают ключ элемента и присваивают новое значение. Пару «ключ — значение» удаляют языковой конструкцией unset().

Пример #10 Работа с массивами через квадратные скобки

<?php

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

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

$arr["x"] = 42; // Добавление в массив нового
// элемента с ключом "x"

unset($arr[5]); // Удаление элемента из массива

var_dump($arr);

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

var_dump($arr);

?>

Замечание:

Как было сказано ранее, если разработчик не указал ключ, то будет взят максимальный из существующих целочисленных (int) индексов, и новым ключом будет это максимальное значение (в крайнем случае 0) плюс 1. Если целочисленных (int) индексов ещё нет, то ключом будет 0 (ноль).

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

<?php

// Создаём простой массив.
$array = array(1, 2, 3, 4, 5);
print_r($array);

// Теперь удаляем каждый элемент, но массив оставляем нетронутым:
foreach ($array as $i => $value) {
unset(
$array[$i]);
}
print_r($array);

// Добавляем элемент (обратите внимание, что новым ключом будет 5, а не 0).
$array[] = 6;
print_r($array);

// Переиндексация:
$array = array_values($array);
$array[] = 7;
print_r($array);

?>

Результат выполнения приведённого примера:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

Деструктуризация массива

Массивы разрешено деструктурировать языковыми конструкциями [] (начиная с PHP 7.1.0) или list(). Эти языковые конструкции разрешено использовать для деструктуризации массива на отдельные переменные.

Пример #11 Деструктуризация массива

<?php

$source_array
= ['foo', 'bar', 'baz'];
[
$foo, $bar, $baz] = $source_array;
echo
$foo, PHP_EOL; // Выведет "foo"
echo $bar, PHP_EOL; // Выведет "bar"
echo $baz, PHP_EOL; // Выведет "baz"

?>

Деструктуризацию массива также выполняют в конструкции foreach для деструктуризации многомерного массива во время итерации по массиву.

Пример #12 Деструктуризация массива в конструкции foreach

<?php

$source_array
= [
[
1, 'John'],
[
2, 'Jane'],
];

foreach (
$source_array as [$id, $name]) {
echo
"{$id}: '{$name}'\n";
}

?>

Деструктуризация проигнорирует элементы массива, для которых не указали переменную. Деструктуризация массива начинается с индекса 0.

Пример #13 Игнорирование элементов

<?php

$source_array
= ['foo', 'bar', 'baz'];

// Присваивание элемента с индексом 2 переменной $baz
[, , $baz] = $source_array;

echo
$baz; // Выведет "baz"

?>

Начиная с PHP 7.1.0 поддерживается деструктуризация ассоциативных массивов. Это упрощает выбор элемента в массивах с числовым индексом, поскольку разрешает явно указать индекс.

Пример #14 Деструктуризация ассоциативных массивов

<?php

$source_array
= ['foo' => 1, 'bar' => 2, 'baz' => 3];

// Присваивание элемента с индексом 'baz' переменной $three
['baz' => $three] = $source_array;

echo
$three, PHP_EOL; // Выведет 3

$source_array = ['foo', 'bar', 'baz'];

// Присваивание элемента с индексом 2 переменной $baz
[2 => $baz] = $source_array;

echo
$baz, PHP_EOL; // Выведет "baz"

?>

Деструктуризацией массива пользуются, чтобы поменять две переменные местами.

Пример #15 Перестановка двух переменных

<?php

$a
= 1;
$b = 2;
[
$b, $a] = [$a, $b];
echo
$a, PHP_EOL; // Выведет 2
echo $b, PHP_EOL; // Выведет 1

?>

Замечание:

Оператор ... не поддерживается в присваиваниях.

Замечание:

Попытка получить доступ к неопределённому ключу массива аналогична обращению к любой другой неопределённой переменной: будет выдано сообщение об ошибке уровня E_WARNING (ошибки уровня E_NOTICE до PHP 8.0.0), а результатом будет значение null.

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

Для работы с массивами есть довольного много полезных функций. Подробнее об этом рассказано в разделе «Функции для работы с массивами».

Замечание:

Языковая конструкция unset() умеет удалять ключи массива. Обратите внимание, что массив НЕ переиндексируется. Массив переиндексируют функцией array_values(), если требуется поведение в стиле «удалить и сдвинуть».

Пример #16 Удаление промежуточных элементов

<?php

$a
= array(1 => 'один', 2 => 'два', 3 => 'три');

/* Удаление элемента изменит массив так, как если бы его определили так:
$a = array(1 => 'один', 3 => 'три');
но НЕ так:
$a = array(1 => 'один', 2 => 'три');
*/
unset($a[2]);
var_dump($a);

$b = array_values($a);
// Теперь переменная $b содержит array(0 => 'один', 1 => 'три')
var_dump($b);

?>

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

Что можно и нельзя делать с массивами

Почему выражение $foo[bar] неверно?

Рекомендовано заключать в кавычки строковый литерал в индексе ассоциативного массива. Например, нужно писать $foo['bar'], а не $foo[bar]. Но почему? Часто в старых скриптах встречается следующий синтаксис:

<?php

$foo
[bar] = 'враг';
echo
$foo[bar];
// и т. д.

?>

Это неверно, хотя и работает. Причина состоит в том, что этот код содержит неопределённую константу bar), а не строку ('bar' — обратите внимание на кавычки. Это работает, потому что PHP автоматически преобразовывает «голую строку» — строка без кавычек, которая не соответствует ни одному известному символу языка — в строку со значением этой «голой строки». PHP заменит строку bar на строку 'bar' и будет работать с ней, если константу с названием bar не определили.

Внимание

Резервный вариант для обработки неопределённой константы как пустой строки выдаёт ошибку уровня E_NOTICE. Начиная с PHP 7.2.0 поведение объявлено устаревшим и выдаёт ошибку уровня E_WARNING. Начиная с PHP 8.0.0 удалено и выбрасывает исключение Error.

Это не значит, что в кавычки заключают каждый ключ. В кавычки не берут константы и переменные, поскольку закавычивание помешает интерпретации.

Пример #17 Закавычивание ключей

<?php

error_reporting
(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);

// Простой массив:
$array = array(1, 2);
$count = count($array);

for (
$i = 0; $i < $count; $i++) {
echo
"\nПроверяем $i: \n";
echo
"Плохо: " . $array['$i'] . "\n";
echo
"Хорошо: " . $array[$i] . "\n";
echo
"Плохо: {$array['$i']}\n";
echo
"Хорошо: {$array[$i]}\n";
}

?>

Результат выполнения приведённого примера:

Проверяем 0:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Плохо:
Хорошо: 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Плохо:
Хорошо: 1

Проверяем 1:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Плохо:
Хорошо: 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Плохо:
Хорошо: 2

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

Пример #18 Дополнительные примеры

<?php

// Показываем все ошибки
error_reporting(E_ALL);

$arr = array('fruit' => 'apple', 'veggie' => 'carrot');

// Верно
echo $arr['fruit'], PHP_EOL; // apple
echo $arr['veggie'], PHP_EOL; // carrot

// Неверно. Это работает, но также выбрасывает PHP-ошибку из-за неопределённой константы
// с названием fruit
//
// Error: Undefined constant "fruit"
try {
echo
$arr[fruit]; // apple
} catch (Error $e) {
echo
get_class($e), ': ', $e->getMessage(), PHP_EOL;
}

// Определим константу, чтобы посмотреть,
// что произоёдет. Присвоим константе с названием fruit значение "veggie".
define('fruit', 'veggie');

// Теперь обратите внимание на разницу
echo $arr['fruit'], PHP_EOL; // apple
echo $arr[fruit], PHP_EOL; // carrot

// Доступ по ключу без кавычек сработает внутри строки. PHP не ищет константы внутри строк,
// поэтому ошибка уровня E_NOTICE здесь не возникнет
echo "Hello $arr[fruit]", PHP_EOL; // Hello apple

// За одним исключением: PHP интерпретирует константы,
// если обращение к массиву внутри строки обернули фигурными скобками
echo "Hello {$arr[fruit]}", PHP_EOL; // Hello carrot
echo "Hello {$arr['fruit']}", PHP_EOL; // Hello apple

// Ещё один способ вывести значение массива — конкатенация
echo "Hello " . $arr['fruit'], PHP_EOL; // Hello apple

?>
<?php

// Это не сработает и вызовет ошибку разбора наподобие:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'.
// Это относится и к суперглобальным переменным в строках
print "Hello $arr['fruit']";
print
"Hello $_GET['foo']";

?>

При установке для директивы error_reporting значения E_ALL, которое включит также и режим отображения ошибок уровня E_NOTICE, PHP сразу покажет ошибки, которые возникают при неправильном доступе к элементам массива. Со значением по умолчанию директива error_reporting не показывает уведомления.

Как указывает раздел о синтаксисе, внутри квадратных скобок '[' и ']' требуется указывать выражение. Поэтому следующий код работает:

<?php

echo $arr[somefunc($bar)];

?>

Это пример работы с возвращаемым функцией значением в качестве индекса массива. PHP также знает о константах:

<?php

$error_descriptions
[E_ERROR] = "Произошла фатальная ошибка";
$error_descriptions[E_WARNING] = "PHP сообщает о предупреждении";
$error_descriptions[E_NOTICE] = "Это лишь неофициальное замечание";

?>

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

<?php

$error_descriptions
[1] = "Произошла фатальная ошибка";
$error_descriptions[2] = "PHP выдал предупреждение";
$error_descriptions[8] = "Это просто уведомление";

?>

поскольку значение константы E_ERROR соответствует значению 1 и т. д.

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

Когда-нибудь в будущем команда разработчиков PHP, возможно, захочет добавить ещё одну константу или ключевое слово, либо константа из другого кода может вмешаться. Например, неправильно использовать слова empty и default, поскольку они относятся к зарезервированным ключевым словам.

Замечание: Повторим, внутри строки (string) в двойных кавычках допустимо не окружать индексы массива кавычками, поэтому "$foo[bar]" — допустимая запись. В примерах выше объяснено, почему, дополнительная информация дана в разделе об обработке переменных в строках.

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

Преобразование целого числа (int), числа с плавающей точкой (float), строки (string), логического значения (bool) или ресурса (resource) в массив — создаёт массив с одним элементом с индексом 0 и значением скаляра, который был преобразован. Говоря по-другому, выражение (array) $scalarValue аналогично выражению array($scalarValue).

Если объект (object) будет преобразован в массив, элементами массива будут свойства (переменные-члены) этого объекта. Ключами будут имена переменных-членов, со следующими примечательными исключениями: целочисленные свойства станут недоступны; к закрытым полям класса (private) в начало будет дописано имя класса; к защищённым полям класса (protected) в начало будет добавлен символ '*'. Эти добавленные с обоих сторон значения также получат NUL-байты. Неинициализированные типизированные свойства автоматически отбрасываются.

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

<?php

class A
{
private
$B;
protected
$C;
public
$D;

function
__construct()
{
$this->{1} = null;
}
}

var_export((array) new A());

?>

Результат выполнения приведённого примера:

array (
  '' . "\0" . 'A' . "\0" . 'B' => NULL,
  '' . "\0" . '*' . "\0" . 'C' => NULL,
  'D' => NULL,
  1 => NULL,
)

Это может вызвать несколько неожиданное поведение:

Пример #20 Приведение объекта к массиву

<?php

class A
{
private
$A; // Свойство станет ключом '\0A\0A'
}

class
B extends A
{
private
$A; // Свойство станет ключом '\0B\0A'
public $AA; // Свойство станет ключом 'AA'
}

var_dump((array) new B());

?>

Результат выполнения приведённого примера:

array(3) {
  ["BA"]=>
  NULL
  ["AA"]=>
  NULL
  ["AA"]=>
  NULL
}

Приведённый код покажет 2 ключа с названием 'AA', хотя один ключ на самом деле называется '\0A\0A'.

Получится пустой массив, если преобразовать в массив значение null.

Сравнение

Массивы сравнивают функцией array_diff() и операторами массивов.

Распаковка массива

Массив, перед которым указали оператор ..., распакуется на месте при определении нового массива. Распаковка доступна только массивам и объектам, которые реализуют интерфейс Traversable. Распаковка массива spread-оператором ... доступна с PHP 7.4.0.

PHP поддерживает многократное чередование распаковки и стандартных элементов до или после оператора ...:

Пример #21 Простая распаковка массива

<?php

// Применение короткого синтаксиса массива.
// Работает также с синтаксисом array().
$arr1 = [1, 2, 3];
$arr2 = [...$arr1]; // [1, 2, 3]
$arr3 = [0, ...$arr1]; // [0, 1, 2, 3]
$arr4 = [...$arr1, ...$arr2, 111]; // [1, 2, 3, 1, 2, 3, 111]
$arr5 = [...$arr1, ...$arr1]; // [1, 2, 3, 1, 2, 3]

function getArr() {
return [
'a', 'b'];
}

$arr6 = [...getArr(), 'c' => 'd']; // ['a', 'b', 'c' => 'd'];

var_dump($arr1, $arr2, $arr3, $arr4, $arr5, $arr6);

?>

Распаковка массива оператором ... соблюдает семантику функции array_merge(), поэтому более поздние строковые ключи перезаписывают более ранние, а целочисленные ключи перенумеровываются:

Пример #22 Распаковка массива с дублирующим ключом

<?php

// Строковый ключ
$arr1 = ["a" => 1];
$arr2 = ["a" => 2];
$arr3 = ["a" => 0, ...$arr1, ...$arr2];
var_dump($arr3); // ["a" => 2]

// Целочисленный ключ
$arr4 = [1, 2, 3];
$arr5 = [4, 5, 6];
$arr6 = [...$arr4, ...$arr5];
var_dump($arr6); // [1, 2, 3, 4, 5, 6]
// Распаковка массивов создаёт массив [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6],
// в котором исходные целочисленные ключи не сохраняются

?>

Замечание:

Ключи, которые не принадлежат ни целочисленному, ни строковому типу, выбрасывают ошибку TypeError. Такие ключи генерируют только объекты, класс которых реализует интерфейс Traversable.

Замечание:

До PHP 8.1 распаковка массива со строковым ключом не поддерживалась:

<?php

$arr1
= [1, 2, 3];
$arr2 = ['a' => 4];
$arr3 = [...$arr1, ...$arr2];
// Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5
$arr4 = [1, 2, 3];
$arr5 = [4, 5];
$arr6 = [...$arr4, ...$arr5]; // работает. [1, 2, 3, 4, 5]

?>

Примеры

Массив в PHP — гибкий тип данных. Вот несколько примеров:

Пример #23 Видимость массивов

<?php

// Код:
$a = array( 'color' => 'красный',
'taste' => 'сладкий',
'shape' => 'круг',
'name' => 'яблоко',
4 // PHP назначит элементу ключ 0
);

$b = array('a', 'b', 'c');

var_dump($a, $b);

// ...эквивалентен следующему коду:
$a = array();
$a['color'] = 'красный';
$a['taste'] = 'сладкий';
$a['shape'] = 'круг';
$a['name'] = 'яблоко';
$a[] = 4; // ключом станет 0

$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';

// После выполнения приведённого кода переменная $a станет массивом
// array('color' => 'красный', 'taste' => 'сладкий', 'shape' => 'круг',
// 'name' => 'яблоко', 0 => 4), а переменная $b станет массивом
// array(0 => 'a', 1 => 'b', 2 => 'c'), или просто array('a', 'b', 'c')

var_dump($a, $b);

?>

Пример #24 Вызов языковой конструкции array()

<?php

// Массив как карта (свойств)
$map = array(
'version' => 4,
'OS' => 'Linux',
'lang' => 'english',
'short_tags' => true
);

var_dump($map);

// Строго числовые ключи,
// что эквивалентно массиву array(0 => 7, 1 => 8, ...)
$array = array(
7,
8,
0,
156,
-
10
);
var_dump($array);

$switching = array(
10, // ключ = 0
5 => 6,
3 => 7,
'a' => 4,
11, // ключ = 6 (максимальным числовым индексом было 5)
'8' => 2, // ключ = 8 (число!)
'02' => 77, // ключ = '02'
0 => 12 // значение 10 перезапишется значением 12
);
var_dump($switching);

// пустой массив
$empty = array();
var_dump($empty);

?>

Пример #25 Коллекция

<?php

$colors
= array('красный', 'голубой', 'зелёный', 'жёлтый');

foreach (
$colors as $color) {
echo
"Вам нравится $color?\n";
}

?>

Результат выполнения приведённого примера:

Вам нравится красный?
Вам нравится голубой?
Вам нравится зелёный?
Вам нравится жёлтый?

Непосредственное изменение значений массива допустимо через передачу значений по ссылке.

Пример #26 Изменение элемента в цикле

<?php

$colors
= array('red', 'blue', 'green', 'yellow');

foreach (
$colors as &$color) {
$color = mb_strtoupper($color);
}
unset(
$color); /* Переменную удаляют, чтобы очередные записи
в переменной $color не меняли последний элемент массива */

print_r($colors);

?>

Результат выполнения приведённого примера:

Array
(
    [0] => КРАСНЫЙ
    [1] => ГОЛУБОЙ
    [2] => ЗЕЛЁНЫЙ
    [3] => ЖЁЛТЫЙ
)

Следующий пример создаёт массив, индексация которого начинается с единицы.

Пример #27 Индексация с единицы

<?php

$firstquarter
= array(1 => 'январь', 'февраль', 'март');
print_r($firstquarter);

?>

Результат выполнения приведённого примера:

Array
(
    [1] => 'январь'
    [2] => 'февраль'
    [3] => 'март'
)

Пример #28 Заполнение массива

<?php

// Заполняем массив элементами из директории
$handle = opendir('.');
while (
false !== ($file = readdir($handle))) {
$files[] = $file;
}
closedir($handle);

var_dump($files);

?>

Массивы упорядочены. Порядок изменяют разными функциями сортировки. Подробнее об этом рассказано в разделе «Функции для работы с массивами». Для подсчёта количества элементов в массиве вызывают функцию count().

Пример #29 Сортировка массива

<?php

sort
($files);
print_r($files);

?>

Массивы поддерживают значения в виде других массивов, поскольку массивы принимают произвольные значения. Поэтому PHP разрешает создавать рекурсивные и многомерные массивы.

Пример #30 Рекурсивные и многомерные массивы

<?php

$fruits
= array ( "fruits" => array ( "a" => "апельсин",
"b" => "банан",
"c" => "яблоко"
),
"numbers" => array ( 1,
2,
3,
4,
5,
6
),
"holes" => array ( "первая",
5 => "вторая",
"третья"
)
);
var_dump($fruits);

// Ряд примеров доступа к значениям предыдущего массива
echo $fruits["holes"][5]; // Выведет "вторая"
echo $fruits["fruits"]["a"]; // напечатает "апельсин"
unset($fruits["holes"][0]); // удалит "первая"

// Создаст новый многомерный массив
$juices["apple"]["green"] = "хороший";
var_dump($juices);

?>

Присваивание массива включает копирование значения. Чтобы скопировать массив по ссылке, указывают оператор присваивания по ссылке.

Пример #31 Копирование массивов

<?php

$arr1
= array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // Массив $arr2 изменился,
// Массив $arr1 всё ещё выглядит так: array(2, 3)

$arr3 = &$arr1;
$arr3[] = 4; // Теперь массивы $arr1 и $arr3 одинаковы

var_dump($arr1, $arr2, $arr3);

?>
Добавить

Примечания пользователей 5 notes

up
126
mlvljr
14 years ago
please note that when arrays are copied, the "reference status" of their members is preserved (http://www.php.net/manual/en/language.references.whatdo.php).
up
76
thomas tulinsky
9 years ago
I think your first, main example is needlessly confusing, very confusing to newbies:

$array = array(
"foo" => "bar",
"bar" => "foo",
);

It should be removed.

For newbies:
An array index can be any string value, even a value that is also a value in the array.
The value of array["foo"] is "bar".
The value of array["bar"] is "foo"

The following expressions are both true:
$array["foo"] == "bar"
$array["bar"] == "foo"
up
58
ken underscore yap atsign email dot com
17 years ago
"If you convert a NULL value to an array, you get an empty array."

This turns out to be a useful property. Say you have a search function that returns an array of values on success or NULL if nothing found.

<?php $values = search(...); ?>

Now you want to merge the array with another array. What do we do if $values is NULL? No problem:

<?php $combined = array_merge((array)$values, $other); ?>

Voila.
up
58
jeff splat codedread splot com
20 years ago
Beware that if you're using strings as indices in the $_POST array, that periods are transformed into underscores:

<html>
<body>
<?php
printf
("POST: "); print_r($_POST); printf("<br/>");
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<input type="hidden" name="Windows3.1" value="Sux">
<input type="submit" value="Click" />
</form>
</body>
</html>

Once you click on the button, the page displays the following:

POST: Array ( [Windows3_1] => Sux )
up
37
chris at ocportal dot com
12 years ago
Note that array value buckets are reference-safe, even through serialization.

<?php
$x
='initial';
$test=array('A'=>&$x,'B'=>&$x);
$test=unserialize(serialize($test));
$test['A']='changed';
echo
$test['B']; // Outputs "changed"
?>

This can be useful in some cases, for example saving RAM within complex structures.
To Top