PHP: полный мануал с примерами, функциями и ООП

<?php
$stock = [0, 3, 0, 7];
$available = array_filter($stock, function ($value) {
    return $value > 0;
});
foreach ($available as $originalPosition => $quantity) {
    echo 'Исходная позиция ', $originalPosition, ': доступно ', $quantity, ' шт.', "\n";
}
$list = array_values($available);
echo 'Первая доступная величина нового списка: ', $list[0], ' шт.', "\n";

Исходная позиция 1: доступно 3 шт.
Исходная позиция 3: доступно 7 шт.
Первая доступная величина нового списка: 3 шт.

При значениях 0 и 0 callback возвращает false, при 3 и 7 — true. Array_filter сохраняет оригинальные ключи 1 и 3. Foreach выводит обе оставшиеся величины, после чего array_values создаёт отдельный список с индексами 0 и 1. Переиндексация уместна для технических позиций, но уничтожила бы смысл ключей, если бы ими были id товаров.

<?php
$measurements = [0, '0', null, false, '', 5];
echo json_encode(array_values(array_filter($measurements))), "
";
echo json_encode(array_values(array_filter($measurements,
    function ($value) { return $value !== null; }))), "
";

[5]
[0,"0",false,"",5]

Отсутствующее измерение и измеренный ноль — разные состояния; условие выбрано из договора данных.

<?php
$form = ['name' => 'Ada', 'role' => 'admin', 'note' => ''];
$allowed = array_filter($form, function ($key) {
    return in_array($key, ['name','note'], true);
}, ARRAY_FILTER_USE_KEY);
$filled = array_filter($allowed, function ($value, $key) {
    return $key === 'name' && $value !== '';
}, ARRAY_FILTER_USE_BOTH);
echo json_encode($filled), "
";

{"name":"Ada"}

Отбор полей не заменяет проверку типов, длины и прав. Порядок параметров режима BOTH: сначала значение, затем ключ.

<?php
declare(strict_types=1);

$stocks = ['A' => 0, 'B' => null, 'C' => 7];
$known = array_filter($stocks, static fn ($stock): bool => $stock !== null);
echo json_encode($known, JSON_THROW_ON_ERROR), "\n";

{"A":0,"C":7}

У поставщика null означает «не сообщил»,0 — «нет в наличии». Явный критерий сохраняет эту разницу и связь с артикулом.

<?php
declare(strict_types=1);

$profile = ['name' => 'Ann', 'email' => 'a@example.test', 'internalNote' => 'review'];
$public = array_filter($profile, static fn (string $key): bool => in_array($key, ['name', 'email'], true), ARRAY_FILTER_USE_KEY);
echo implode(',', array_keys($public)), "\n";

name,email

Фильтр по ключу реализует разрешенный список. Для сложного API явное построение ответа еще нагляднее; не публикуйте все поля по умолчанию.

<?php
$prices = [40 => 100, 70 => 250];
$changed = array_map(function ($price) {
    return $price + 20;
}, $prices);
foreach ($changed as $id => $newPrice) {
    echo 'Товар ', $id, ': ', $prices[$id], ' → ', $newPrice, ' коп.', "\n";
}

Товар 40: 100 → 120 коп.
Товар 70: 250 → 270 коп.

Map передаёт callback сначала 100, затем 250. Return создаёт соответственно 120 и 270; map сохраняет ключи 40 и 70, потому что входной массив один. Changed получает новый прайс, а prices хранит старый и используется в отчёте. Callback не получает ключ автоматически; внешний foreach получает его из результата.

<?php
$codes = ['p1','p2'];
$amounts = [4];
echo json_encode(array_map(null, $codes, $amounts)), "
";
if (count($codes) !== count($amounts)) {
    echo "Импорт отклонён: длины колонок различаются
";
}

[["p1",4],["p2",null]]
Импорт отклонён: длины колонок различаются

Функция не останавливается на коротком списке, как Python zip. Для строгого импорта сначала проверяйте длины.

<?php
$totals = array_map(function ($price, $quantity) {
    return $price * $quantity;
}, [100, 250], [3, 2]);
echo json_encode($totals), "
";
echo json_encode(array_map(null, ['id' => 5])), "
";

[300,500]
{"id":5}

Первый аргумент callback берётся из первой колонки, второй — из второй. При нескольких входах их ключи не используются для соединения записей.

<?php
declare(strict_types=1);

$tags = [' PHP ', ' API '];
$normalized = array_map('trim', $tags);
echo implode('|', $normalized), "\n";

PHP|API

Передаем имя функции как callback. Это подходит для уже проверенного списка строк; массив или null внутри списка требуют валидации на входе.

<?php
declare(strict_types=1);

$rows = [['id' => 7, 'name' => 'Tea', 'secret' => 'x']];
$cards = array_map(static fn (array $row): array => ['id' => $row['id'], 'title' => $row['name']], $rows);
echo json_encode($cards, JSON_THROW_ON_ERROR), "\n";

[{"id":7,"title":"Tea"}]

Выбираем только публичные поля. Функция превращает внутренние записи в представление API и не тащит служебный secret в ответ.

