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

<?php
var_dump(is_bool(false));
var_dump(is_bool(0));
var_dump(is_bool("false"));

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

false в первом вызове — проверяемое значение. Ответ true означает «тип действительно bool», а не «флаг включён».

<?php
$settings = ["notifications" => false];
$enabled = $settings["notifications"] ?? null;
if (!is_bool($enabled)) {
    throw new InvalidArgumentException("Нужен логический флаг");
}
echo $enabled ? "Отправлять" : "Не отправлять";

Не отправлять

Так проверяют структуру внутренней конфигурации или JSON с настоящим false. Текстовое поле формы потребует разбора разрешённых значений. Тернарный оператор выбирает понятную человеку подпись.

<?php
var_dump(is_float(2.0));
var_dump(is_float(2));
var_dump(is_float("2.0"));

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

Проверяется тип хранения значения, а не наличие значимых цифр после точки.

<?php
$measurements = [1.25, INF, '1.25'];
foreach ($measurements as $value) {
    if (!is_float($value) || !is_finite($value) || $value < 0) {
        echo "Измерение отклонено: нужен конечный неотрицательный float\n";
        continue;
    }
    $twoPackages = $value * 2;
    echo 'Масса одной упаковки: ', $value, ' кг; двух: ', $twoPackages, ' кг', "\n";
}

Масса одной упаковки: 1.25 кг; двух: 2.5 кг
Измерение отклонено: нужен конечный неотрицательный float
Измерение отклонено: нужен конечный неотрицательный float

Is_float разрешает первое значение и INF, но is_finite отклоняет INF. Строка 1.25 отклонена уже по типу. Только подходящее измерение используется в умножении и выводится с единицей измерения. Этот договор намеренно требует float; если источник допускает int, расширяют первую проверку явно.

<?php
$deliveryDate = null;
var_dump(is_null($deliveryDate));
var_dump(is_null(0));
var_dump(is_null(""));

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

null здесь означает «дата ещё не назначена», а не строку из четырёх букв.

<?php
$customer = ['name' => 'Анна', 'phone' => '+7 000 000-00-00'];
$update = ['phone' => null];
echo 'До изменения: ', $customer['phone'], "\n";
if (!array_key_exists('phone', $update)) {
    echo "Телефон не меняется\n";
} elseif (is_null($update['phone'])) {
    $customer['phone'] = null;
    echo "Поле phone очищено по явному запросу\n";
} else {
    echo "Новый телефон требует отдельной проверки формата\n";
}
echo 'После изменения: ', $customer['phone'] ?? 'телефон не указан', "\n";

До изменения: +7 000 000-00-00
Поле phone очищено по явному запросу
После изменения: телефон не указан

Array_key_exists различает отсутствующий ключ и существующий null. Is_null получает существующее значение и возвращает true; только тогда присваивается null в локальную карточку. При отсутствии ключа прежний телефон сохранился бы. Показан договор частичного обновления в памяти: записи в БД или отправки куда-либо нет. Для неизвестной переменной is_null не заменяет isset: аргумент будет прочитан до вызова.

<?php
$item = new stdClass();
var_dump(is_object($item));
var_dump(is_object([]));

bool(true)
bool(false)

new создаёт объект; stdClass — встроенный простой класс. [] создаёт массив, даже если его использовать как запись товара.

<?php
class ProductView
{
    public string $name = "Чай";
}
$value = new ProductView();
if (is_object($value)) {
    echo get_debug_type($value), "
";
}
if ($value instanceof ProductView) {
    echo $value->name;
}

ProductView
Чай

Для диагностики достаточно «это объект»; для чтения ожидаемого свойства полезен конкретный instanceof. public разрешает внешний доступ, стрелка читает свойство. Для бизнес-клиента обычно проверяют интерфейс, а не любой объект.

<?php
$stream = fopen("php://memory", "r+");
var_dump(is_resource($stream));
fclose($stream);
var_dump(is_resource($stream));

bool(true)
bool(false)

