Массивы в PHP – подробное руководство с примерами

Массивы в PHP хранят упорядоченные пары «ключ – значение». Запись $fruits = ['apple', 'pear']; создает список, а $fruits[0] возвращает первый элемент. В статье вы найдете рабочие примеры для создания, перебора, поиска, удаления, сортировки и преобразования массивов.

Содержание

Что такое массив в PHP

Массив в PHP хранит упорядоченную карту «ключ – значение». Ключ имеет тип int или string, а значение может быть строкой, числом, объектом, null или другим массивом.

PHP сохраняет порядок добавления элементов. Числовой ключ сам по себе не сортирует значения. Повторная запись по существующему ключу заменяет его значение.

$data = [
    'name' => 'Anna',
    'age' => 25,
    'tags' => ['php', 'html'],
];

echo $data['name'], ' ', $data['tags'][0];
// Вывод: Anna php

Строка '8' становится числовым ключом 8, а строка '08' сохраняет строковый тип. Подробные правила описывает документация PHP по массивам.

Как создать массив: [] и array()

Короткий синтаксис [] появился в PHP 5.4 и подходит для нового кода. Запись array() встречается в старых проектах и создает такой же массив.

$empty = [];
$fruits = ['apple', 'pear'];
$oldStyle = array('apple', 'pear');
$labels = [10 => 'first', 20 => 'second'];

echo count($empty), PHP_EOL;
var_dump($fruits === $oldStyle);
echo $labels[20], PHP_EOL;
// Вывод:
// 0
// bool(true)
// second

Без явных ключей индексация начинается с нуля. Явные ключи могут иметь пропуски, поэтому $labels[20] доступен без элементов от 0 до 19.

Типы массивов: индексные, ассоциативные, многомерные

Тип структуры выбирайте по задаче. Список хранит последовательность, ассоциативный массив связывает имена с данными, а вложенный массив объединяет связанные группы.

ТипКакие ключиПример объявленияОбращение
ИндексныйЦелочисленные; у списка – подряд от нуля$a = ['apple', 'pear'];$a[0]
АссоциативныйСтроковые имена$a = ['name' => 'Anna'];$a['name']
МногомерныйКлючи на каждом уровне$a = ['x' => ['apple']];$a['x'][0]

Индексный массив

Индексный массив хранит значения с целочисленными ключами. Получите нужный элемент по индексу.

$fruits = ['apple', 'pear', 'plum'];
echo $fruits[0], ' ', $fruits[2];
// Вывод: apple plum

Ассоциативный массив PHP

Ассоциативный массив PHP связывает понятное имя поля с его значением. Такой формат подходит для данных пользователя и параметров формы.

$user = ['name' => 'Anna', 'age' => 25];
echo $user['name'], ': ', $user['age'];
// Вывод: Anna: 25

Суперглобальные массивы $_GET и $_POST содержат параметры запроса. Считайте данные формы недоверенными и проверяйте их перед обработкой.