<?php
$sum = array_reduce([100, 250], function ($carry, $item) {
    echo $carry, '+', $item, "
";
    return $carry + $item;
}, 0);
echo 'Итого: ', $sum, "
";
var_dump(array_reduce([], function ($a, $b) { return $a + $b; }));

0+100
100+250
Итого: 350
NULL

Для простого сложения array_sum короче. Здесь виден договор каждого шага.

<?php
$lines = [['price' => 150, 'quantity' => 2], ['price' => 80, 'quantity' => 3]];
$itemsTotalKopecks = array_reduce($lines, function ($sum, $line) {
    $lineTotal = $line['price'] * $line['quantity'];
    return $sum + $lineTotal;
}, 0);
$deliveryKopecks = 50;
$payableKopecks = $itemsTotalKopecks + $deliveryKopecks;
echo 'Товары: ', $itemsTotalKopecks, ' коп.', "\n";
echo 'Доставка: ', $deliveryKopecks, ' коп.', "\n";
echo 'К оплате: ', $payableKopecks, ' коп.', "\n";
$emptyTotal = array_reduce([], function ($sum, $line) { return $sum; }, 0);
echo 'Товары в пустой корзине: ', $emptyTotal, ' коп.', "\n";

Товары: 540 коп.
Доставка: 50 коп.
К оплате: 590 коп.
Товары в пустой корзине: 0 коп.

Initial 0 становится первым sum. Строка 150 × 2 даёт 300; return 300 поступает в sum следующего callback. Строка 80 × 3 даёт 240, следующий return равен 540. Array_reduce возвращает 540 в itemsTotalKopecks; обычный код прибавляет 50. Пустой вход не вызывает callback и возвращает initial 0. Все поля примера заранее проверены по форме и единицам.

<?php
declare(strict_types=1);

$items = [['price' => 15000, 'qty' => 2], ['price' => 9900, 'qty' => 1]];
$total = array_reduce($items, static fn (int $sum, array $item): int => $sum + $item['price'] * $item['qty'], 0);
echo $total, "\n";

39900

Начальное 0 гарантирует числовой итог и для пустой корзины. Ограничения полей проверяются до агрегации; не используйте float для копеек.

<?php
declare(strict_types=1);

$tasks = [['overdue' => false], ['overdue' => true]];
$hasOverdue = array_reduce($tasks, static fn (bool $found, array $task): bool => $found || $task['overdue'], false);
echo $hasOverdue ? "Нужно внимание\n" : "Все вовремя\n";

Нужно внимание

Это показывает bool-накопитель. Reduce все равно вызовет callback для каждого элемента; если важно остановиться на первом совпадении, используйте foreach с break или array_any в PHP 8.4+.

<?php
$rows = [['sku' => 'A', 'stock' => 0], ['sku' => 'B', 'stock' => 3]];
$stocksBySku = array_column($rows, 'stock', 'sku');
foreach ($stocksBySku as $sku => $stock) {
    echo $sku, ': ', $stock, ' шт.', "\n";
}
echo 'Для проверки заказа товара B: ', $stocksBySku['B'], ' шт.', "\n";
$codes = array_column($rows, 'sku');
echo 'Первый артикул отдельного списка: ', $codes[0], "\n";

A: 0 шт.
B: 3 шт.
Для проверки заказа товара B: 3 шт.
Первый артикул отдельного списка: A

Stock задаёт содержимое новой ячейки, sku — её ключ: получаются A => 0 и B => 3. Ноль сохранён. Вызов без index_key возвращает обычный список артикулов с 0 и 1. Исходные строки остаются прежними. Если поле отсутствует или sku повторяется, результат может потерять строку: подробный следующий опыт показывает эти границы.

<?php
$rows = [['sku' => 'A', 'stock' => 1], ['sku' => 'B'], ['sku' => 'A', 'stock' => 4]];
echo json_encode(array_column($rows, 'stock', 'sku')), "\n";
$indexed = array_column($rows, null, 'sku');
echo $indexed['A']['stock'], "\n";

{"A":4}
4

Строка B не попала в первый результат, а поздняя A затёрла раннюю. Индекс по ID подходит только при принятой политике уникальности.

<?php
$rows = [(object) ['id' => 41, 'stock' => 0], (object) ['id' => 72, 'stock' => 2]];
$stocks = array_column($rows, 'stock', 'id');
echo json_encode($stocks), "\n";

{"41":0,"72":2}

(object) создаёт простые объекты с публичными свойствами. Функция читает поля, но не вызывает произвольный метод getStock.

<?php
declare(strict_types=1);

$orders = [['id' => 21, 'status' => 'new'], ['id' => 22, 'status' => 'paid']];
echo implode(',', array_column($orders, 'id')), "\n";

21,22

ID можно передать в параметризованный SQL с отдельным плейсхолдером на каждый ID. Не вставляйте готовую строку из implode в сырой SQL.

<?php
declare(strict_types=1);

$products = [['sku' => 'A', 'stock' => 2], ['sku' => 'B', 'stock' => 0]];
$bySku = array_column($products, null, 'sku');
echo $bySku['B']['stock'], "\n";