fopen открывает временный поток в памяти, r+ разрешает чтение и запись. fclose закрывает поток. После этого нельзя продолжать fwrite лишь потому, что переменная осталась.

<?php
$stream = fopen("php://memory", "r+");
try {
    if (!is_resource($stream)) {
        throw new RuntimeException("Поток не открыт");
    }
    fwrite($stream, "ready");
    rewind($stream);
    echo stream_get_contents($stream);
} finally {
    if (is_resource($stream)) {
        fclose($stream);
    }
}

ready

finally освобождает ресурс и при исключении. Это учебный поток без сети; в реальном экспорте дополнительно проверяют неполную запись и ошибки чтения. Проверка ресурса не обещает права на запись или живое удалённое соединение.

<?php
var_dump(is_scalar("SKU-2"));
var_dump(is_scalar(false));
var_dump(is_scalar(null));
var_dump(is_scalar([]));

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

Скаляр — категория типов, а не синоним «полезное непустое значение». Ложный bool остаётся скаляром.

<?php
$attributes = ["name" => "Чай", "active" => false, "tags" => ["food"]];
foreach ($attributes as $key => $value) {
    if (!is_scalar($value)) {
        echo $key, ": нужен отдельный формат
";
        continue;
    }
    $text = is_bool($value) ? ($value ? "yes" : "no") : strval($value);
    echo $key, ": ", $text, "
";
}

name: Чай
active: no
tags: нужен отдельный формат

Локальный текстовый экспорт принимает простые атрибуты. bool получает явные yes/no, иначе false пропал бы в пустой строке. Массив тегов требует отдельной сериализации. Для CSV/HTML нужны соответствующие экранирование и форматирование.

<?php
$transform = "strtoupper";
var_dump(is_callable($transform));
echo $transform("tea");

bool(true)
TEA

В первом вызове имя только проверили. Во втором скобки реально вызывают strtoupper; результатом является новая строка.

<?php
$name = "manual_missing_transform";
var_dump(is_callable($name, true, $description));
var_dump(is_callable($name));
echo $description;

bool(true)
bool(false)
manual_missing_transform

syntax_only=true проверяет форму, поэтому произвольная строка проходит. Третий параметр передан по ссылке: функция записывает туда описательное имя. Оно не гарантирует существование функции или статичность метода.

<?php
$transforms = ["upper" => static fn (string $text): string => strtoupper($text)];
$selected = "upper";
$transform = $transforms[$selected] ?? null;
if (!is_callable($transform)) {
    throw new InvalidArgumentException("Неизвестное преобразование");
}
echo $transform("tea");

TEA

Это следующая ступень: fn создаёт короткую функцию, string описывает её вход и выход. Пользователь выбирает ключ из списка, а не произвольное имя PHP-функции. Разрешённость вызова ещё не гарантирует, что само тело не выбросит исключение.

<?php
var_dump(is_countable(["tea", "bread"]));
var_dump(is_countable("tea"));

bool(true)
bool(false)

Для длины строки нужны strlen/mb_strlen, не count. Сама is_countable не обходит элементы массива.

<?php
function orderIds(): Generator
{
    yield 41;
    yield 42;
}
$orders = orderIds();
var_dump(is_iterable($orders));
var_dump(is_countable($orders));
foreach ($orders as $id) {
    echo $id, "
";
}

bool(true)
bool(false)
41
42

yield выдаёт значения по одному; Generator не реализует Countable. Проверки не потребили генератор. Отдельный полный подсчёт обходом потратил бы время и мог бы исчерпать одноразовый источник. Подробности — в главе генераторов.

<?php
var_dump(is_iterable(["TEA"]));
var_dump(is_iterable("TEA"));
var_dump(is_iterable(new stdClass()));

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

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

<?php
function printCodes(iterable $codes): void
{
    foreach ($codes as $code) {
        echo $code, "
";
    }
}
$source = new ArrayIterator(["TEA", "BREAD"]);
if (is_iterable($source)) {
    printCodes($source);
}

TEA
BREAD