$name = $_GET['name'] ?? 'Guest';
$name = is_string($name) ? $name : 'Guest';
echo htmlspecialchars($name, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
// Для запроса ?name=Anna вывод: Anna

Многомерный массив

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

Схема вложенности многомерного массива с Дэвидом, Ричи, Мейсоном и их детьми
$david = [
    'Richie' => ['Sue', 'Natasha'],
    'Mason' => ['Nichole', 'Salma', 'Amber'],
];

echo $david['Richie'][0], PHP_EOL;
foreach ($david as $parent => $children) {
    foreach ($children as $child) {
        echo $parent, ': ', $child, PHP_EOL;
    }
}
// Вывод:
// Sue
// Richie: Sue
// Richie: Natasha
// Mason: Nichole
// Mason: Salma
// Mason: Amber

Как добавить элемент в массив

Запись $a[] = ... добавляет одно значение в конец и назначает следующий целочисленный ключ.

$fruits = ['apple'];
$fruits[] = 'pear';
echo implode(', ', $fruits);
// Вывод: apple, pear

Функция PHP array_push() добавляет сразу несколько значений и возвращает новую длину массива.

$fruits = ['apple'];
$length = array_push($fruits, 'pear', 'plum');
echo $length, ': ', implode(', ', $fruits);
// Вывод: 3: apple, pear, plum

Чтобы добавить элемент в массив PHP, выбирайте способ по его позиции. Функция array_unshift() ставит элементы в начало массива и переиндексирует числовые ключи.

$fruits = ['pear', 'plum'];
array_unshift($fruits, 'apple');
$user = ['name' => 'Anna'];
$user['city'] = 'Kazan';
echo implode(', ', $fruits), PHP_EOL;
echo $user['city'];
// Вывод:
// apple, pear, plum
// Kazan

Оператор распаковки ... собирает новый массив. Распаковка массивов со строковыми ключами работает с PHP 8.1. При совпадении строкового ключа последнее значение заменяет предыдущее.

$base = ['apple', 'pear'];
$fruits = [...$base, 'plum'];
$settings = [...['theme' => 'light'], 'theme' => 'dark'];
echo implode(', ', $fruits), PHP_EOL;
echo $settings['theme'];
// Вывод:
// apple, pear, plum
// dark

Как посчитать количество элементов в массиве PHP через count()

В PHP длина массива определяется функцией count(): она возвращает количество элементов верхнего уровня.

$fruits = ['apple', 'pear', 'plum'];
echo count($fruits), ' ', sizeof($fruits), PHP_EOL;
$groups = [['apple', 'pear'], ['plum']];
echo count($groups), ' ', count($groups, COUNT_RECURSIVE);
// Вывод:
// 3 3
// 2 5

sizeof() – алиас count(). Обычный вызов считает верхний уровень, а COUNT_RECURSIVE учитывает вложенные элементы.

Сохраните результат count() перед циклом for, если список не меняется. Так код не считает длину на каждой итерации.

$numbers = [10, 20, 30];
$length = count($numbers);
for ($i = 0; $i < $length; $i++) {
    echo $numbers[$i], PHP_EOL;
}
// Вывод:
// 10
// 20
// 30

Перебор массива в PHP через foreach и for

Выбирайте цикл по структуре данных. foreach подходит для списков и ассоциативных массивов, а for – для последовательных индексов.

$fruits = ['apple', 'pear'];
foreach ($fruits as $fruit) {
    echo $fruit, PHP_EOL;
}
$user = ['name' => 'Anna', 'city' => 'Kazan'];
foreach ($user as $key => $value) {
    echo $key, '=', $value, PHP_EOL;
}
// Вывод:
// apple
// pear
// name=Anna
// city=Kazan

Перебор по ссылке меняет исходные элементы. После такого цикла вызовите unset($value), чтобы ссылка не осталась привязанной к последнему элементу.

$numbers = [1, 2, 3];
foreach ($numbers as &$value) {
    $value *= 2;
}
unset($value);
echo implode(', ', $numbers);
// Вывод: 2, 4, 6

Цикл for работает со списком индексов от 0. Оператор continue пропускает текущую итерацию, а break завершает цикл.

$numbers = [10, 20, 30, 40];
$length = count($numbers);
for ($i = 0; $i < $length; $i++) {
    if ($numbers[$i] === 20) {
        continue;
    }
    if ($numbers[$i] === 40) {
        break;
    }
    echo $numbers[$i], PHP_EOL;
}
// Вывод:
// 10
// 30

Функция each() устарела в PHP 7.2 и удалена в PHP 8.0. Конструкции list() и [] применяют для деструктуризации внутри foreach, но они не заменяют сам цикл.

$rows = [[1, 'apple'], [2, 'pear']];
foreach ($rows as [$id, $name]) {
    echo $id, ': ', $name, PHP_EOL;
}
// Вывод:
// 1: apple
// 2: pear

Начало и конец массива

Функции array_shift() и array_pop() извлекают элементы с краев и изменяют исходный массив.

$fruits = [5 => 'apple', 9 => 'pear', 12 => 'plum'];
$first = array_shift($fruits);
$last = array_pop($fruits);
echo $first, ' / ', $last, PHP_EOL;
echo json_encode($fruits);
// Вывод:
// apple / plum
// ["pear"]

array_shift() переиндексирует оставшиеся числовые ключи. array_pop() удаляет последний элемент и сохраняет ключи остальных.

Функции array_key_first() и array_key_last() появились в PHP 7.3. Они возвращают крайние ключи без удаления. Функции reset() и end() возвращают крайние значения и меняют внутренний указатель.

$scores = ['Anna' => 90, 'Maria' => 60];
echo array_key_first($scores), ': ', reset($scores), PHP_EOL;
echo array_key_last($scores), ': ', end($scores);
// Вывод:
// Anna: 90
// Maria: 60

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

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

$fruits = ['apple', 'pear', 'plum'];
unset($fruits[1]);
echo json_encode($fruits), PHP_EOL;
$fruits = array_values($fruits);
echo json_encode($fruits);
// Вывод:
// {"0":"apple","2":"plum"}
// ["apple","plum"]

Используйте array_values(), когда после удаления списку нужны новые индексы. Функция array_splice() удаляет участок по позиции и сразу переиндексирует числовые ключи.

$fruits = ['apple', 'pear', 'plum'];
$removed = array_splice($fruits, 1, 1);
echo implode(', ', $removed), PHP_EOL;
echo implode(', ', $fruits);
// Вывод:
// pear
// apple, plum

Для удаления первого совпадения найдите ключ через array_search(). Сравнивайте результат с false строго, потому что найденный ключ может быть равен 0.

$fruits = ['apple', 'pear', 'apple'];
$key = array_search('apple', $fruits, true);
if ($key !== false) {
    unset($fruits[$key]);
}
echo implode(', ', $fruits);
// Вывод: pear, apple

Все совпадения удаляет array_filter(). Функция сохраняет исходные ключи, поэтому для списка добавьте array_values().

$fruits = ['apple', 'pear', 'apple'];
$fruits = array_values(array_filter(
    $fruits,
    fn($fruit) => $fruit !== 'apple'
));
echo json_encode($fruits);
// Вывод: ["pear"]

Как проверить тип массива и найти ключ или значение

Функция PHP is_array() проверяет, является ли значение массивом. Значение ищет in_array(), ключ возвращает array_search(), а наличие самого ключа проверяет array_key_exists().

$values = ['10', 'apple'];
var_dump(is_array($values));
var_dump(in_array(10, $values, true));
var_dump(in_array('10', $values, true));
// Вывод:
// bool(true)
// bool(false)
// bool(true)

Третий аргумент true включает строгое сравнение типов. Без него число и строка могут считаться одинаковыми.

$fruits = ['apple', 'pear'];
$key = array_search('apple', $fruits, true);
var_dump($key, $key !== false);
// Вывод:
// int(0)
// bool(true)

Не пишите if ($key): такое условие отвергнет найденный ключ 0.

$user = ['name' => null];
var_dump(array_key_exists('name', $user));
var_dump(isset($user['name']));
var_dump(isset($user['city']));
// Вывод:
// bool(true)
// bool(false)
// bool(false)

array_key_exists() находит ключ со значением null. isset() возвращает false для такого значения. Функция array_is_list() доступна с PHP 8.1 и проверяет последовательность ключей от нуля.

var_dump(array_is_list(['apple', 'pear']));
var_dump(array_is_list([1 => 'apple']));
var_dump(array_is_list([]));
// Вывод:
// bool(true)
// bool(false)
// bool(true)

PHP массив в строку и обратно

Чтобы преобразовать массив в строку PHP, используйте implode(), если нужен простой список. Для обмена структурированными данными подойдет JSON. Для сохранения PHP-типов используйте сериализацию.

$fruits = ['apple', 'pear'];
$text = implode(', ', $fruits);
echo $text, PHP_EOL;
echo join(' / ', $fruits), PHP_EOL;
$restored = explode(', ', $text);
echo $restored[1];
// Вывод:
// apple, pear
// apple / pear
// pear

implode() и ее алиас join() соединяют значения. explode() разбивает строку по разделителю, но не восстанавливает исходные ключи и типы. Функция str_split() разбивает строку на части по байтам.

$letters = str_split('PHP');
echo implode('-', $letters);
// Вывод: P-H-P
$user = ['name' => 'Anna', 'age' => 25];
$json = json_encode($user, JSON_THROW_ON_ERROR);
$restored = json_decode($json, true, 512, JSON_THROW_ON_ERROR);
echo $json, PHP_EOL;
echo $restored['age'];
// Вывод:
// {"name":"Anna","age":25}
// 25

Функции serialize() и unserialize() подходят для внутреннего хранения PHP-структур. Строку из недоверенного источника не передавайте в unserialize().

$numbers = [10, 20];
$saved = serialize($numbers);
$restored = unserialize($saved, ['allowed_classes' => false]);
echo $saved, PHP_EOL;
echo implode(', ', $restored);
// Вывод:
// a:2:{i:0;i:10;i:1;i:20;}
// 10, 20

Предупреждение «Array to string conversion» появляется, когда код передает массив в echo. Выведите элемент, примените implode() или вызовите json_encode().

Сортировка массивов

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

ФункцияКлючиСортировка
sort()СбрасываетЗначения по возрастанию
rsort()СбрасываетЗначения по убыванию
asort()СохраняетЗначения по возрастанию
arsort()СохраняетЗначения по убыванию
ksort()СохраняетКлючи по возрастанию
krsort()СохраняетКлючи по убыванию
usort()СбрасываетПо функции сравнения
$numbers = [30, 10, 20];
sort($numbers, SORT_NUMERIC);
echo implode(', ', $numbers), PHP_EOL;
rsort($numbers, SORT_NUMERIC);
echo implode(', ', $numbers);
// Вывод:
// 10, 20, 30
// 30, 20, 10

asort() сохраняет связь ключа со значением, а ksort() сортирует ключи.

$scores = ['b' => 20, 'a' => 30, 'c' => 10];
asort($scores, SORT_NUMERIC);
echo json_encode($scores), PHP_EOL;
ksort($scores, SORT_STRING);
echo json_encode($scores);
// Вывод:
// {"c":10,"b":20,"a":30}
// {"a":30,"b":20,"c":10}

usort() принимает собственное правило сравнения. Оператор <=> возвращает результат сравнения двух значений.

$users = [
    ['name' => 'Anna', 'age' => 30],
    ['name' => 'Maria', 'age' => 20],
];
usort($users, fn($a, $b) => $a['age'] <=> $b['age']);
echo implode(', ', array_column($users, 'name'));
// Вывод: Maria, Anna

Объединение и сравнение массивов

Функция array_merge() заменяет одинаковые строковые ключи правыми значениями и переиндексирует числовые ключи. Оператор + сохраняет левый массив при совпадении ключей.

$left = [0 => 'apple', 'color' => 'red'];
$right = [0 => 'pear', 'color' => 'green', 'size' => 'M'];
echo json_encode(array_merge($left, $right)), PHP_EOL;
echo json_encode($left + $right);
// Вывод:
// {"0":"apple","color":"green","1":"pear","size":"M"}
// {"0":"apple","color":"red","size":"M"}

Для списков берите array_merge(), а для конфигураций с приоритетом левого массива – оператор +.

$keys = ['name', 'city'];
$values = ['Anna', 'Kazan'];
echo json_encode(array_combine($keys, $values));
// Вывод: {"name":"Anna","city":"Kazan"}

array_combine() берет ключи из первого массива, а значения из второго. Количество элементов в массивах должно совпадать.

$a = ['x' => 'apple', 'y' => 'pear'];
$b = ['y' => 'apple', 'z' => 'plum'];
echo json_encode(array_diff($a, $b)), PHP_EOL;
echo json_encode(array_diff_key($a, $b)), PHP_EOL;
echo json_encode(array_intersect($a, $b));
// Вывод:
// {"y":"pear"}
// {"x":"apple"}
// {"x":"apple"}

array_diff() сравнивает значения, array_diff_key() – ключи, а array_intersect() оставляет общие значения. Эти функции сохраняют ключи первого массива.

$a = ['x' => 1, 'y' => 2];
$b = ['y' => 2, 'x' => 1];
var_dump($a == $b);
var_dump($a === $b);
var_dump(['x' => 1] === ['x' => '1']);
// Вывод:
// bool(true)
// bool(false)
// bool(false)

Оператор == не учитывает порядок пар, а === требует одинаковые ключи, значения, типы и порядок.

Полезные функции работы с массивами

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

Уникальные значения и сумма элементов

array_unique() оставляет первое значение каждого повтора и сохраняет его ключ. array_sum() складывает элементы массива.

$numbers = [10, 20, 10];
$unique = array_unique($numbers);
echo json_encode(array_values($unique)), PHP_EOL;
echo array_sum($numbers);
// Вывод:
// [10,20]
// 40

Преобразование, фильтрация и накопление

array_map() преобразует значения через обработчик и возвращает результат. array_filter() оставляет подходящие элементы, а array_reduce() сводит массив к одному результату.

$numbers = [1, 2, 3, 4];
$doubled = array_map(fn($n) => $n * 2, $numbers);
$even = array_filter($numbers, fn($n) => $n % 2 === 0);
$product = array_reduce($numbers, fn($carry, $n) => $carry * $n, 1);
echo json_encode($doubled), PHP_EOL;
echo json_encode(array_values($even)), PHP_EOL;
echo $product;
// Вывод:
// [2,4,6,8]
// [2,4]
// 24

Без обработчика array_filter() удаляет значения, которые приводятся к false, включая 0 и строку '0'.

Ключи, значения, срезы и столбцы

array_keys() возвращает ключи, array_values() – значения, а array_slice() извлекает участок без изменения исходного массива.

$scores = ['Anna' => 90, 'Maria' => 60];
echo json_encode(array_keys($scores)), PHP_EOL;
echo json_encode(array_values($scores)), PHP_EOL;
echo json_encode(array_slice(['apple', 'pear', 'plum'], 1, 2));
// Вывод:
// ["Anna","Maria"]
// [90,60]
// ["pear","plum"]

array_column() извлекает поле из набора записей. Третий аргумент задает ключи результата.

$users = [
    ['id' => 10, 'name' => 'Anna'],
    ['id' => 20, 'name' => 'Maria'],
];
echo json_encode(array_column($users, 'name', 'id'));
// Вывод: {"10":"Anna","20":"Maria"}

Обмен ключей и создание последовательностей

array_flip() меняет местами ключи и значения. array_fill() создает одинаковые элементы, а range() строит числовую последовательность.

$codes = ['first' => 'A', 'second' => 'B'];
echo json_encode(array_flip($codes)), PHP_EOL;
echo json_encode(array_fill(0, 3, 'apple')), PHP_EOL;
echo json_encode(range(2, 6, 2));
// Вывод:
// {"A":"first","B":"second"}
// ["apple","apple","apple"]
// [2,4,6]

Вывод массива для отладки

Функции print_r(), var_dump() и var_export() показывают структуру массива. Выбирайте инструмент по тому, нужны ли типы или готовый PHP-синтаксис.

ИнструментЧто показываетВозвращает строку
print_r()Ключи, значения, вложенностьДа, с аргументом true
var_dump()Типы, длины строк, структуруНет отдельного режима
var_export()Синтаксис PHPДа, с аргументом true
$output = print_r(['apple'], true);
echo $output;
// Вывод:
// Array
// (
//     [0] => apple
// )
var_dump([10, '10']);
// Вывод:
// array(2) {
//   [0]=>
//   int(10)
//   [1]=>
//   string(2) "10"
// }
echo var_export(['apple'], true);
// Вывод:
// array (
//   0 => 'apple',
// )

Не выводите отладочные данные посетителям рабочего сайта. Массив может содержать токены, персональные данные и внутренние настройки.

Ошибки при работе с массивами в PHP

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

Обращение к отсутствующему ключу

В PHP 8 чтение отсутствующего ключа вызывает Warning «Undefined array key». Оператор ?? подставляет значение по умолчанию.

$user = [];
echo $user['name'] ?? 'Guest';
// Вывод: Guest

Если null имеет отдельный смысл, применяйте array_key_exists(). Конструкции isset() и ?? считают отсутствие ключа и значение null одинаковым случаем.

Попытка вывести массив как строку

Выражение echo $array вызывает «Array to string conversion». Для списка используйте implode(), для структуры – json_encode(), а для отладки – print_r() или var_dump().

Изменение переменной цикла

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

$numbers = [1, 2];
foreach ($numbers as $value) {
    $value *= 10;
}
echo implode(', ', $numbers), PHP_EOL;
foreach ($numbers as $key => $value) {
    $numbers[$key] = $value * 10;
}
echo implode(', ', $numbers);
// Вывод:
// 1, 2
// 10, 20

Оставшаяся ссылка после foreach

После цикла по ссылке переменная остается связанной с последним элементом. Сразу вызовите unset().

$numbers = [1, 2];
foreach ($numbers as &$value) {
    $value *= 10;
}
unset($value);
echo implode(', ', $numbers);
// Вывод: 10, 20

Путаница array_merge и +

Оператор + не соединяет два списка подряд. При одинаковом числовом ключе он оставляет элемент слева, поэтому для списков применяйте array_merge().

echo json_encode(['apple'] + ['pear']), PHP_EOL;
echo json_encode(array_merge(['apple'], ['pear']));
// Вывод:
// ["apple"]
// ["apple","pear"]

Нестрогий поиск значения

Без строгого режима in_array() может сравнить число и строку как равные. Передайте true третьим аргументом, когда тип важен.

var_dump(in_array(10, ['10']));
var_dump(in_array(10, ['10'], true));
// Вывод:
// bool(true)
// bool(false)

Массивы в PHP проще использовать, когда структура ключей определена заранее. Для списка берите [], $a[] и foreach. После удаления решите, нужны ли исходные индексы, а результат поиска проверяйте через !== false.

При непонятной ошибке вызовите var_dump() и посмотрите ключи и типы значений.

Комментарии

Оставьте свой комментарий
Пока никто не оставил комментариев