0

Предполагается проверенная уникальность SKU. Индекс нужен при повторном сопоставлении позиций; это осознанный обмен памяти на отсутствие повторного линейного поиска.

<?php
$saved = ['comment' => 'Позвонить заранее'];
$patch = ['comment' => null];
if (array_key_exists('comment', $patch)) {
    $saved['comment'] = $patch['comment'];
}
echo 'Комментарий: ', $saved['comment'] ?? 'не указан', "\n";
$patch = [];
if (array_key_exists('comment', $patch)) {
    $saved['comment'] = $patch['comment'];
}
echo 'После пустой правки: ', $saved['comment'] ?? 'не указан', "\n";

Комментарий: не указан
После пустой правки: не указан

По договору этой локальной правки null означает очистку. Проверка находит существующий ключ comment и возвращает true даже при null; присваивание действительно очищает значение. Во второй правке ключа нет: false пропускает присваивание. ?? выбирает текст для отсутствующего/null комментария. Isset дал бы false уже в первом случае и помешал бы очистить поле. Тип и разрешённые имена входных полей проверяют отдельно.

<?php
$payload = ['product' => ['stock' => 0]];
var_dump(array_key_exists('stock', $payload));
var_dump(array_key_exists('stock', $payload['product']));
echo $payload['product']['stock'], "\n";

bool(false)
bool(true)
0

Функция не ищет рекурсивно. Форма product здесь известна; для внешнего JSON сначала убедитесь, что product — массив.

<?php
declare(strict_types=1);

$patch = ['phone' => null];
echo array_key_exists('phone', $patch) ? "Обновить поле\n" : "Не менять\n";
echo isset($patch['phone']) ? "Есть значение\n" : "Значение отсутствует\n";

Обновить поле
Значение отсутствует

В PATCH отсутствие поля и явный null могут иметь разные действия. Политику очистки и право изменения проверяют отдельно.

<?php
declare(strict_types=1);

$cache = ['missing-product' => null];
$key = 'missing-product';
echo array_key_exists($key, $cache) ? "Уже искали\n" : "Нужен запрос\n";

Уже искали

Null может означать сохраненное«не найдено». isset заставил бы выполнять поиск повторно. Для долгоживущего кеша добавьте срок действия отрицательного результата.

<?php
$items = [0 => 'A', 2 => 'C'];
$list = array_values($items);
foreach ($list as $position => $name) {
    echo 'Позиция ', $position, ': ', $name, "\n";
}
echo 'Во входе C по-прежнему доступно по ключу 2: ', $items[2], "\n";

Позиция 0: A
Позиция 1: C
Во входе C по-прежнему доступно по ключу 2: C

Values читает A и C в текущем порядке и присваивает новым ячейкам ключи 0 и 1. List получает новый массив; items сохраняет 0 и 2. Это переиндексация, не сортировка и не фильтр. Если важный id существовал только в ключе, он был бы потерян в list.

<?php
$byId = [41 => ['id' => 41, 'status' => 'new'], 72 => ['id' => 72, 'status' => 'paid']];
$rows = array_values($byId);
echo json_encode($rows), "\n";
echo $rows[1]['id'], "\n";

[{"id":41,"status":"new"},{"id":72,"status":"paid"}]
72

Идентификаторы остались внутри каждой записи. Если ID были только ключами, это преобразование потеряло бы их.

<?php
declare(strict_types=1);

$ids = [0 => 10, 2 => 30];
echo json_encode(array_values($ids), JSON_THROW_ON_ERROR), "\n";

[10,30]

Внешний контракт ожидает список, поэтому устраняем дырку индексов. Без этой операции такой массив кодировался бы объектом.

<?php
declare(strict_types=1);

$row = ['sku' => 'A', 'stock' => 5];
$cells = array_values($row);
echo implode(';', $cells), "\n";

A;5

Порядок соответствует порядку элементов массива. В рабочем CSV лучше явно перечислить колонки, а затем fputcsv, чтобы изменение схемы не сдвинуло данные.

<?php
$stocks = ['A' => 0, 'B' => 2, 'C' => 0];
$allCodes = array_keys($stocks);
echo 'Первый известный артикул: ', $allCodes[0], "\n";
$soldOut = array_keys($stocks, 0, true);
foreach ($soldOut as $sku) {
    echo 'Нужно пополнить: ', $sku, "\n";
}

Первый известный артикул: A
Нужно пополнить: A
Нужно пополнить: C

Без второго аргумента keys возвращает все имена A,B,C новым списком. Со значением 0 и strict=true выбирает только ключи элементов int 0: A и C. Это все совпадения, тогда как array_search вернул бы один первый ключ. Функция не меняет сами остатки и не пополняет склад автоматически.

<?php
$states = ['count' => 0, 'code' => '0', 'unknown' => null];
echo json_encode(array_keys($states, 0, true)), "\n";
echo json_encode(array_keys($states, null, true)), "\n";

["count"]
["unknown"]

Фильтр со строгим сравнением отражает реальный договор типа. Без третьего аргумента значения разных типов могут совпасть.