ArrayIterator оборачивает массив и поддерживает Traversable. Тип iterable разрешает единый вход для массива, итератора и генератора. Он не гарантирует тип каждого элемента, повторяемость прохода или конечность потока.

<?php
$stock = 0;
$delivery = null;
var_dump(isset($stock));
var_dump(isset($delivery));
var_dump(isset($missing));

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

Необъявленный missing проверяется без предупреждения: isset — конструкция языка, а не обычная функция, читающая аргумент заранее.

<?php
$customer = ['name' => 'Анна', 'phone' => null];
if (isset($customer['name'], $customer['phone'])) {
    echo 'Контакт готов: ', $customer['name'], ', ', $customer['phone'], "\n";
} else {
    echo "Контакт ещё не заполнен полностью\n";
}
if (array_key_exists('phone', $customer)) {
    echo "Поле телефона предусмотрено в карточке\n";
}
$phoneLabel = $customer['phone'] ?? 'не указан';
echo 'Покупатель: ', $customer['name'], '; телефон: ', $phoneLabel, "\n";

Контакт ещё не заполнен полностью
Поле телефона предусмотрено в карточке
Покупатель: Анна; телефон: не указан

Многоаргументный isset требует оба существующих ненулевых значения: name подходит, phone=null останавливает проверку с false. Array_key_exists подтверждает ключ отдельно. Последнее ?? возвращает строку для отображения, не заполняя phone автоматически. Даже true от isset не доказывало бы строковый тип или допустимый номер.

<?php
var_dump(empty(""));
var_dump(empty("0"));
var_dump(empty(0));
var_dump(empty(" "));
var_dump(empty($missing));

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

Пробел является непустой строкой. Строка "0" считается ложной. Неизвестное имя не вызывает предупреждение.

<?php
$quote = ["delivery" => 0];
if (empty($quote["delivery"])) {
    echo "empty не отличил бесплатную доставку
";
}
if (array_key_exists("delivery", $quote) && is_int($quote["delivery"])) {
    echo "Цена доставки: ", $quote["delivery"];
}

empty не отличил бесплатную доставку
Цена доставки: 0

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

<?php
$items = [0 => 'Чай', 1 => 'Кофе'];
$cancelled = $items[0];
unset($items[0]);
echo 'Отменён товар: ', $cancelled, "\n";
foreach ($items as $key => $name) {
    echo 'Оставшийся ключ ', $key, ': ', $name, "\n";
}
$listForDisplay = array_values($items);
echo 'Первая позиция нового списка: ', $listForDisplay[0], "\n";
$temporary = 'Готово';
unset($temporary);
if (!isset($temporary)) {
    echo "Временное имя очищено\n";
}

Отменён товар: Чай
Оставшийся ключ 1: Кофе
Первая позиция нового списка: Кофе
Временное имя очищено

Unset ничего не возвращает, поэтому отменённое название сохранено до удаления. Ключ 1 не переехал автоматически в 0. Array_values возвращает новый последовательный массив в listForDisplay; исходные items по-прежнему имеют ключ 1. Последний unset удаляет только имя temporary, не файл и не запись базы.

<?php
$stock = 5;
$editable =& $stock;
$editable = 3;
unset($editable);
$editable = 100;
echo $stock, "
", $editable;

3
100

=& связывает два имени. unset разрывает связь только для editable; новая запись создаёт независимую переменную. Это полезно после foreach по ссылке, чтобы не менять последний элемент следующей записью.

<?php
var_dump(is_double(2.5));
var_dump(is_double("2.5"));

bool(true)
bool(false)

Это alias, а не другой диапазон чисел или более строгая проверка. Строка остаётся строкой.

<?php
$value = 2.5;
$oldCheck = is_double($value);
$currentCheck = is_float($value);
var_dump($oldCheck === $currentCheck);

bool(true)

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

<?php
var_dump(is_integer(2));
var_dump(is_integer("2"));

bool(true)
bool(false)

Это alias, а не другой диапазон чисел или более строгая проверка. Строка остаётся строкой.

