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

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

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

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

Замечание:

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

<?php

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

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

var_dump($array1, $array2);

В PHP массивы поддерживают только целочисленные (int) и строковые (string) ключи. Тип значений не ограничивается.

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

• Строки (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 перезаписывает значение элемента, если встречает в объявлении массива повтор одного и того же ключа, поэтому в массиве остается только последний такой элемент.

<?php

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

var_dump($array);

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

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

<?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)
}

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

<?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"
}

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

<?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"
}

<?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"
}

<?php

$array = [];

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

var_dump($array);

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

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

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

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

<?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.

<?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().

<?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);

Замечание: Если ключ не указан, новым ключом станет максимальный существующий целочисленный индекс + 1. Если в массиве нет положительных целочисленных индексов, ключом станет 0. Начиная с PHP 8.3.0 это также может быть отрицательное целое число.

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

<?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(). Эти языковые конструкции разрешено использовать для деструктуризации массива на отдельные переменные.

<?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 для деструктуризации многомерного массива во время итерации по массиву.

<?php

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

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

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

<?php

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

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

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

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

<?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"

Массив деструктурируют, чтобы поменять две переменные местами.

<?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.

Замечание:

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

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

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

<?php

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

Неправильно записывать ключ без кавычек, хотя такой код и работает. Причина заключается в интерпретации незакавыченного ключа как неопределённой константы bar, а не строки 'bar' — литерала в кавычках. Код работает из-за автоматического преобразования «голой строки» — строки без кавычек, которая не соответствует ни одному известному символу, — в строку со значением такой «голой строки». PHP подставит вместо bar строку 'bar', если в текущей области видимости недоступна константа с названием bar.

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

<?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

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

<?php

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

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

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

// Неверно. Это не работает и выбрасывает PHP-ошибку Error из-за неопределённой константы
// с названием fruit
//
// Error: Undefined constant "fruit"
try {
    echo $arr[fruit];
} 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 не ищет константы внутри строк,
// поэтому ошибка здесь не возникнет
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']";

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

<?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 и т. д.