<?php
declare(strict_types=1);

$input = ['name' => 'Ann', 'role' => 'admin'];
$unexpected = array_diff(array_keys($input), ['name']);
echo implode(',', $unexpected), "\n";

role

Разрешенный список предотвращает массовое назначение привилегированного поля. Правильная реакция — игнорирование или ошибка согласно API, а не автоматическое присваивание.

<?php
declare(strict_types=1);

$stocks = ['north' => 0, 'south' => '0', 'west' => 4];
echo implode(',', array_keys($stocks, 0, true)), "\n";

north

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

<?php
$morning = [10 => 'накладная A', 20 => 'накладная B'];
$evening = [10 => 'накладная C'];
$queue = array_merge($morning, $evening);
foreach ($queue as $index => $document) {
    echo 'Позиция ', $index, ': ', $document, "\n";
}
$settings = array_merge(['mode' => 'draft'], ['mode' => 'live']);
echo 'Режим: ', $settings['mode'], "\n";
echo 'Первый исходный ключ 10: ', $morning[10], "\n";

Позиция 0: накладная A
Позиция 1: накладная B
Позиция 2: накладная C
Режим: live
Первый исходный ключ 10: накладная A

Оба числовых ключа 10 обозначают здесь технические позиции: merge добавляет все три документа и назначает 0/1/2. Строковый ключ mode действует иначе: позднее live заменяет draft. Queue и settings — два новых массива, исходные morning/evening не меняются. Если 10 был бы ID одного документа, такая склейка потеряла бы смысл ключа; тогда выбирают replace или оператор + с нужным правилом победителя.

<?php
$pages = [['p1','p2'], ['p3']];
$result = [];
foreach ($pages as $page) { foreach ($page as $id) { $result[] = $id; } }
echo json_encode($result), "\n";
echo json_encode(array_merge(...$pages)), "\n";

["p1","p2","p3"]
["p1","p2","p3"]

... перед массивом разворачивает его в аргументы вызова. Для большого потока прямое добавление избегает повторного слияния растущего результата.

<?php
declare(strict_types=1);

$addressErrors = ['Нет города'];
$contactErrors = ['Нет телефона'];
echo implode('; ', array_merge($addressErrors, $contactErrors)), "\n";

Нет города; Нет телефона

Оба источника — списки сообщений. Их порядок задан аргументами; пустой список естественно вносит ничего.

<?php
declare(strict_types=1);

$base = ['Accept' => 'application/json', 'X-Client' => 'manual'];
$request = ['X-Client' => 'importer'];
echo array_merge($base, $request)['X-Client'], "\n";

importer

Это обычный словарь конфигурации; реальные HTTP-заголовки регистр независимы, поэтому канонизируйте имена или используйте библиотеку, иначе accept и Accept станут разными ключами PHP.

<?php
$stock = [10 => 2, 20 => 5];
$correction = [10 => 3, 30 => 1];
$updated = array_replace($stock, $correction);
foreach ($updated as $id => $quantity) {
    echo 'ID ', $id, ': ', $quantity, ' шт.', "\n";
}
echo 'До правки ID 10: ', $stock[10], ' шт.', "\n";

ID 10: 3 шт.
ID 20: 5 шт.
ID 30: 1 шт.
До правки ID 10: 2 шт.

Replace видит тот же ключ 10 и берёт позднее значение 3, сохраняет отсутствующий в правке 20→5 и добавляет 30→1. Числовые ключи не перенумеровываются. Новый массив updated используется в отчёте, а stock хранит прежнее 2. Если значение ключа само массив, обычный replace заменяет его целиком: ниже это сравнивается с рекурсивной правкой.

<?php
$base = ['mail' => ['host' => 'local', 'port' => 25]];
$patch = ['mail' => ['port' => 587]];
echo json_encode(array_replace($base, $patch)), "\n";
echo json_encode($base), "\n";

{"mail":{"port":587}}
{"mail":{"host":"local","port":25}}

host исчез из результата, потому что заменялось всё значение mail. Исходный массив не изменён.

<?php
declare(strict_types=1);

$defaults = ['timeout' => 5, 'retries' => 2];
$environment = ['timeout' => 15];
echo json_encode(array_replace($defaults, $environment), JSON_THROW_ON_ERROR), "\n";

{"timeout":15,"retries":2}

Значение повторов остается по умолчанию. После объединения проверьте диапазон и тип: строка из переменной окружения не становится int автоматически.

<?php
declare(strict_types=1);

$stocks = [101 => 3, 205 => 1];
$patch = [205 => 0];
echo json_encode(array_replace($stocks, $patch), JSON_THROW_ON_ERROR), "\n";

{"101":3,"205":0}

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

<?php
$jobs = ['A', 'B', 'C', 'D', 'E'];
$batches = array_chunk($jobs, 2);
foreach ($batches as $batchIndex => $batch) {
    echo 'Порция ', $batchIndex + 1, ':', "\n";
    foreach ($batch as $job) {
        echo '  Подготовить задание ', $job, "\n";
    }
}

Порция 1:
  Подготовить задание A
  Подготовить задание B