<?php
$value = 2;
$oldCheck = is_integer($value);
$currentCheck = is_int($value);
var_dump($oldCheck === $currentCheck);

bool(true)

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

<?php
var_dump(is_long(2));
var_dump(is_long("2"));

bool(true)
bool(false)

Это alias, а не другой диапазон чисел или более строгая проверка. Строка остаётся строкой.

<?php
$value = 2;
$oldCheck = is_long($value);
$currentCheck = is_int($value);
var_dump($oldCheck === $currentCheck);

bool(true)

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

<?php
var_dump(function_exists("is_real"));
var_dump(is_float(1.5));

bool(false)
bool(true)

В PHP 8 is_real удалена; прямой вызов неизвестного имени вызвал бы Error. Основное имя — is_float.

<?php
$temperature = 18.5;
if (is_float($temperature) && is_finite($temperature)) {
    echo "Конечное измерение";
}

Конечное измерение

При переносе старого проекта заменяют alias, затем проверяют предметные ограничения. is_float не гарантирует конечность и допустимый диапазон датчика.

<?php
var_dump(boolval(0));
var_dump(boolval("0"));
var_dump(boolval("false"));
var_dump(boolval([]));

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

boolval применяет обычные правила приведения к bool. Она не разбирает английские слова true/false. [] — пустой массив; непустой массив дал бы true.

<?php
$raw = 'false';
$coerced = boolval($raw);
echo 'После простого boolval: ', $coerced ? 'уведомления включены' : 'уведомления выключены', "\n";
$allowed = ['true' => true, 'false' => false];
if (!array_key_exists($raw, $allowed)) {
    throw new InvalidArgumentException('Нужны true или false');
}
$enabled = $allowed[$raw];
echo 'После разбора согласованного словаря: ', $enabled ? 'уведомления включены' : 'уведомления выключены', "\n";

После простого boolval: уведомления включены
После разбора согласованного словаря: уведомления выключены

Boolval вернул true: строка false непуста и не равна строке 0. Вторая часть использует две явно согласованные записи и получает bool false по ключу false. Результат enabled управляет подписью; отправка уведомлений не выполняется. Если протокол принимает 0/1 или другие записи, их задают отдельно.

<?php
var_dump(floatval("2.75"));
var_dump(floatval("2.75 kg"));
var_dump(floatval("kg 2.75"));
var_dump(floatval("2,75"));

float(2.75)
float(2.75)
float(0)
float(2)

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

<?php
$raw = '2.75';
if (!is_string($raw) || !is_numeric($raw)) {
    throw new InvalidArgumentException('Вес должен быть числовой строкой');
}
$weightKg = floatval($raw);
if (!is_finite($weightKg) || $weightKg <= 0 || $weightKg > 30) {
    throw new InvalidArgumentException('Недопустимый вес');
}
$totalWeightKg = $weightKg * 2;
echo 'Исходный текст: ', $raw, ' (', get_debug_type($raw), ')', "\n";
echo 'Масса двух мест: ', $totalWeightKg, ' кг', "\n";

Исходный текст: 2.75 (string)
Масса двух мест: 5.5 кг

Floatval получает проверенную строку, возвращает float 2.75 в weightKg; raw остаётся строкой. После проверки конечности и диапазона умножение даёт 5.5. Числовой синтаксис PHP — договор этого примера, включая экспоненту; он не подходит автоматически для местной записи с запятой или цен с разделителем тысяч.

<?php
var_dump(doubleval("1.5"));
var_dump(doubleval("1.5 units"));

float(1.5)
float(1.5)

doubleval — alias floatval, а не более точная десятичная арифметика. Даже текст с припиской может дать число.

<?php
$raw = "3.25";
$old = doubleval($raw);
$current = floatval($raw);
var_dump($old === $current);
echo $current;

bool(true)
3.25

При сопровождении старого кода можно использовать основное имя floatval. Все требования проверки входа, конечности и погрешности сохраняются; переименование не исправляет денежные расчёты.

<?php
var_dump(strval(41));
var_dump(strval(true));
var_dump(strval(false));
var_dump(strval(null));

string(2) "41"
string(1) "1"
string(0) ""
string(0) ""

Получен новый string. true становится "1", а false/null — пустой строкой. Если нужны буквальные yes/no или true/false, задайте это правило явно.

<?php
$orderId = 41;
$reference = "ORDER-" . strval($orderId);
echo $reference, "
";
$enabled = false;
echo $enabled ? "enabled" : "disabled";

ORDER-41
disabled

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

<?php
class OrderReference
{
    public function __toString(): string
    {
        return "ORDER-41";
    }
}
$reference = new OrderReference();
echo strval($reference);

ORDER-41

__toString — метод, возвращающий строку при соответствующем преобразовании. Это уже раздел ООП: метод может иметь собственные ошибки; любой произвольный объект строкой не становится.

<?php
$quantity = "12";
$success = settype($quantity, "int");
var_dump($success);
var_dump($quantity);

bool(true)
int(12)

var передаётся по ссылке: settype меняет quantity. Переменная success содержит true, а не 12. С (int) $quantity можно получить новое значение без изменения исходника.

<?php
$value = "12";
try {
    settype($value, "decimal");
} catch (ValueError $error) {
    echo "Такого типа у settype нет
";
}
var_dump($value);

Такого типа у settype нет
string(2) "12"

try содержит рискованный вызов, catch принимает ValueError и объясняет ошибку. PHP 8 не возвращает false для неизвестного типа. decimal не является названием типа, понятным settype.

<?php
$raw = '3';
$permitted = ['1', '2', '3', '4', '5'];
if (!in_array($raw, $permitted, true)) {
    throw new InvalidArgumentException('Нужна одна из строк 1, 2, 3, 4, 5');
}
$normalized = $raw;
$success = settype($normalized, 'int');
if (!$success) {
    throw new RuntimeException('Преобразование не выполнено');
}
echo 'Для журнала: ', $raw, ' (', get_debug_type($raw), ')', "\n";
echo 'Для модуля: ', $normalized, ' (', get_debug_type($normalized), ')', "\n";
echo 'Всего в трёх одинаковых наборах: ', $normalized * 3, ' шт.', "\n";

Для журнала: 3 (string)
Для модуля: 3 (int)
Всего в трёх одинаковых наборах: 9 шт.

In_array с третьим true ищет строгое совпадение в маленьком согласованном словаре. Raw скопирован, поэтому settype изменяет только normalized на int 3. Его возврат true хранится в success отдельно; расчёт использует normalized и даёт 9. При известном целевом типе обычный (int) часто яснее; динамический settype нужен лишь когда API требует именно такую мутацию.

<?php
class BatchSettings
{
    public int $limit = 12;
}
$settings = new BatchSettings();
var_dump(settype($settings->limit, "string"));
var_dump($settings->limit);

bool(true)
int(12)

Здесь обычный режим без strict_types=1. settype получила строку "12", но присваивание в int-свойство привело её обратно к int. true не гарантирует, что свойство теперь имеет запрошенный строковый тип. С неподходящим значением или в строгом режиме возможен TypeError; не используйте settype для обхода договора свойства.

<?php
echo gettype(12), "
";
echo gettype(1.5), "
";
echo gettype(false), "
";
echo gettype(null);

integer
double
boolean
NULL

double здесь обозначает PHP float, а NULL записывается в верхнем регистре. Это договор старой функции, не новые типы языка.

<?php
$value = new stdClass();
echo gettype($value), "
";
echo get_debug_type($value), "
";
var_dump(is_object($value));

object
stdClass
bool(true)

gettype говорит об общей категории, get_debug_type уточняет класс, is_object возвращает логический ответ. Выбор зависит от того, нужен текст диагностики или условие программы.

<?php
var_dump(0, "0", null);

int(0)
string(1) "0"
NULL

Через запятую передаются несколько аргументов. string(1) показывает длину в байтах; это не универсальное количество букв для UTF-8. var_dump печатает непосредственно, её возврат — null при использовании в выражении.