Порция 2:
  Подготовить задание C
  Подготовить задание D
Порция 3:
  Подготовить задание E

Chunk вернул три вложенных массива [A,B], [C,D], [E]. Внешний foreach берёт порцию; внутренний перебирает её задания. Максимум два элемента не требует дополнять последнюю порцию: там только E. Все порции созданы в памяти; функция не делает запросы, паузы или запуск заданий.

<?php
$jobs = [41 => 'mail', 58 => 'report', 90 => 'export'];
foreach (array_chunk($jobs, 2, true) as $batch) {
    echo implode(',', array_keys($batch)), "
";
}
try { array_chunk($jobs, 0); }
catch (ValueError $error) { echo "Размер должен быть положительным
"; }

41,58
90
Размер должен быть положительным

catch перехватывает отказ вызова; как работает исключение. Порции создаются в памяти: это не потоковая загрузка из БД.

<?php
declare(strict_types=1);

$ids = [1, 2, 3, 4, 5];
foreach (array_chunk($ids, 2) as $batch) {
    echo implode(',', $batch), "\n";
}

1,2
3,4
5

Это только формирование пакетов, без сетевых вызовов. У API могут быть разные лимиты на число ID в запросе и на число запросов в секунду.

<?php
declare(strict_types=1);

$stocks = ['A' => 2, 'B' => 0, 'C' => 7];
foreach (array_chunk($stocks, 2, true) as $part) {
    echo implode(',', array_keys($part)), "\n";
}

A,B
C

Preservekeys нужен, когда ключи — смысловые метки. Для списка JSON обычно оставляют false, чтобы каждая партия была списком.

<?php
$rows = [10 => 'A', 50 => 'B', 90 => 'C'];
$window = array_slice($rows, 1, 1, true);
foreach ($window as $id => $name) {
    echo 'Выбранная запись ID ', $id, ': ', $name, "\n";
}
$renumbered = array_slice($rows, 1, 1);
echo 'Та же запись под новым ключом 0: ', $renumbered[0], "\n";
echo 'Исходная первая запись сохранена: ', $rows[10], "\n";

Выбранная запись ID 50: B
Та же запись под новым ключом 0: B
Исходная первая запись сохранена: A

Offset 1 означает вторую позицию в порядке массива, а не ключ 1. Length 1 берёт один элемент. Preserve_keys=true удерживает id 50; без этого флага новый числовой ключ 0. Оба вызова вернули копию окна, ни один не удалил A или другую запись из rows.

<?php
$events = ['open','load','save','close'];
echo json_encode(array_slice($events, -2)), "
";
echo json_encode(array_slice($events, 1, -1)), "
";
echo json_encode(array_slice($events, 99)), "
";

["save","close"]
["load","save"]
[]

Отрицательная длина — число исключаемых элементов с конца, а не обратное направление обхода.

<?php
declare(strict_types=1);

$titles = ['A', 'B', 'C', 'D', 'E'];
$page = 2;
$perPage = 2;
echo implode(',', array_slice($titles, ($page - 1) * $perPage, $perPage)), "\n";

C,D

Подходит для небольшого заранее загруженного списка. Page следует валидировать как положительное целое; для большой таблицы используйте SQL пагинацию.

<?php
declare(strict_types=1);

$events = [10 => 'created', 20 => 'paid', 30 => 'shipped'];
echo json_encode(array_slice($events, -2, null, true), JSON_THROW_ON_ERROR), "\n";

{"20":"paid","30":"shipped"}

Числовые идентификаторы событий сохраняются. Последние в массиве не обязательно последние повремени: порядок источника нужен в контракте.

<?php
$tags = ['red','blue','red'];
echo json_encode(array_unique($tags)), "
";
echo json_encode(array_unique([1, '1', '01'])), "
";
echo json_encode(array_unique([1, '1', '01'], SORT_NUMERIC)), "
";

["red","blue"]
{"0":1,"2":"01"}
[1]

По умолчанию число 1 и строка "1" равны как строки, а "01" отличается. Числовой режим объединяет все три.

<?php
$rows = [['id' => 41], ['id' => 72], ['id' => 41]];
$ids = array_column($rows, 'id');
$uniqueIds = array_unique($ids, SORT_NUMERIC);
foreach ($uniqueIds as $sourcePosition => $id) {
    echo 'Подготовить товар ID ', $id, ' (первая позиция ', $sourcePosition, ')', "\n";
}
$list = array_values($uniqueIds);
echo 'Первый ID нового списка: ', $list[0], "\n";

Подготовить товар ID 41 (первая позиция 0)
Подготовить товар ID 72 (первая позиция 1)
Первый ID нового списка: 41

Column извлекает [41,72,41] из уже проверенных строк. Unique с числовым правилом возвращает первые 41 и 72 с ключами 0 и 1, повтор 41 не вызывает вторую подготовку. Здесь все ID — int; смешанные текстовые коды требуют другого правила равенства. Values — отдельный шаг для технических позиций нового списка. Ни unique, ни этот пример не выполняют запрос к базе: они готовят его набор ID.

<?php
declare(strict_types=1);

$skus = ['A', 'B', 'A'];
echo json_encode(array_values(array_unique($skus)), JSON_THROW_ON_ERROR), "\n";

["A","B"]

Подходит для проверенных строк SKU. Если повторы означают несколько заказанных единиц, нельзя удалять их без агрегации количества.

<?php
declare(strict_types=1);

$addresses = ['ops@example.test', 'sales@example.test', 'ops@example.test'];
echo count(array_unique($addresses, SORT_STRING)), "\n";

2

Это учебный список уже проверенных канонических адресов. Разная политика нормализации email должна решаться раньше; array_unique ее не выбирает.

<?php
$a = [4 => 10, 7 => 20, 9 => 10];
$b = ["x" => "10"];
echo json_encode(array_diff($a, $b)), "\n";

{"7":20}

Только значения; ключи остальных массивов не участвуют. Ключи результата взяты из $a.

<?php
$requested = ['mail', 'export', 'report', 'mail'];
$groupA = ['mail', 'report'];
$groupB = ['mail'];
$selected = array_diff($requested, $groupA, $groupB);
foreach ($selected as $position => $task) {
    echo "Ещё не назначено: ", $task, " (позиция ", $position, ")\n";
}

Ещё не назначено: export (позиция 1)

Diff исключает всё, что встречается хотя бы в одной группе: mail и report заняты, остаётся export. Selected содержит исходные ключи requested; foreach использует их для связи с исходной заявкой. Ключи групп не сравниваются. Выход — план, реальная отправка писем/экспорт в этом примере не выполняются.

<?php
declare(strict_types=1);

$requested = ['news', 'offers', 'events'];
$existing = ['news'];
echo implode(',', array_diff($requested, $existing)), "\n";

offers,events

Это разность разрешенных строковых кодов аргумента. Проверку прав и набор допустимых кодовых значений выполните отдельно.

<?php
declare(strict_types=1);

$receivedColumns = ['sku', 'stock', 'admin'];
$allowedColumns = ['sku', 'stock'];
echo implode(',', array_diff($receivedColumns, $allowedColumns)), "\n";

admin

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

<?php
$a = [4 => 10, 7 => 20, 9 => 10];
$b = ["x" => "10"];
echo json_encode(array_intersect($a, $b)), "\n";

{"4":10,"9":10}

Только значения; ключи остальных массивов не участвуют. Ключи результата взяты из $a.

<?php
$requested = ['mail', 'export', 'report', 'mail'];
$groupA = ['mail', 'report'];
$groupB = ['mail'];
$selected = array_intersect($requested, $groupA, $groupB);
foreach ($selected as $position => $task) {
    echo "Поддерживается обеими системами: ", $task, " (позиция ", $position, ")\n";
}

Поддерживается обеими системами: mail (позиция 0)
Поддерживается обеими системами: mail (позиция 3)

Intersect требует наличия значения в каждой последующей группе: report есть только у A, поэтому остаётся mail. Оба вхождения mail сохраняются: операция не удаляет повторы. Selected содержит исходные ключи requested; foreach использует их для связи с исходной заявкой. Ключи групп не сравниваются. Выход — план, реальная отправка писем/экспорт в этом примере не выполняются.

<?php
declare(strict_types=1);

$requested = ['csv', 'pdf', 'exe'];
$supported = ['csv', 'pdf'];
echo implode(',', array_intersect($requested, $supported)), "\n";

csv,pdf

Пересечение применяется к явному разрешенному набору. Результат может быть пустым — сообщите это, а не выбирайте случайный формат.

<?php
declare(strict_types=1);

$first = ['php', 'api', 'shop'];
$second = ['api', 'security'];
echo implode(',', array_values(array_intersect($first, $second))), "\n";

api

При ранжировании похожих статей общие теги — лишь признак. Если коллекции большие, измерьте стоимость и подумайте об индексе/поиске хранилища.

<?php
$allowed = ['new', 'paid'];
$status = 'paid';
if (in_array($status, $allowed, true)) {
    echo 'Фильтр списка заказов принят: ', $status, "\n";
}
$status = 'PAID';
if (!in_array($status, $allowed, true)) {
    echo 'Фильтр отклонён: неизвестный код ', $status, "\n";
}

Фильтр списка заказов принят: paid
Фильтр отклонён: неизвестный код PAID

Needle — status, haystack — allowed, strict=true запрещает совпадение с другим типом. Возврат bool прямо выбирает сообщение. Ищутся значения new/paid, не их ключи 0/1. Регистр различается; если протокол допускает нормализацию, это отдельное согласованное действие до проверки.

<?php
var_dump(in_array('0', [0], false));
var_dump(in_array('0', [0], true));
var_dump(in_array(true, ['approved'], false));

bool(true)
bool(false)
bool(true)

Нестрогое равенство может принять bool true за непустую строку. Исправление сравнения числа с нечисловой строкой в PHP 8 не отменило остальные преобразования.

<?php
declare(strict_types=1);

$sort = 'price';
$allowed = ['price', 'name', 'created'];
echo in_array($sort, $allowed, true) ? "Разрешено\n" : "Неизвестное поле\n";

Разрешено

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

<?php
declare(strict_types=1);

$allowedIds = [10, 20];
echo in_array('10', $allowedIds, true) ? "Есть\n" : "Нужна нормализация\n";

Нужна нормализация

Внешний ввод сначала проверяют и нормализуют, после этого строгое сравнение не создает неожиданных совпадений.

<?php
$items = ['A', 'B'];
$key = array_search('A', $items, true);
if ($key !== false) {
    echo 'Удаляем найденный товар ', $items[$key], ' по ключу ', $key, "\n";
    unset($items[$key]);
}
foreach ($items as $remainingKey => $item) {
    echo 'Остался товар ', $item, ' по ключу ', $remainingKey, "\n";
}
$missingKey = array_search('C', $items, true);
if ($missingKey === false) {
    echo "Товара C нет: ничего не удаляем\n";
}

Удаляем найденный товар A по ключу 0
Остался товар B по ключу 1
Товара C нет: ничего не удаляем

Search возвращает успешный ключ 0, поэтому проверка !== false обязательна: if(key) ошибочно отвергла бы ноль. После чтения найденного значения удаляется именно этот элемент. Ключ B остался 1. Отсутствующий C даёт false, и unset не вызывается: непроверенный false мог бы быть преобразован в ключ 0.

<?php
$statuses = ['A' => 'paid', 'B' => 'new', 'C' => 'paid'];
echo array_search('paid', $statuses, true), "\n";
echo json_encode(array_keys($statuses, 'paid', true)), "\n";
var_dump(array_search('missing', $statuses, true));

A
["A","C"]
bool(false)

Первый результат — ключ, не значение paid. Если нужны все совпадения, array_keys с фильтром выражает задачу прямо.

<?php
declare(strict_types=1);

$filters = ['sale', 'new'];
$key = array_search('sale', $filters, true);
if ($key !== false) {
    unset($filters[$key]);
}
echo implode(',', array_values($filters)), "\n";

new

Sale стоит под ключом 0. Строгая проверка предотвращает пропуск первого пункта; array_values восстанавливает список для интерфейса.

<?php
declare(strict_types=1);

$labels = ['new' => 'Новый', 'paid' => 'Оплачен'];
$code = array_search('Оплачен', $labels, true);
echo $code === false ? "Не найдено\n" : $code . "\n";

paid

Для редкого поискав маленьком справочнике этого достаточно. Для локализованных подписей не гарантируется уникальность — лучше передавать код из формы, а подпись только показывать.

<?php
$weights = ['large' => 2.7, 'small' => 2.1, 'middle' => 2.4];
usort($weights, function ($left, $right) {
    return $left <=> $right;
});
foreach ($weights as $key => $weight) {
    echo 'Позиция ', $key, ': ', $weight, " кг\n";
}

Позиция 0: 2.1 кг
Позиция 1: 2.4 кг
Позиция 2: 2.7 кг

Первый аргумент — изменяемый массив, второй — функция как значение. Алгоритм сам многократно передаёт в left/right две массы; конкретный порядок вызовов не обещан. Оператор <=> возвращает int: например, для 2.1 и 2.7 это -1, для обратной пары 1, для одинаковых значений 0. Этот return поступает в алгоритм сортировки, а не в weights. После завершения внешний foreach читает массы в новом порядке. Имена large/small/middle заменены позициями 0/1/2; для сохранения имён нужна uasort. Дробную разность left-right возвращать нельзя: приведение к int превратило бы 0.6 в 0.

<?php
$orders = ["c" => ["priority" => 2, "id" => 30], "a" => ["priority" => 1, "id" => 20], "b" => ["priority" => 1, "id" => 10]];
usort($orders, function ($a, $b) {
    $byPriority = $a["priority"] <=> $b["priority"];
    return $byPriority !== 0 ? $byPriority : $a["id"] <=> $b["id"];
});
echo json_encode(array_column($orders, "id")), "\n";
echo json_encode(array_keys($orders)), "\n";

[10,20,30]
[0,1,2]

Сначала сравниваем приоритет, при равенстве — ID. ?: выбирает один результат; <=> вычисляет целое сравнение даже для float.

<?php
declare(strict_types=1);

$rows = [['sku' => 'B', 'price' => 100], ['sku' => 'A', 'price' => 100], ['sku' => 'C', 'price' => 50]];
usort($rows, static fn ($a, $b): int => ($a['price'] <=> $b['price']) ?: ($a['sku'] <=> $b['sku']));
echo implode(',', array_column($rows, 'sku')), "\n";

C,A,B

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

<?php
declare(strict_types=1);

$tasks = [['id' => 1, 'priority' => 1], ['id' => 2, 'priority' => 5]];
usort($tasks, static fn ($a, $b): int => $b['priority'] <=> $a['priority']);
echo implode(',', array_column($tasks, 'id')), "\n";

2,1

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

<?php
$invoices = [30 => 'накладная C', 10 => 'накладная A', 20 => 'накладная B'];
$status = ksort($invoices, SORT_NUMERIC);
if ($status) { echo "Накладные упорядочены\n"; }
foreach ($invoices as $id => $title) { echo "ID ", $id, ": ", $title, "\n"; }

Накладные упорядочены
ID 10: накладная A
ID 20: накладная B
ID 30: накладная C

Сравниваются числовые ключи 30/10/20; текст накладной в сравнении не участвует. SORT_NUMERIC явно выбирает числовой порядок. Значение перемещается вместе со своим ID. Возврат status — true; результат сортировки находится в изменившемся invoices и сразу используется для отчёта.

<?php
$files = ["part10" => "ten", "part2" => "two", "Part1" => "one"];
ksort($files, SORT_NATURAL | SORT_FLAG_CASE);
echo json_encode($files), "\n";

{"Part1":"one","part2":"two","part10":"ten"}

Часть 2 сравнивается как число и идёт перед частью 10 при возрастании. Флаг CASE убирает различие ASCII-регистра, а не меняет сами строки.

<?php
declare(strict_types=1);

$stocks = ['B' => 2, 'A' => 0];
ksort($stocks, SORT_STRING);
echo json_encode($stocks, JSON_THROW_ON_ERROR), "\n";

{"A":0,"B":2}

Так отчет легче сравнивать в diff. Это оформление, а не изменение остатков или порядка клиентского заказа.

<?php
declare(strict_types=1);

$sales = [12 => 300, 2 => 100];
ksort($sales, SORT_NUMERIC);
echo implode(',', array_keys($sales)), "\n";

2,12

Режим числового сравнения объясняет порядок. Для полных дат ISO в формате Y-m-d строковый порядок обычно соответствует календарному при едином формате.

<?php
$cart = ['A' => 3, 'B' => 1];
$lineCount = count($cart);
$packageCount = array_sum($cart);
echo 'Разных позиций: ', $lineCount, "\n";
echo 'Упаковок к сборке: ', $packageCount, "\n";
if ($lineCount === 0) { echo "Корзина пуста\n"; }

Разных позиций: 2
Упаковок к сборке: 4

count возвращает 2, потому что на верхнем уровне две пары: A→3 и B→1. Этот результат отвечает за число разных строк; array_sum отдельно возвращает 4 упаковки. Наличие вложенных полей у строки не увеличило бы обычный count. Рекурсивный режим ниже считает также элементы контейнеров и не заменяет сумму количеств.

<?php
$groups = [['A', 'B'], ['C']];
echo count($groups), "\n";
echo count($groups, COUNT_RECURSIVE), "\n";
try {
    count(null);
} catch (TypeError) {
    echo "Ожидался массив или Countable\n";
}

2
5
Ожидался массив или Countable

Рекурсивно получилось 2 контейнера + 3 значения. Это не число товаров-листьев. На границе API null сначала обрабатывают по договору, а не автоматически превращают в пустой список.

<?php
declare(strict_types=1);

$items = [];
echo count($items) === 0 ? "Добавьте товары\n" : "Можно оформить\n";

Добавьте товары

Число позиций не равно сумме количеств: три товара в одной строке — одна ячейка массива.

<?php
declare(strict_types=1);

$row = ['A', 'Tea', '2'];
echo count($row) === 3 ? "Форма строки верна\n" : "Лишние колонки\n";

Форма строки верна

Это проверка ширины записи, а не валидности содержимого. Затем проверьте SKU, название и числовой остаток.

<?php
$items = ['Чай', 'Кофе', 'Вода'];
unset($items[1]);
if (!array_is_list($items)) {
    echo "После удаления позиции нужно перенумеровать\n";
    $items = array_values($items);
}
foreach ($items as $index => $name) {
    echo 'Позиция ', $index + 1, ': ', $name, "\n";
}

После удаления позиции нужно перенумеровать
Позиция 1: Чай
Позиция 2: Вода

После unset остаются ключи 0 и 2. Array_is_list возвращает false; знак ! обращает его в true, поэтому выполняется ветка восстановления. Array_values возвращает список с ключами 0 и 1, который сохраняется обратно в items. На экране номера для человека увеличены на 1. Это позиции, а не ID товаров; словарь с ID нельзя так перенумеровывать.

<?php
$items = [0 => 'A', 2 => 'C'];
$response = array_values($items);
var_dump(array_is_list($response));
echo json_encode($response), "\n";
var_dump(array_is_list([1 => 'B', 0 => 'A']));

bool(true)
["A","C"]
bool(false)

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

<?php
declare(strict_types=1);

$items = [['sku' => 'A'], ['sku' => 'B']];
echo array_is_list($items) ? "Список\n" : "Нужен список\n";

Список

После этого проверяйте каждую запись внутри. Список скаляров также прошел бы array_is_list, хотя контракт заказа он нарушает.

<?php
declare(strict_types=1);

$ids = [0 => 10, 2 => 30];
echo array_is_list($ids) ? "list\n" : "map\n";
echo array_is_list(array_values($ids)) ? "list\n" : "map\n";

map
list

Это объясняет разный вид JSON после unset. Восстанавливайте плотные индексы только для коллекции, где позиционные ключи не имеют смысла.