<?php
$line = ["sku" => "TEA", "stock" => 0];
ob_start();
var_dump($line);
$debugText = ob_get_clean();
echo "Сохранён текст: ", is_string($debugText) ? "да" : "нет", "
";
echo $debugText;

Сохранён текст: да
array(2) {
  ["sku"]=>
  string(3) "TEA"
  ["stock"]=>
  int(0)
}

ob_start включает буфер, ob_get_clean возвращает и закрывает именно этот буфер. В реальном JSON-обработчике не выводите debugText вместе с JSON: сохраните ограниченную диагностику в журнал. Здесь echo нужен, чтобы увидеть результат учебного опыта.

<?php
print_r(["sku" => "TEA", "stock" => 0]);

Array
(
    [sku] => TEA
    [stock] => 0
)

Ключи и значения удобны для быстрого просмотра, но подробных типов нет. false и пустая строка выглядят похоже; для такой ошибки используйте var_dump.

<?php
$order = ["id" => 41, "status" => "new", "internalToken" => "demo-only"];
$publicDebug = ["id" => $order["id"], "status" => $order["status"]];
$text = print_r($publicDebug, true);
var_dump(is_string($text));
echo $text;

bool(true)
Array
(
    [id] => 41
    [status] => new
)

Второй аргумент true возвращает строку вместо немедленной печати. Поля выбраны явно: технический токен не попадает в представление. Даже такой текст экранируйте перед включением в HTML.

<?php
$enabled = false;
$code = var_export($enabled, true);
var_dump($code);
echo $code;

string(5) "false"
false

strval(false) вернула бы пустую строку. var_export создаёт текст PHP-выражения false; его имя code здесь обозначает строку, она сама не исполняется.

<?php
$config = ["limit" => 20, "enabled" => false];
$source = "<?php
return " . var_export($config, true) . ";
";
echo $source;

<?php
return array (
  'limit' => 20,
  'enabled' => false,
);

Так инструмент сборки может подготовить проверяемый файл с собственными настройками. Пример лишь печатает строку; не вызывает eval, не записывает и не подключает чужой код. Фикстуру сохраняют вне публичных загрузок, пересматривают и контролируют права.

<?php
debug_zval_dump(7, false);

int(7)
bool(false)

int и bool не используют copy-on-write как массивы/строки; ожидать refcount у каждого типа неправильно. Функция предназначена для исследования устройства движка.

<?php
$text = "ORDER-" . strval(2);
$copy = $text;
ob_start();
debug_zval_dump($text);
$diagnostic = ob_get_clean();
var_dump(str_contains($diagnostic, 'string(7) "ORDER-2"'));
$copy .= "-COPY";
echo $text, "
", $copy;

bool(true)
ORDER-2
ORDER-2-COPY

Буфер сохраняет наблюдаемый dump для локального просмотра. Проверяем смысл значения, не число владельцев: сама передача аргумента влияет на refcount, а интернирование/оптимизации меняют детали. Изменение copy не изменило text. Этот опыт не измеряет производительность или физический объём памяти.

<?php
$outside = "не здесь";
function inspectLine(): void
{
    $quantity = 2;
    $variables = get_defined_vars();
    echo $variables["quantity"], "
";
    var_dump(array_key_exists("outside", $variables));
    var_dump(array_key_exists("variables", $variables));
}
inspectLine();

2
bool(false)
bool(false)

Внутренняя quantity уже объявлена; outside не импортирована. Переменная variables ещё не получила результат вызова в момент создания снимка. Это помогает понять область видимости, а не получить все переменные всех функций.

<?php
function debugImport(int $processed): array
{
    $phase = "catalog";
    $token = "demo-only";
    $snapshot = get_defined_vars();
    return ["processed" => $snapshot["processed"], "phase" => $snapshot["phase"]];
}
print_r(debugImport(3));

Array
(
    [processed] => 3
    [phase] => catalog
)

В снимок попал и token, но наружу выбраны только два поля. В этом небольшом примере лучше сразу вернуть ["processed"=>$processed,"phase"=>$phase]; get_defined_vars показана для исследования и инструментов, а не как обязательная прослойка каждого журнала.

<?php
$stream = fopen("php://memory", "r+");
$id = get_resource_id($stream);
var_dump(is_int($id));
var_dump($id === get_resource_id($stream));
fclose($stream);

bool(true)
bool(true)

Числовая метка зависит от запуска, поэтому пример сравнивает её с меткой того же ресурса, а не обещает конкретное число.

<?php
$first = fopen("php://memory", "r+");
$second = fopen("php://memory", "r+");
try {
    $labels = [get_resource_id($first) => "source", get_resource_id($second) => "target"];
    echo $labels[get_resource_id($second)], "
";
    var_dump(get_resource_id($first) !== get_resource_id($second));
} finally {
    fclose($first);
    fclose($second);
}

target
bool(true)

Локальное отображение помогает подписать диагностику импорта. Это не файловый descriptor ОС, ID клиента или устойчивый ключ для БД. После завершения/повторного запуска не ищите ресурс по сохранённому числу.

<?php
$stream = fopen("php://memory", "r+");
echo get_resource_type($stream);
fclose($stream);

stream

Ответ говорит, что это поток PHP. Он не сообщает, находится ли поток в памяти, файле или сети; подробности потока получают отдельными API.

<?php
$stream = fopen("php://memory", "r+");
fclose($stream);
echo get_resource_type($stream), "
";
try {
    get_resource_type("php://memory");
} catch (TypeError $error) {
    echo "Нужен ресурс, а не строка";
}

Unknown
Нужен ресурс, а не строка

В PHP 8.5.11 закрытый поток даёт Unknown, строка — TypeError. В старых описаниях можно встретить null с предупреждением для не-ресурса; современный обработчик не должен рассчитывать на такой возврат. Проверка выполнена на целевой версии.

<?php
$line = ["qty" => 2];
$stored = serialize($line);
var_dump(is_string($stored));
echo $stored;

bool(true)
a:1:{s:3:"qty";i:2;}

a обозначает массив, s — строку, i — целое. Числа длины строк относятся к байтам. Это знакомство с представлением: собирать или чинить его вручную заменой строк не нужно.

<?php
$cart = ['version' => 1, 'items' => [['sku' => 'TEA', 'qty' => 2]]];
$encoded = serialize($cart);
$file = tempnam(sys_get_temp_dir(), 'phpman-cart-');
if ($file === false) {
    throw new RuntimeException('Не удалось создать учебный файл');
}
try {
    if (file_put_contents($file, $encoded, LOCK_EX) !== strlen($encoded)) {
        throw new RuntimeException('Неполная запись');
    }
    $bytes = file_get_contents($file);
    if ($bytes === false) {
        throw new RuntimeException('Не удалось прочитать файл');
    }
    $restored = unserialize($bytes, ['allowed_classes' => false, 'max_depth' => 8]);
    if (!is_array($restored) || ($restored['version'] ?? null) !== 1) {
        throw new UnexpectedValueException('Неизвестный формат кеша');
    }
    echo $restored['items'][0]['sku'], ':', $restored['items'][0]['qty'];
} finally {
    unlink($file);
}

TEA:2

Источник полностью создан этим примером. allowed_classes=false ограничивает восстановление обычных классов, но не делает чужие данные безопасными. Версия снимка помогает отличить старый формат. В рабочем кеше проверяют и всю схему items, а блокировка записи сама не решает гонки чтения и устаревание данных.

<?php
class CartSnapshot
{
    public function __construct(public int $quantity) {}
    public function __serialize(): array
    {
        return ['quantity' => $this->quantity];
    }
    public function __unserialize(array $data): void
    {
        if (!is_int($data['quantity'] ?? null) || $data['quantity'] < 0) {
            throw new UnexpectedValueException('Некорректное количество');
        }
        $this->quantity = $data['quantity'];
    }
}
$snapshot = new CartSnapshot(2);
$stored = serialize($snapshot);
$restored = unserialize($stored, ['allowed_classes' => [CartSnapshot::class]]);
echo $restored->quantity;

2

Это ступень после классов/конструктора. __serialize задаёт переносимое состояние, __unserialize проверяет его при восстановлении; обычный конструктор для такого восстановления не вызывается. Тип и инварианты нельзя считать автоматически выполненными только потому, что когда-то вызывали new.

<?php
$callback = static fn (): int => 2;
try {
    serialize($callback);
} catch (Exception $error) {
    echo "Closure нельзя сохранить этим способом";
}

Closure нельзя сохранить этим способом

Анонимная функция — исполняемое поведение с контекстом, а не простой снимок данных. Сохраните имя разрешённой операции и её данные, затем восстановите действие через явное отображение. Не пытайтесь сериализовать соединение с БД или ресурс потока.

<?php
$original = ["qty" => 2];
$bytes = serialize($original);
$restored = unserialize($bytes, ["allowed_classes" => false]);
echo $restored["qty"];

2

serialize создала строку, unserialize восстановила значение. Эти действия не означают отправку по сети: каналы хранения и доверие к ним — отдельная часть приложения.

<?php
set_error_handler(static function (int $level, string $message): never {
    throw new ErrorException($message, 0, $level);
});
try {
    foreach ([serialize(false), 'broken'] as $bytes) {
        try {
            $value = unserialize($bytes, ['allowed_classes' => false, 'max_depth' => 8]);
            echo 'Прочитано: ', get_debug_type($value), "\n";
        } catch (ErrorException $error) {
            echo "Повреждённый снимок\n";
        }
    }
} finally {
    restore_error_handler();
}

Прочитано: bool
Повреждённый снимок

never у callback означает, что он не возвращается обычным образом, а бросает исключение. Не выводим исходную диагностику посетителю: она может содержать детали хранения. Для реального обработчика определите область перехвата и правила журналирования; не подавляйте сообщение оператором @.

<?php
$bytes = serialize(['outer' => ['inner' => ['qty' => 2]]]);
set_error_handler(static function (int $level, string $message): never {
    throw new ErrorException($message, 0, $level);
});
try {
    try {
        unserialize($bytes, ['allowed_classes' => false, 'max_depth' => 1]);
    } catch (ErrorException $error) {
        echo "Глубина больше разрешённой\n";
    }
    $data = unserialize($bytes, ['allowed_classes' => false, 'max_depth' => 8]);
    echo $data['outer']['inner']['qty'];
} finally {
    restore_error_handler();
}

Глубина больше разрешённой
2

Лимит 1 намеренно мал для нашего собственного вложенного снимка. Число 8 соответствует маленькому договору примера, а не универсальной рекомендации. Ограничение глубины не ограничивает число соседних элементов; отдельно ограничивайте размер доверенного файла.

<?php
class DeliverySnapshot
{
    public int $places = 2;
}
$bytes = serialize(new DeliverySnapshot());
$value = unserialize($bytes, ["allowed_classes" => false]);
echo get_debug_type($value), "
";
var_dump(is_object($value));

__PHP_Incomplete_Class
bool(true)

Получен объект, но не полноценный DeliverySnapshot. is_object сам не доказывает готовность к вызову методов. allowed_classes не распространяется на перечисления enum; это ограничение конкретного механизма, не универсальная песочница.

<?php
$bytes = serialize(['qty' => 2]);
foreach (['8', -1] as $depth) {
    try {
        unserialize($bytes, ['allowed_classes' => false, 'max_depth' => $depth]);
    } catch (TypeError | ValueError $error) {
        echo get_class($error), "\n";
    }
}

TypeError
ValueError

max_depth принимает int от 0, а не числовую строку: "8" здесь не приводится автоматически. Отрицательное целое даёт ValueError. Сам снимок корректен; исправить нужно параметры вызова. Вертикальная черта в catch позволяет обработать два типа исключений.