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

PHP 4.3.0+ · standard

stream_context_get_options(resource $stream_or_context): array

Посмотреть сохранённые wrapper-настройки ресурса, не открывая соединение.

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

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

<?php
declare(strict_types=1);

$context = stream_context_create(['http' => ['timeout' => 4]]);
$options = stream_context_get_options($context);
echo 'Timeout: ', $options['http']['timeout'], "\n";

Timeout: 4

<?php
declare(strict_types=1);

$context = stream_context_create(['http' => ['timeout' => 2]]);
$copy = stream_context_get_options($context);
$copy['http']['timeout'] = 99;
echo stream_context_get_options($context)['http']['timeout'], "\n";
stream_context_set_option($context, 'http', 'timeout', 3);
echo stream_context_get_options($context)['http']['timeout'], "\n";

2
3

Связанные операции: stream_context_get_params, stream_context_set_option, stream_context_set_options.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_context_get_options

PHP 4.3.0+ · standard

stream_context_set_option(resource $stream_or_context, string $wrapper, string $option_name, mixed $value): bool

Установить одно значение wrapper-настройки в существующем контексте или потоке.

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

Нужно изменить только timeout одного ресурса, не трогая его method и остальные поля. Четырёхаргументный set_option записывает одну настройку. Имя wrapper не всегда равно схеме адреса: HTTPS-запрос всё равно использует группу http для метода и timeout.

<?php
declare(strict_types=1);

$context = stream_context_create(['http' => ['method' => 'GET', 'timeout' => 2]]);
$changed = stream_context_set_option($context, 'http', 'timeout', 5);
$options = stream_context_get_options($context)['http'];
var_dump($changed);
echo $options['method'], '/', $options['timeout'], "\n";

bool(true)
GET/5

<?php
declare(strict_types=1);

$first = stream_context_create(['http' => ['timeout' => 2]]);
$second = $first;
stream_context_set_option($second, 'http', 'timeout', 7);
echo stream_context_get_options($first)['http']['timeout'], "\n";

7

Связанные операции: stream_context_set_options, stream_context_create, stream_context_get_options.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_context_set_option

PHP 8.3.0+ · standard

stream_context_set_options(resource $context, array $options): true

Дополнить контекст набором wrapper-настроек без устаревшей перегрузки set_option.

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

Настроек несколько: method, timeout и ограничение редиректов. Начиная с PHP 8.3 отдельная функция принимает массив групп. Она дополняет/заменяет переданные поля, а не очищает остальные группы и не проверяет безопасность всей политики.

<?php
declare(strict_types=1);

$context = stream_context_create(['http' => ['method' => 'GET']]);
$ok = stream_context_set_options($context, ['http' => ['timeout' => 2, 'follow_location' => 0]]);
$options = stream_context_get_options($context)['http'];
var_dump($ok);
echo $options['method'], '/', $options['timeout'], '/', $options['follow_location'], "\n";

bool(true)
GET/2/0

<?php
declare(strict_types=1);

$context = stream_context_create();
try { stream_context_set_options($context, ['timeout' => 2]); }
catch (ValueError $error) { echo "Нужна группа wrapper\n"; }
stream_context_set_options($context, ['http' => ['timeout' => 2]]);
echo stream_context_get_options($context)['http']['timeout'], "\n";

Нужна группа wrapper
2

Связанные операции: stream_context_set_option, stream_context_get_options.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_context_set_options

PHP 5.3.0+ · standard

stream_context_get_params(resource $context): array

Получить параметры контекста вместе с wrapper-options, например для диагностики регистрации notification.

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

Кроме настроек wrapper, контекст может нести callback уведомлений. get_params позволяет посмотреть оба слоя: отдельное поле notification и вложенный массив options. Параметры не нужно искать внутри http.

<?php
declare(strict_types=1);

$context = stream_context_create(['http' => ['timeout' => 2]]);
$params = stream_context_get_params($context);
echo $params['options']['http']['timeout'], "\n";
var_dump(array_key_exists('notification', $params));

2
bool(false)

<?php
declare(strict_types=1);

$notify = function ($code, $severity, $message, $messageCode, $transferred, $maximum) {};
$context = stream_context_create(['http' => ['timeout' => 2]], ['notification' => $notify]);
$params = stream_context_get_params($context);
var_dump($params['notification'] === $notify);
echo $params['options']['http']['timeout'], "\n";

bool(true)
2

Связанные операции: stream_context_get_options, stream_context_set_params, stream_notification_callback.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_context_get_params

PHP 4.3.0+ · standard

stream_context_set_params(resource $context, array $params): true

Зарегистрировать параметры контекста, прежде всего callback уведомлений.

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

Обработчик прогресса можно подключить после создания контекста. set_params изменяет общие параметры. Поддерживаемые поля этой страницы — notification и options; произвольное поле business_id не превращается в новый API уведомления.

<?php
declare(strict_types=1);

$context = stream_context_create();
$notify = function ($code, $severity, $message, $messageCode, $transferred, $maximum) {};
$ok = stream_context_set_params($context, [
    'notification' => $notify,
    'options' => ['http' => ['timeout' => 3]],
]);
$params = stream_context_get_params($context);
var_dump($ok, $params['notification'] === $notify);
echo $params['options']['http']['timeout'], "\n";

bool(true)
bool(true)
3

<?php
declare(strict_types=1);

$first = function ($code, $severity, $message, $messageCode, $transferred, $maximum) {};
$second = function ($code, $severity, $message, $messageCode, $transferred, $maximum) {};
$context = stream_context_create(null, ['notification' => $first]);
stream_context_set_params($context, ['notification' => $second]);
var_dump(stream_context_get_params($context)['notification'] === $second);

bool(true)

Уведомления поддерживаются HTTP/FTP wrappers; это не универсальные события для любого fopen локального файла. options внутри params имеют тот же вложенный формат, что у create. Неправильные типы/ресурсы дают TypeError, неправильная форма options — ValueError. Успех регистрации не означает, что callback уже был вызван или что будущий запрос завершится. Не используйте внешнюю строку как произвольное имя вызываемой функции.

Связанные операции: stream_context_get_params, stream_context_create, stream_notification_callback.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_context_set_params

PHP 5.1.0+ · standard

stream_context_get_default(?array $options = null): resource

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

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

У процесса есть контекст по умолчанию: его используют открытия без явно переданного context. get_default возвращает именно этот общий ресурс. Если передать options, функция одновременно изменит его — название get не означает безусловно чистое чтение.

<?php
declare(strict_types=1);

$first = stream_context_get_default();
$second = stream_context_get_default();
var_dump($first === $second);

bool(true)

<?php
declare(strict_types=1);

$default = stream_context_get_default(['http' => ['timeout' => 4]]);
$separate = stream_context_create(['http' => ['timeout' => 1]]);
echo stream_context_get_options(stream_context_get_default())['http']['timeout'], "\n";
echo stream_context_get_options($separate)['http']['timeout'], "\n";

4
1

Связанные операции: stream_context_create, stream_context_set_default, stream_context_get_options.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_context_get_default

PHP 5.3.0+ · standard

stream_context_set_default(array $options): resource

Явно дополнить общую политику контекста там, где код владеет всем процессом.

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

Иногда главный CLI-скрипт сознательно задаёт общую политику до подключения библиотек. set_default подходит владельцу всего процесса, но опасен как незаметный побочный эффект маленькой helper-функции. Настройки дополняются, а не заменяются целиком.

<?php
declare(strict_types=1);

$default = stream_context_set_default(['http' => ['timeout' => 2, 'follow_location' => 0]]);
var_dump($default === stream_context_get_default());
echo stream_context_get_options($default)['http']['timeout'], "\n";

bool(true)
2

<?php
declare(strict_types=1);

stream_context_set_default(['http' => ['method' => 'GET', 'timeout' => 2]]);
stream_context_set_default(['http' => ['timeout' => 5]]);
stream_context_set_default([]);
$options = stream_context_get_options(stream_context_get_default())['http'];
echo $options['method'], '/', $options['timeout'], "\n";

GET/5

Связанные операции: stream_context_get_default, stream_context_create, stream_context_get_options.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_context_set_default

PHP 5.2.0+; prototype only · standard

prototype callback(int $notification_code, int $severity, ?string $message, int $message_code, int $bytes_transferred, int $bytes_max): void

Реализовать свой обработчик уведомлений о работе HTTP/FTP-потока.

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

Команда скачивает свой отчёт и хочет показать полученное количество байтов. notification — callback, который wrapper вызывает при событиях. Название stream_notification_callback в мануале описывает прототип: такой встроенной функции нет. Вы создаёте функцию с собственным именем или замыкание и регистрируете её в params.notification.

<?php
declare(strict_types=1);

var_dump(function_exists('stream_notification_callback'));
$events = [];
$notify = function ($code, $severity, $message, $messageCode, $transferred, $maximum) use (&$events) {
    if ($code === STREAM_NOTIFY_PROGRESS) { $events[] = $transferred; }
};
$context = stream_context_create(null, ['notification' => $notify]);
$notify(STREAM_NOTIFY_PROGRESS, STREAM_NOTIFY_SEVERITY_INFO, null, 0, 128, 0);
echo $events[0], " байтов\n";

bool(false)
128 байтов

<?php
declare(strict_types=1);

function progressLabel($received, $total) {
    if ($total <= 0) { return $received . ' байтов, размер неизвестен'; }
    return $received . ' из ' . $total . ' байтов';
}
echo progressLabel(128, 0), "\n";
echo progressLabel(128, 256), "\n";

128 байтов, размер неизвестен
128 из 256 байтов

severity принимает STREAM_NOTIFY_SEVERITY_INFO, WARN или ERR. message может быть null, message_code зависит от wrapper. return callback не возвращает скачанные байты и не является общим протоколом «отменить запрос». Порядок/количество вызовов не фиксируют в тесте как одинаковые для FTP, HTTP, сжатия и разных серверов. Настоящий локальный HTTP-тест этой главы отдельно проверяет получение события, не выдаёт прямой вызов функции за сетевое испытание.

Связанные операции: stream_context_create, stream_context_set_params, stream_context_get_params.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_notification_callback

PHP 5+ · standard

stream_get_contents(resource $stream, ?int $length = null, int $offset = -1): string|false

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

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

Файл уже открыт, первые байты прочитаны, и теперь нужен остаток как строка. stream_get_contents работает с этим ресурсом и его текущей позицией. Он не открывает файл по имени заново и не возвращает автоматически ранее прочитанные байты.

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/pickup.txt', 'rb');
if ($stream === false) { throw new RuntimeException('Не открыть лист выдачи'); }
try {
    echo 'Номер: ', rtrim(fgets($stream)), "\n";
    $details = stream_get_contents($stream);
    if ($details === false) { throw new RuntimeException('Не прочитать позиции'); }
    echo "Остаток документа:\n", $details;
} finally { fclose($stream); }

Номер: 104
Остаток документа:
TEA:2
MILK:1

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/catalog.txt', 'rb');
try {
    echo stream_get_contents($stream, 3), "\n";
    echo stream_get_contents($stream, 2), "\n";
    echo stream_get_contents($stream, 3, 0), "\n";
} finally { fclose($stream); }

Tea
:m
Tea

<?php
declare(strict_types=1);

$stream = fopen('php://memory', 'w+');
try {
    fwrite($stream, "A\0B"); rewind($stream);
    $bytes = stream_get_contents($stream, 3);
    echo bin2hex($bytes), "\n";
    var_dump(stream_get_contents($stream));
} finally { fclose($stream); }

410042
string(0) ""

length=null читает оставшееся до конца; с PHP 8.0 это явный nullable параметр. Историческое -1 также означает остаток в PHP 8.5.11, меньше -1 даёт ValueError; для нового кода пишите null. length=0 даёт пустую строку. Отрицательный offset не делает seek; неотрицательный задаёт абсолютную позицию. Неверный ресурс даёт TypeError; невозможное позиционирование/чтение может дать warning и false. Проверяйте === false отдельно от пустой строки.

Связанные операции: stream_get_line, stream_copy_to_stream, stream_get_meta_data.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_get_contents

PHP 5+ · standard

stream_copy_to_stream(resource $from, resource $to, ?int $length = null, int $offset = 0): int|false

Перенести байты между открытыми ресурсами и проверить фактически скопированный объём.

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

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

<?php
declare(strict_types=1);

$from = fopen(__DIR__ . '/pickup.txt', 'rb');
$to = fopen(__DIR__ . '/archive.txt', 'wb');
if ($from === false || $to === false) { throw new RuntimeException('Не открыть файлы'); }
try {
    $copied = stream_copy_to_stream($from, $to);
    if ($copied === false) { throw new RuntimeException('Копирование не завершено'); }
    echo 'Скопировано байтов: ', $copied, "\n";
} finally { fclose($from); fclose($to); }
echo "archive.txt:\n", file_get_contents(__DIR__ . '/archive.txt');

Скопировано байтов: 17
archive.txt:
104
TEA:2
MILK:1

<?php
declare(strict_types=1);

$source = fopen(__DIR__ . '/report.txt', 'rb');
$target = fopen('php://temp', 'w+');
try {
    fread($source, 4);
    stream_copy_to_stream($source, $target, 2, 0);
    stream_copy_to_stream($source, $target, 3, 1);
    rewind($target);
    echo stream_get_contents($target), "\n";
} finally { fclose($source); fclose($target); }

miea:

<?php
declare(strict_types=1);

$source = fopen(__DIR__ . '/report.txt', 'rb');
$target = fopen('php://temp', 'w+');
try {
    $copied = stream_copy_to_stream($source, $target, 10);
    if ($copied === false) { echo "Ошибка копирования\n"; }
    elseif ($copied !== 10) { echo 'Короткий источник: ', $copied, " байта\n"; }
    else { echo "Получен весь ожидаемый фрагмент\n"; }
} finally { fclose($source); fclose($target); }

Короткий источник: 3 байта

length=null — до конца, nullable с PHP 8.0. В PHP 8.5 отрицательные length также фактически ведут к чтению остатка; новый прикладной контракт лучше ограничить null или числом ≥0. offset>0 перемещает только источник и требует seek; offset≤0 оставляет текущую позицию. При отказе часть данных уже могла быть записана: атомарного отката нет. У blocking socket чтение может остановиться по timeout до EOF и вернуть false после частичной записи. Для публикации файла используют отдельный временный результат, проверку и затем согласованную замену, а не объявляют target готовым заранее.

Связанные операции: stream_get_contents, stream_set_timeout, stream_get_meta_data.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_copy_to_stream

PHP 5+ · standard

stream_get_line(resource $stream, int $length, string $ending = ""): string|false

Прочитать фрагмент до выбранного разделителя без включения разделителя в результат.

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

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

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/items.txt', 'rb');
try {
    echo stream_get_line($stream, 100, '|'), "\n";
    echo stream_get_line($stream, 100, '|'), "\n";
} finally { fclose($stream); }

tea
mint

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/items.txt', 'rb');
try {
    $items = [];
    while (($line = stream_get_line($stream, 100, '|')) !== false) {
        $items[] = '[' . $line . ']';
    }
    echo implode(',', $items), "\n";
} finally { fclose($stream); }

[tea],[],[mint]

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/items.txt', 'rb');
try {
    echo stream_get_line($stream, 3, '|'), "\n";
    echo stream_get_line($stream, 3, '|'), "\n";
} finally { fclose($stream); }

abc
def

Связанные операции: stream_get_contents, stream_get_meta_data.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_get_line

PHP 4.3.0+ · standard

stream_get_meta_data(resource $stream): array

Получить диагностическое состояние открытого потока и учитывать различия wrapper.

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

Когда чтение пошло не так, нужны свойства ресурса: поддерживается ли seek, истёк ли timeout, какой wrapper его открыл. get_meta_data смотрит уже существующий поток. Массив различается между файловым, HTTP и TLS потоком; обращаться ко всем возможным ключам без проверки нельзя.

<?php
declare(strict_types=1);

$stream = fopen('php://memory', 'w+b');
try {
    fwrite($stream, "104:ready\n");
    $info = stream_get_meta_data($stream);
    echo 'Режим: ', $info['mode'], "\n";
    if (!$info['seekable']) { throw new RuntimeException('Нужен новый источник для повторного чтения'); }
    rewind($stream);
    echo stream_get_contents($stream);
} finally { fclose($stream); }

Режим: w+b
104:ready

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/items.txt', 'rb');
try {
    echo stream_get_contents($stream), "\n";
    $meta = stream_get_meta_data($stream);
    if (!$meta['seekable']) { throw new RuntimeException('Нужен новый источник'); }
    if (fseek($stream, 0) !== 0) { throw new RuntimeException('Перемотка не удалась'); }
    echo stream_get_contents($stream), "\n";
} finally { fclose($stream); }

tea
tea

При нескольких HTTP-ответах wrapper_data может содержать redirect chain: первая status line не обязана описывать окончательный ответ. Ресурс, созданный расширением Sockets как объект Socket, сюда не подходит; нужен именно stream (или корректный адаптер). В PHP 8.5.11 неверный/закрытый ресурс приводит к TypeError. Получение и интерпретация HTTP-заголовков разбирает значения ответа отдельно.

Связанные операции: stream_set_timeout, stream_set_blocking, stream_get_contents.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_get_meta_data

PHP 5.3.2+ · standard

stream_resolve_include_path(string $filename): string|false

Разрешить имя своего файла по include_path, не исполняя его.

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

Для собственного шаблона известно короткое имя, а каталог выбирается конфигурацией include_path. resolve_include_path позволяет узнать разрешённый путь заранее; она не подключает и не исполняет PHP-файл. Это поиск по правилам открытия, а не контроль доступа к произвольному имени от посетителя.

<?php
declare(strict_types=1);

$before = get_include_path();
try {
    set_include_path(__DIR__ . '/templates');
    $path = stream_resolve_include_path('receipt.txt');
    if ($path === false) { throw new RuntimeException('Шаблон отсутствует'); }
    echo basename($path), '/', file_get_contents($path), "\n";
} finally { set_include_path($before); }

receipt.txt/Tea receipt

<?php
declare(strict_types=1);

$old = get_include_path();
set_include_path(__DIR__ . '/templates');
try {
    $path = stream_resolve_include_path('missing-receipt.txt');
    echo $path === false ? "Шаблон чека не найден: проверьте комплект файлов.\n" : file_get_contents($path);
} finally { set_include_path($old); }

Шаблон чека не найден: проверьте комплект файлов.

Связанные операции: stream_get_wrappers, stream_is_local.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_resolve_include_path

PHP 5.3.0+ · standard

stream_supports_lock(resource $stream): bool

Узнать поддержку flock перед выбором стратегии синхронизации.

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

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

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/events.txt', 'c+b');
if ($stream === false) { throw new RuntimeException('Не открыть журнал'); }
try {
    echo stream_supports_lock($stream)
        ? "Поток поддерживает flock; перед записью ещё надо получить блокировку.\n"
        : "Этот поток не подходит для нашего общего журнала.\n";
} finally { fclose($stream); }

Поток поддерживает flock; перед записью ещё надо получить блокировку.

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/events.txt', 'c+b');
if ($stream === false) { throw new RuntimeException('Не открыть журнал'); }
try {
    if (!stream_supports_lock($stream) || !flock($stream, LOCK_EX)) {
        throw new RuntimeException('Нельзя получить блокировку журнала');
    }
    try {
        if (fseek($stream, 0, SEEK_END) !== 0) { throw new RuntimeException('Не найти конец'); }
        $event = "104:ready\n";
        if (fwrite($stream, $event) !== strlen($event) || !fflush($stream)) {
            throw new RuntimeException('Событие не сохранено полностью');
        }
    } finally { flock($stream, LOCK_UN); }
} finally { fclose($stream); }
echo file_get_contents(__DIR__ . '/events.txt');

104:created
104:ready

Связанные операции: stream_get_meta_data, stream_is_local.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_supports_lock

PHP 5.2.4+ · standard

stream_is_local(resource|string $stream): bool

Различить классификацию local/URL wrapper без ложного обещания безопасности пути.

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

Инструмент выбирает обработку между файловым и URL-wrapper. is_local смотрит категорию wrapper, а не делает DNS, не измеряет расстояние до сервера и не проверяет, что путь безопасен. HTTP на 127.0.0.1 остаётся URL-потоком; data:// тоже не следует считать обычным локальным файлом.

<?php
declare(strict_types=1);

var_dump(stream_is_local(__DIR__ . '/missing.txt'));
var_dump(stream_is_local('php://temp'));
var_dump(stream_is_local('http://127.0.0.1/report'));

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

<?php
declare(strict_types=1);

$warning = false;
set_error_handler(function ($level) use (&$warning) {
    if ($level === E_WARNING) { $warning = true; return true; }
    return false;
});
try { $local = stream_is_local('lesson-missing-wrapper://report'); }
finally { restore_error_handler(); }
var_dump($local, $warning);

bool(true)
bool(true)

Связанные операции: stream_get_wrappers, stream_resolve_include_path.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_is_local

PHP 7.2.0+ · standard

stream_isatty(resource $stream): bool

Проверить терминальное назначение CLI-потока, чтобы не загрязнять перенаправленный вывод.

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

CLI-инструмент может рисовать изменяющийся прогресс только в терминале, а при записи результата в файл должен печатать обычные строки. isatty помогает узнать, является ли конкретный поток терминальным устройством. Это переносимая на Windows альтернатива posix_isatty, но не проверка всех возможностей цвета терминала.

<?php
declare(strict_types=1);

$output = fopen(__DIR__ . '/result.txt', 'wb');
if ($output === false) { throw new RuntimeException('Не открыть результат'); }
try {
    if (stream_isatty($output)) { fwrite($output, "Готовим отчёт...\r"); }
    fwrite($output, "104:ready\n");
} finally { fclose($output); }
echo file_get_contents(__DIR__ . '/result.txt');

104:ready

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    $interactive = stream_isatty($stream);
    fwrite($stream, $interactive ? "\rГотово: 1/2" : "Готово: 1/2\n");
    rewind($stream);
    echo stream_get_contents($stream);
} finally { fclose($stream); }

Готово: 1/2

Связанные операции: stream_get_meta_data, stream_is_local.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_isatty

PHP 5+ · standard

stream_get_transports(): array

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

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

Прежде чем выбирать transport для сокета, узнайте, зарегистрирован ли он в данной сборке PHP. Transports — tcp, udp, tls и подобные механизмы. Это другой список, чем wrappers вроде http или file. Наличие tls ещё не доказывает доступность сети, доверенных сертификатов или совместимость сервера.

<?php
declare(strict_types=1);

$transports = stream_get_transports();
echo in_array('tcp', $transports, true) ? "TCP зарегистрирован\n" : "TCP отсутствует\n";

TCP зарегистрирован

<?php
declare(strict_types=1);

$allowed = ['tcp', 'udp'];
$available = stream_get_transports();
foreach ($allowed as $name) {
    if (in_array($name, $available, true)) { echo $name, " доступен\n"; }
}

tcp доступен
udp доступен

Связанные операции: stream_get_wrappers, stream_socket_client, stream_socket_server.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_get_transports

PHP 5+ · standard

stream_get_wrappers(): array

Узнать зарегистрированные схемы открытия потоков, отделяя доступность от разрешённости.

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

Код получил путь вида scheme://target. Имя scheme выбирает wrapper — реализацию открытия и операций. Список зависит от расширений и пользовательских регистраций. Например, http использует HTTP-протокол поверх транспорта, а php://temp реализует временное хранение.

<?php
declare(strict_types=1);

if (!in_array('php', stream_get_wrappers(), true)) {
    throw new RuntimeException('Нет встроенного php wrapper');
}
$stream = fopen('php://memory', 'w+b');
try { fwrite($stream, "104:ready\n"); rewind($stream); echo stream_get_contents($stream); }
finally { fclose($stream); }

104:ready

<?php
declare(strict_types=1);

$scheme = 'lesson-private-catalog';
if (!in_array($scheme, stream_get_wrappers(), true)) {
    echo "Каталог не подключён: wrapper отсутствует\n";
}

Каталог не подключён: wrapper отсутствует

Связанные операции: stream_wrapper_register, stream_wrapper_unregister, stream_wrapper_restore, stream_get_transports.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_get_wrappers

PHP 5.4.0+ · standard

stream_set_chunk_size(resource $stream, int $size): int

Настроить внутреннюю порцию потока и сохранить прежнее значение для восстановления.

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

При работе с потоком PHP читает/передаёт данные внутренними порциями. set_chunk_size меняет выбранный размер такой порции и возвращает прежний. Это настройка механизма, а не разбиение вашего документа на гарантированные сообщения ровно по N байтов.

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    $original = stream_set_chunk_size($stream, 1024);
    $previous = stream_set_chunk_size($stream, 2048);
    echo $previous, "\n";
    stream_set_chunk_size($stream, $original);
} finally { fclose($stream); }

1024

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/record.txt', 'rb');
try {
    stream_set_chunk_size($stream, 2);
    echo stream_get_contents($stream, 5), "\n";
    echo stream_get_contents($stream), "\n";
} finally { fclose($stream); }

abcde
fgh

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    try { stream_set_chunk_size($stream, 0); }
    catch (ValueError $error) { echo "Chunk должен быть положительным\n"; }
} finally { fclose($stream); }

Chunk должен быть положительным

Измеряйте настройку на вашем wrapper, размере данных и инфраструктуре. Маленькие порции могут увеличить число вызовов, большие — память/задержку первой порции; универсального быстрого значения нет. Положительное int ограничено PHP_INT_MAX самой платформы. Значение вне диапазона PHP int нельзя безопасно протолкнуть float/string без проверки типов.

Связанные операции: stream_set_read_buffer, stream_get_contents, stream_set_write_buffer.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_set_chunk_size

PHP 5.3.3+ · standard

stream_set_read_buffer(resource $stream, int $size): int

Попросить wrapper изменить буферизацию чтения и проверить, принял ли он запрос.

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

Если нужно изменить буферизацию чтения, set_read_buffer передаёт соответствующий запрос реализации потока. Не каждый wrapper его выполняет. Успех — число 0; это особенно важно, потому что обычное if ($result) перевернуло бы смысл проверки.

<?php
declare(strict_types=1);

$stream = fopen('php://memory', 'w+');
try {
    fwrite($stream, 'tea'); rewind($stream);
    $status = stream_set_read_buffer($stream, 0);
    echo $status === 0 ? "Запрос принят\n" : "Wrapper не применил настройку\n";
    echo fread($stream, 3), "\n";
} finally { fclose($stream); }

Запрос принят
tea

<?php
declare(strict_types=1);

$stream = fopen(__DIR__ . '/record.txt', 'rb');
try {
    $status = stream_set_read_buffer($stream, 0);
    if ($status !== 0) { throw new RuntimeException('Этот режим чтения недоступен'); }
    $first = fread($stream, 3);
    $second = fread($stream, 3);
    echo $first, '/', $second, "\n";
} finally { fclose($stream); }

abc/def

size — число байтов; 0 запрашивает отключение буферизации чтения. Формулировку старой документации о порядке чтения процессов нельзя превращать в гарантию взаимного исключения: функция не устанавливает flock и не делает последовательность из нескольких read атомарной. Для координации процессов нужны отдельно выбранные блокировки/протоколы. Поддержка и точный эффект зависят от реализации потока; новые настройки не возвращают уже потреблённые данные.

Связанные операции: stream_set_write_buffer, stream_set_chunk_size, stream_supports_lock.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_set_read_buffer

PHP 4.3.0+ · standard

stream_set_write_buffer(resource $stream, int $size): int

Запросить размер буферизации записи, предусмотрев неподдерживаемый wrapper.

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

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

<?php
declare(strict_types=1);

$stream = fopen('php://memory', 'w+');
try {
    $status = stream_set_write_buffer($stream, 0);
    echo $status === 0 ? "Запрос принят\n" : "Wrapper не поддерживает настройку\n";
    fwrite($stream, 'receipt');
    rewind($stream);
    echo stream_get_contents($stream), "\n";
} finally { fclose($stream); }

Wrapper не поддерживает настройку
receipt

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    if (stream_set_write_buffer($stream, 0) !== 0) {
        echo "Выберите другой приёмник: нужный режим недоступен\n";
    } else {
        fwrite($stream, 'approved');
        echo "Выбранный режим доступен\n";
    }
} finally { fclose($stream); }

Выберите другой приёмник: нужный режим недоступен

Связанные операции: stream_set_read_buffer, stream_set_chunk_size, stream_supports_lock.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_set_write_buffer

PHP 4.3.0+ · standard

stream_set_blocking(resource $stream, bool $enable): bool

Выбрать, должен ли поддерживаемый поток ждать данные, и организовать продолжение отдельно.

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

Интеграция ожидает ответ. В blocking-режиме read может ждать данные; в non-blocking он возвращает управление, даже когда сейчас читать нечего. Само переключение не выполняет параллельный код и не превращает приложение в асинхронный фреймворк. Нужно отдельно решить, когда попробовать снова и когда завершить ожидание.

Следующие примеры подключают приложенный tcp-lab.php: он создаёт две стороны настоящего TCP-соединения только на 127.0.0.1 с автоматически выбранным портом. Клиент подключается к нашему временному listener, accept получает вторую сторону, listener закрывается. Тесты не обращаются к интернету. lessonWriteAll / lessonReadExact обрабатывают частичные операции для маленьких сообщений; полный исходник fixture поставляется вместе с примером. Это лаборатория механизма, не готовый многопользовательский сервер.

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    if (!stream_set_blocking($peer, false)) { throw new RuntimeException('Non-blocking unsupported'); }
    $empty = fread($peer, 16);
    var_dump($empty, feof($peer));
    lessonWriteAll($client, 'tea');
    stream_set_blocking($peer, true);
    echo lessonReadExact($peer, 3), "\n";
} finally { fclose($client); fclose($peer); }

string(0) ""
bool(false)
tea

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    $original = stream_get_meta_data($peer)['blocked'];
    try {
        stream_set_blocking($peer, false);
        var_dump(stream_get_meta_data($peer)['blocked']);
    } finally { stream_set_blocking($peer, $original); }
    var_dump(stream_get_meta_data($peer)['blocked'] === $original);
} finally { fclose($client); fclose($peer); }

bool(false)
bool(true)

enable=true задаёт blocking, false — non-blocking. Поддержка зависит от stream; на Windows non-blocking режим локальных обычных файлов не поддерживается и такая настройка не оказывает на них нужного эффекта. Для сокетов readiness проверяют stream_select. Готовность к записи не гарантирует запись всего сообщения одним fwrite; нужно отслеживать число байтов. После ошибки/пустого чтения проверяют состояние и протокол, не безусловно продолжают цикл.

Связанные операции: stream_select, stream_set_timeout, stream_get_meta_data.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_set_blocking

PHP 4.3.0+ · standard

stream_set_timeout(resource $stream, int $seconds, int $microseconds = 0): bool

Ограничить ожидание данных в поддерживаемом потоке и после операции проверить timed_out.

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

У TCP-соединения уже завершён connect, но удалённая сторона может молчать. set_timeout ограничивает поддерживаемые операции ожидания ввода-вывода этого потока. Это не timeout создания соединения и не общий deadline всего импорта, состоящего из многих операций.

Следующие примеры подключают приложенный tcp-lab.php: он создаёт две стороны настоящего TCP-соединения только на 127.0.0.1 с автоматически выбранным портом. Клиент подключается к нашему временному listener, accept получает вторую сторону, listener закрывается. Тесты не обращаются к интернету. lessonWriteAll / lessonReadExact обрабатывают частичные операции для маленьких сообщений; полный исходник fixture поставляется вместе с примером. Это лаборатория механизма, не готовый многопользовательский сервер.

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    if (!stream_set_timeout($peer, 0, 20000)) { throw new RuntimeException('Timeout unsupported'); }
    $result = fread($peer, 1);
    $state = stream_get_meta_data($peer);
    echo $state['timed_out'] ? "Ожидание истекло\n" : "Данные получены\n";
    var_dump(feof($peer));
} finally { fclose($client); fclose($peer); }

Ожидание истекло
bool(false)

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    stream_set_timeout($peer, 0, 20000);
    fread($peer, 1);
    if (!stream_get_meta_data($peer)['timed_out']) { throw new RuntimeException('Expected local timeout'); }
    lessonWriteAll($client, 'ok');
    stream_set_timeout($peer, 1);
    echo lessonReadExact($peer, 2), "\n";
    var_dump(stream_get_meta_data($peer)['timed_out']);
} finally { fclose($client); fclose($peer); }

ok
bool(false)

Суммарное время задаётся seconds + microseconds. Принимайте проверенные неотрицательные значения; timeout относится к поддерживаемому stream I/O. Для stream_socket_recvfrom этот setter не работает как обещание предельного ожидания: используйте stream_select с timeout. Исторические имена set_socket_timeout / socket_set_timeout рассматривайте в их отдельных alias-карточках, новый код использует stream_set_timeout.

Связанные операции: stream_get_meta_data, stream_select, stream_socket_client.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_set_timeout

PHP 4.3.0+ · standard

stream_select(?array &$read, ?array &$write, ?array &$except, ?int $seconds, ?int $microseconds = null): int|false

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

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

Есть несколько потоков, и пока нельзя читать из любого наугад: один ещё молчит. stream_select ждёт готовность и сокращает переданные массивы до тех ресурсов, с которыми операция сейчас не должна блокироваться. Она не читает сообщения и не запускает callback. Сама программа выбирает, что сделать после её возврата.

Следующие примеры подключают приложенный tcp-lab.php: он создаёт две стороны настоящего TCP-соединения только на 127.0.0.1 с автоматически выбранным портом. Клиент подключается к нашему временному listener, accept получает вторую сторону, listener закрывается. Тесты не обращаются к интернету. lessonWriteAll / lessonReadExact обрабатывают частичные операции для маленьких сообщений; полный исходник fixture поставляется вместе с примером. Это лаборатория механизма, не готовый многопользовательский сервер.

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    $read = ['reply' => $peer]; $write = null; $except = null;
    echo stream_select($read, $write, $except, 0), "\n";
    lessonWriteAll($client, 'tea');
    $read = ['reply' => $peer]; $write = null; $except = null;
    $ready = stream_select($read, $write, $except, 1);
    if ($ready === false || $ready === 0) { throw new RuntimeException('Local reply not ready'); }
    echo array_key_first($read), '/', lessonReadExact($read['reply'], 3), "\n";
} finally { fclose($client); fclose($peer); }

0
reply/tea

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    stream_socket_shutdown($client, STREAM_SHUT_WR);
    $read = [$peer]; $write = null; $except = null;
    $ready = stream_select($read, $write, $except, 1);
    if ($ready === false || $ready === 0) { throw new RuntimeException('EOF not ready'); }
    var_dump(fread($peer, 1), feof($peer));
} finally { fclose($client); fclose($peer); }

string(0) ""
bool(true)

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    lessonWriteAll($client, 'abcd');
    echo fread($peer, 1), "\n";
    $read = [$peer]; $write = [$client]; $except = null;
    $count = stream_select($read, $write, $except, 0);
    echo $count, '/', count($read), '/', count($write), "\n";
    echo lessonReadExact($peer, 3), "\n";
} finally { fclose($client); fclose($peer); }

a
1/1/0
bcd

Сигнал ОС способен прервать системное ожидание и привести к false. Некоторые streams, например zlib, не имеют подходящего дескриптора. На Windows proc_open pipes не поддерживаются stream_select, а готовность консольного STDIN по событию ещё не гарантирует неблокирующий ввод строки. Если данные уже во внутреннем PHP-буфере, применяется описанный быстрый путь: write/except в этот раз не проверяются. Универсальный event loop должен учитывать эти ограничения, EOF, неполные read/write и собственный deadline.

Связанные операции: stream_set_blocking, stream_set_timeout, stream_get_meta_data, stream_socket_recvfrom.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_select

PHP 5+ · standard

stream_socket_server(string $address, int &$error_code = null, string &$error_message = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, ?resource $context = null): resource|false

Создать локальный адрес для входящих соединений, отделяя listener от принятого клиента.

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

Для локального учебного сервиса нужен адрес, к которому сможет подключиться клиент. server создаёт слушающий ресурс; входящего клиента он ещё не принимает. В примерах выбираем только loopback 127.0.0.1 и порт 0 — ОС выделит свободный порт, поэтому не занимаем заранее известный порт приложения.

<?php
declare(strict_types=1);

$server = stream_socket_server('tcp://127.0.0.1:0', $errorCode, $errorMessage);
if ($server === false) { throw new RuntimeException('Listener не создан'); }
try {
    $address = stream_socket_get_name($server, false);
    echo str_starts_with($address, '127.0.0.1:') ? "Слушаем только loopback\n" : "Иной адрес\n";
} finally { fclose($server); }

Слушаем только loopback

<?php
declare(strict_types=1);

$server = stream_socket_server('tcp://127.0.0.1:0', $errorCode, $errorMessage);
if ($server === false) { throw new RuntimeException('Нет listener'); }
$client = false; $peer = false;
try {
    $address = stream_socket_get_name($server, false);
    $client = stream_socket_client('tcp://' . $address, $errorCode, $errorMessage, 1);
    if ($client === false) { throw new RuntimeException('Нет client'); }
    $peer = stream_socket_accept($server, 1);
    if ($peer === false) { throw new RuntimeException('Нет peer'); }
    echo ($server !== $peer && $client !== $peer) ? "Три разных ресурса\n" : "Ошибка модели\n";
} finally {
    if (is_resource($peer)) { fclose($peer); }
    if (is_resource($client)) { fclose($client); }
    fclose($server);
}

Три разных ресурса

error_code и error_message заполняются по ссылке при отказах socket/bind/listen. false при error_code=0 может означать отказ до системного bind; не воспринимайте 0 как успех без ресурса. Сообщение ОС не выводят посетителю целиком. context задаёт параметры socket/TLS; null допустим с PHP 8.0. Порт ниже 1024 на многих системах требует дополнительных прав; учебный ephemeral port этого не требует. Открытие на 0.0.0.0 или :: расширило бы доступ за пределы loopback — не подменяйте адрес без понимания назначения.

Связанные операции: stream_socket_client, stream_socket_accept, stream_socket_recvfrom, stream_get_transports.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_socket_server

PHP 5+ · standard

stream_socket_client(string $address, int &$error_code = null, string &$error_message = null, ?float $timeout = null, int $flags = STREAM_CLIENT_CONNECT, ?resource $context = null): resource|false

Открыть клиентский stream к выбранному адресу и отдельно вести протокол обмена.

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

Сервису нужен клиентский канал к известному серверу. socket_client открывает транспортное соединение; HTTP-запрос, JSON и бизнес-протокол он сам не создаёт. Для обычного HTTP API часто удобнее готовый HTTP-клиент; ниже изучаем механизм на коротком локальном обмене.

Следующие примеры подключают приложенный tcp-lab.php: он создаёт две стороны настоящего TCP-соединения только на 127.0.0.1 с автоматически выбранным портом. Клиент подключается к нашему временному listener, accept получает вторую сторону, listener закрывается. Тесты не обращаются к интернету. lessonWriteAll / lessonReadExact обрабатывают частичные операции для маленьких сообщений; полный исходник fixture поставляется вместе с примером. Это лаборатория механизма, не готовый многопользовательский сервер.

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    lessonWriteAll($client, "PING\n");
    echo lessonReadExact($peer, 5);
} finally { fclose($client); fclose($peer); }

PING

<?php
declare(strict_types=1);

$warned = false;
set_error_handler(function ($level) use (&$warned) {
    if ($level === E_WARNING) { $warned = true; return true; }
    return false;
});
try {
    $client = stream_socket_client('lesson-unknown-transport://127.0.0.1:1', $code, $message, 0.1);
} finally { restore_error_handler(); }
var_dump($client === false, $warned);
echo "Пользователю: соединение недоступно\n";

bool(true)
bool(true)
Пользователю: соединение недоступно

По умолчанию соединение открывается blocking. timeout ограничивает connect при синхронной попытке, null берёт default_socket_timeout; чтение/запись на уже созданном сокете имеют другую настройку stream_set_timeout. С PHP 8.0 timeout и context nullable. Числовой IPv6 требует квадратных скобок. UDP «соединение» может успешно создаться даже при недоступном адресате: без рукопожатия это не проверка получателя. Unix-domain и некоторые виды connect timeout зависят от окружения.

Связанные операции: stream_socket_server, stream_set_timeout, stream_set_blocking, stream_select, stream_socket_enable_crypto.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_socket_client

PHP 5+ · standard

stream_socket_accept(resource $socket, ?float $timeout = null, string &$peer_name = null): resource|false

Принять одну входящую TCP-подобную связь и получить отдельный ресурс клиента.

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

Listener уже открыт, но у входящего клиента должен появиться отдельный ресурс. accept ждёт и возвращает именно принятую связь. Она живёт отдельно от listener: закрытие одного клиента не обязано прекращать приём остальных.

<?php
declare(strict_types=1);

$server = stream_socket_server('tcp://127.0.0.1:0', $code, $message);
$client = false; $peer = false;
try {
    $address = stream_socket_get_name($server, false);
    $client = stream_socket_client('tcp://' . $address, $code, $message, 1);
    $peer = stream_socket_accept($server, 1, $peerName);
    if ($peer === false) { throw new RuntimeException('Accept failed'); }
    var_dump($peerName === stream_socket_get_name($client, false));
} finally {
    if (is_resource($peer)) { fclose($peer); }
    if (is_resource($client)) { fclose($client); }
    if (is_resource($server)) { fclose($server); }
}

bool(true)

<?php
declare(strict_types=1);

$server = stream_socket_server('tcp://127.0.0.1:0', $code, $message);
if ($server === false) { throw new RuntimeException('No listener'); }
$warning = false;
set_error_handler(function ($level) use (&$warning) {
    if ($level === E_WARNING) { $warning = true; return true; }
    return false;
});
try { $peer = stream_socket_accept($server, 0.02); }
finally { restore_error_handler(); fclose($server); }
var_dump($peer === false, $warning);

bool(true)
bool(true)

Связанные операции: stream_socket_server, stream_socket_get_name, stream_socket_recvfrom.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_socket_accept

PHP 5+ · standard

stream_socket_get_name(resource $socket, bool $remote): string|false

Получить локальное или удалённое имя существующего socket stream.

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

У соединения две стороны. get_name(false) описывает локальный адрес данного ресурса, get_name(true) — противоположный. У client и accepted peer роли меняются местами; это помогает проверить свою лабораторию и не перепутать адрес прослушивания с адресом клиента.

Следующие примеры подключают приложенный tcp-lab.php: он создаёт две стороны настоящего TCP-соединения только на 127.0.0.1 с автоматически выбранным портом. Клиент подключается к нашему временному listener, accept получает вторую сторону, listener закрывается. Тесты не обращаются к интернету. lessonWriteAll / lessonReadExact обрабатывают частичные операции для маленьких сообщений; полный исходник fixture поставляется вместе с примером. Это лаборатория механизма, не готовый многопользовательский сервер.

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    $clientRemote = stream_socket_get_name($client, true);
    $serverLocal = stream_socket_get_name($peer, false);
    var_dump($clientRemote === $serverLocal);
} finally { fclose($client); fclose($peer); }

bool(true)

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client, $peer] = lessonTcpPair();
try {
    $clientLocal = stream_socket_get_name($client, false);
    $serverRemote = stream_socket_get_name($peer, true);
    var_dump($clientLocal === $serverRemote);
    echo str_starts_with($serverRemote, '127.0.0.1:') ? "Учебный локальный клиент\n" : "Иной адрес\n";
} finally { fclose($client); fclose($peer); }

bool(true)
Учебный локальный клиент

Связанные операции: stream_socket_client, stream_socket_accept, stream_get_meta_data.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_socket_get_name

PHP 5.1.0+ · standard

stream_socket_pair(int $domain, int $type, int $protocol): array|false

Создать два соединённых socket stream для локального двустороннего обмена.

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

Для обмена между двумя участниками иногда не нужен видимый listener. socket_pair создаёт сразу два соединённых сокетных ресурса. Они равноправны: данные, записанные в первый, читает второй, и наоборот. Типичное применение — IPC, но первый опыт можно провести в одном процессе без fork.

<?php
declare(strict_types=1);

$family = PHP_OS_FAMILY === 'Windows' ? STREAM_PF_INET : STREAM_PF_UNIX;
$pair = stream_socket_pair($family, STREAM_SOCK_STREAM, STREAM_IPPROTO_IP);
if ($pair === false) { throw new RuntimeException('Socket pair unavailable'); }
try {
    stream_set_timeout($pair[1], 1);
    if (fwrite($pair[0], 'tea') !== 3) { throw new RuntimeException('Short fixture write'); }
    echo fread($pair[1], 3), "\n";
} finally { fclose($pair[0]); fclose($pair[1]); }

tea

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
$family = PHP_OS_FAMILY === 'Windows' ? STREAM_PF_INET : STREAM_PF_UNIX;
$pair = stream_socket_pair($family, STREAM_SOCK_STREAM, STREAM_IPPROTO_IP);
if ($pair === false) { throw new RuntimeException('Socket pair unavailable'); }
try {
    stream_set_timeout($pair[0], 1); stream_set_timeout($pair[1], 1);
    lessonWriteAll($pair[0], 'PING');
    $request = lessonReadExact($pair[1], 4);
    lessonWriteAll($pair[1], $request === 'PING' ? 'PONG' : 'FAIL');
    echo lessonReadExact($pair[0], 4), "\n";
} finally { fclose($pair[0]); fclose($pair[1]); }

PONG

Связанные операции: stream_socket_client, stream_socket_shutdown, stream_select.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_socket_pair

PHP 5.2.1+ · standard

stream_socket_shutdown(resource $stream, int $mode): bool

Завершить выбранное направление full-duplex связи, отделяя это от закрытия ресурса.

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

Иногда команда завершила отправку тела, но ещё ждёт ответ по тому же соединению. Shutdown направления записи сообщает противоположной стороне EOF после переданных байтов, сохраняя возможность читать ответ. Это отличается от fclose, который закрывает ресурс целиком.

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client,$peer]=lessonTcpPair();
try {
    lessonWriteAll($client,'report');
    if(!stream_socket_shutdown($client,STREAM_SHUT_WR)){throw new RuntimeException('Half-close failed');}
    echo stream_get_contents($peer), "\n";
    lessonWriteAll($peer,'ACK');
    echo lessonReadExact($client,3), "\n";
} finally {fclose($client);fclose($peer);}

report
ACK

<?php
declare(strict_types=1);

require __DIR__ . '/tcp-lab.php';
[$client,$peer]=lessonTcpPair();
try {
    var_dump(stream_socket_shutdown($client,STREAM_SHUT_RDWR));
    var_dump(is_resource($client));
} finally {fclose($client);fclose($peer);}
var_dump(is_resource($client));

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

Связанные операции: stream_socket_client, stream_get_contents, stream_select.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_socket_shutdown

PHP 5+ · standard

stream_socket_recvfrom(resource $socket, int $length, int $flags = 0, ?string &$address = null): string|false

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

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

UDP-обработчик получает отдельную датаграмму и адрес отправителя, чтобы ответить ему. recvfrom читает из сокета напрямую; это не то же самое, что чтение уже накопленного PHP-буфера. Максимум length должен соответствовать вашему протоколу, иначе хвост datagram может потеряться.

udp-lab.php создаёт два настоящих UDP-сокета только на 127.0.0.1, каждый на автоматически выбранном порту. Отправка выполняется локально; перед recvfrom helper ждёт read-ready через stream_select с лимитом 1 секунда. Это маленькие учебные datagrams, не проверка надёжности произвольной сети.

<?php
declare(strict_types=1);

require __DIR__ . '/udp-lab.php';
[$sender,$receiver,$address]=lessonUdpPair();
try {
    if(stream_socket_sendto($sender,'tea',0,$address)!==3){throw new RuntimeException('Send failed');}
    lessonWaitRead($receiver);
    $data=stream_socket_recvfrom($receiver,64,0,$from);
    echo $data, "\n";
    var_dump($from===stream_socket_get_name($sender,false));
} finally {fclose($sender);fclose($receiver);}

tea
bool(true)

<?php
declare(strict_types=1);

require __DIR__ . '/udp-lab.php';
[$sender,$receiver,$address]=lessonUdpPair();
try {
    stream_socket_sendto($sender,'tea',0,$address);
    lessonWaitRead($receiver);
    echo stream_socket_recvfrom($receiver,64,STREAM_PEEK), "\n";
    echo stream_socket_recvfrom($receiver,64), "\n";
} finally {fclose($sender);fclose($receiver);}

tea
tea

<?php
declare(strict_types=1);

require __DIR__ . '/udp-lab.php';
[$sender,$receiver,$address]=lessonUdpPair();
try {
    stream_socket_sendto($sender,'abcdef',0,$address);
    lessonWaitRead($receiver);
    $data=stream_socket_recvfrom($receiver,3);
    if($data===false || strlen($data)!==6){echo "Целое сообщение не получено\n";}
    $read=[$receiver];$write=null;$except=null;
    echo stream_select($read,$write,$except,0), "\n";
} finally {fclose($sender);fclose($receiver);}

Целое сообщение не получено
0

Связанные операции: stream_socket_sendto, stream_select, stream_set_timeout.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_socket_recvfrom

PHP 5+ · standard

stream_socket_sendto(resource $socket, string $data, int $flags = 0, string $address = ""): int|false

Передать сообщение выбранному socket-адресату и проверить число отправленных байтов.

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

Для UDP-ответа нужен явный адрес, полученный при приёме. sendto передаёт bytes в выбранный сокетный транспорт. Число записанных байтов подтверждает работу локальной операции отправки, но не получение сообщения удалённым приложением.

udp-lab.php создаёт два настоящих UDP-сокета только на 127.0.0.1, каждый на автоматически выбранном порту. Отправка выполняется локально; перед recvfrom helper ждёт read-ready через stream_select с лимитом 1 секунда. Это маленькие учебные datagrams, не проверка надёжности произвольной сети.

<?php
declare(strict_types=1);

require __DIR__ . '/udp-lab.php';
[$sender,$receiver,$address]=lessonUdpPair();
try {
    $sent=stream_socket_sendto($sender,'tea',0,$address);
    if($sent===false || $sent!==3){throw new RuntimeException('Message not sent completely');}
    lessonWaitRead($receiver);
    echo $sent, '/', stream_socket_recvfrom($receiver,64), "\n";
} finally {fclose($sender);fclose($receiver);}

3/tea

<?php
declare(strict_types=1);

require __DIR__ . '/udp-lab.php';
[$sender,$receiver,$address]=lessonUdpPair();
try {
    stream_socket_sendto($sender,'PING',0,$address);
    lessonWaitRead($receiver);
    $request=stream_socket_recvfrom($receiver,64,0,$from);
    $reply=$request==='PING' ? 'PONG' : 'FAIL';
    if(stream_socket_sendto($receiver,$reply,0,$from)!==4){throw new RuntimeException('Reply failed');}
    lessonWaitRead($sender);
    echo stream_socket_recvfrom($sender,64), "\n";
} finally {fclose($sender);fclose($receiver);}

PONG

Пустой address использует адрес, выбранный при создании соединённого socket stream. Альтернативный адрес задаётся числовым IPv4:port либо [IPv6]:port; не подставляйте произвольное имя хоста в надежде на DNS-разрешение этого параметра. flags поддерживает STREAM_OOB, если транспорт это умеет; STREAM_PEEK здесь не разрешение на «предварительную отправку». TCP тоже может использовать sendto, но протокольные границы сообщений и частичные передачи от этого не исчезают.

Связанные операции: stream_socket_recvfrom, stream_socket_client, stream_socket_get_name.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_socket_sendto

PHP 5.1.0+ · standard

stream_socket_enable_crypto(resource $stream, bool $enable, ?int $crypto_method = null, ?resource $session_stream = null): int|bool

Согласовать TLS на уже открытом socket stream, различая успех, отказ и продолжение non-blocking handshake.

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

Обычный TCP передаёт байты без защиты транспортного канала. Протокол может требовать TLS сразу после connect или согласованный переход STARTTLS. enable_crypto запускает TLS на уже существующем socket stream. Проверка сертификата, имени сервера и согласованного протокола нужна до передачи секретов; просто наличие шифрования ещё не подтверждает личность другой стороны.

Здесь приложены tcp-lab.php, tls-lab.php и tls.cnf. Лаборатория создаёт одноразовый ключ/сертификат только для localhost, сохраняет их во временную папку примера и настраивает клиенту cafile и peer_name=localhost. verify_peer и verify_peer_name включены. Обе стороны соединяются только через 127.0.0.1. Helpers последовательно продвигают два non-blocking handshake с общим пределом ожидания, затем возвращают blocking для короткого сообщения. Это контролируемая лаборатория, не общий TLS event loop для любой нагрузки.

<?php
declare(strict_types=1);

require __DIR__ . '/tls-lab.php';
[$client,$peer]=lessonTlsSockets();
try {
    $state=stream_socket_enable_crypto($client,true,
        STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT|STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT);
    if($state===false){throw new RuntimeException('TLS failed');}
    echo $state===0 ? "Нужно продолжить handshake\n" : "TLS уже установлен\n";
    $completed=lessonTlsHandshake($client,$peer);
    var_dump($completed['client'],$completed['server']);
} finally {fclose($client);fclose($peer);}

Нужно продолжить handshake
bool(true)
bool(true)

<?php
declare(strict_types=1);

require __DIR__ . '/tls-lab.php';
[$client,$peer]=lessonTlsSockets();
try {
    lessonTlsHandshake($client,$peer);
    lessonWriteAll($client,'receipt');
    echo lessonReadExact($peer,7), "\n";
    $crypto=stream_get_meta_data($client)['crypto'];
    var_dump(in_array($crypto['protocol'],['TLSv1.2','TLSv1.3'],true));
    var_dump(isset($crypto['cipher_name'],$crypto['cipher_bits']));
} finally {fclose($client);fclose($peer);}

receipt
bool(true)
bool(true)

<?php
declare(strict_types=1);

$stream=fopen('php://memory','w+');
$warned=false;
set_error_handler(function($level) use (&$warned){
    if($level===E_WARNING){$warned=true;return true;}return false;
});
try {$result=stream_socket_enable_crypto($stream,true,STREAM_CRYPTO_METHOD_TLS_CLIENT);}
finally {restore_error_handler();fclose($stream);}
var_dump($result,$warned);

bool(false)
bool(true)

session_stream позволяет использовать параметры TLS-сессии из другого совместимого потока; он не переносит HTTP-аутентификацию, историю команд или гарантию resumption. Сервер/библиотека могут не возобновить сессию. Nullable session_stream поддерживается с PHP 8.0. Настройки сертификата относятся к SSL context, а не к аргументу session_stream как «любой уже залогиненный клиент».

enable=false отключает защиту, если это поддержано состоянием потока. Это не безопасный «следующий шаг после логина»: исторический пример мануала с plaintext после пароля не переносится в новый сервис. Менять режим можно лишь по явно согласованному протоколу. TLS не заменяет проверку полномочий, корректность API-команды или безопасность кода приложения. Для обычного HTTPS удобнее wrapper/HTTP-клиент, который организует жизненный цикл; низкоуровневый API нужен, когда вы действительно ведёте такой протокол.

Связанные операции: stream_socket_client, stream_context_create, stream_select, stream_get_meta_data.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_socket_enable_crypto

PHP 4.3.0+ · standard

stream_filter_append(resource $stream, string $filter_name, int $mode = 0, mixed $params = null): resource|false

Добавить преобразование в конец цепочки чтения или записи открытого потока.

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

Нужно преобразовать выгрузку при записи, не собирая второй полный файл в переменной. Сначала откройте поток, затем прикрепите обработчик к направлению WRITE. Он меняет байты между fwrite и хранилищем. READ действует между хранилищем и читающим кодом. Обработчик не делает весь файл «изменённым навсегда»: это отдельная стадия конкретного открытого потока.

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    $filter = stream_filter_append($stream, 'string.toupper', STREAM_FILTER_WRITE);
    if ($filter === false) { throw new RuntimeException('Filter unavailable'); }
    fwrite($stream, "tea\n");
    stream_filter_remove($filter);
    rewind($stream);
    echo stream_get_contents($stream);
} finally { fclose($stream); }

TEA

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
$stream = fopen('php://temp', 'w+');
try {
    stream_filter_append($stream, 'string.toupper', STREAM_FILTER_WRITE);
    $last = stream_filter_append($stream, 'convert.base64-encode', STREAM_FILTER_WRITE,
        ['line-length' => 0]);
    fwrite($stream, 'tea');
    stream_filter_remove($last);
    rewind($stream);
    echo stream_get_contents($stream), "\n";
} finally { fclose($stream); }

VEVB

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

Для режима r+/w+ значение mode по умолчанию может создать одновременно READ и WRITE экземпляры. Это два состояния фильтра, а один возвращённый handle не даёт отдельно управлять обоими. Если нужны оба, вызовите функцию дважды с явными направлениями и сохраните оба ресурса. STREAM_FILTER_ALL = READ | WRITE; params передаются конкретному фильтру и имеют его собственный контракт.

Связанные операции: stream_filter_remove, stream_filter_register, stream_filter_prepend, stream_get_filters.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_filter_append

PHP 4.3.0+ · standard

stream_filter_prepend(resource $stream, string $filter_name, int $mode = 0, mixed $params = null): resource|false

Добавить преобразование в начало цепочки чтения или записи открытого потока.

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

Нужно преобразовать выгрузку при записи, не собирая второй полный файл в переменной. Сначала откройте поток, затем прикрепите обработчик к направлению WRITE. Он меняет байты между fwrite и хранилищем. READ действует между хранилищем и читающим кодом. Обработчик не делает весь файл «изменённым навсегда»: это отдельная стадия конкретного открытого потока.

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    $filter = stream_filter_prepend($stream, 'string.toupper', STREAM_FILTER_WRITE);
    if ($filter === false) { throw new RuntimeException('Filter unavailable'); }
    fwrite($stream, "tea\n");
    stream_filter_remove($filter);
    rewind($stream);
    echo stream_get_contents($stream);
} finally { fclose($stream); }

TEA

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    $base64 = stream_filter_append($stream, 'convert.base64-encode', STREAM_FILTER_WRITE);
    stream_filter_prepend($stream, 'string.toupper', STREAM_FILTER_WRITE);
    fwrite($stream, 'tea');
    stream_filter_remove($base64);
    rewind($stream);
    echo stream_get_contents($stream), "\n";
} finally { fclose($stream); }

VEVB

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

Для режима r+/w+ значение mode по умолчанию может создать одновременно READ и WRITE экземпляры. Это два состояния фильтра, а один возвращённый handle не даёт отдельно управлять обоими. Если нужны оба, вызовите функцию дважды с явными направлениями и сохраните оба ресурса. STREAM_FILTER_ALL = READ | WRITE; params передаются конкретному фильтру и имеют его собственный контракт.

Связанные операции: stream_filter_remove, stream_filter_register, stream_filter_append, stream_get_filters.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_filter_prepend

PHP 5+ · standard

stream_filter_register(string $filter_name, string $class): bool

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

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

Регистрация связывает имя с вашим классом; она ещё не открывает поток и не преобразует данные. Класс наследуется от php_user_filter. Для инициализации PHP вызывает onCreate, а не пользовательский __construct. Самостоятельный вызов new не заменяет прикрепление фильтра к потоку.

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
var_dump(stream_filter_register('lesson.copy', LessonCopyFilter::class));
echo lessonFilter('lesson.copy', ['tea', '+', 'milk']), "\n";

bool(true)
tea+milk

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class NamedCase extends php_user_filter {
    public function onCreate(): bool {
        return in_array($this->filtername, ['lessoncase.upper', 'lessoncase.lower'], true);
    }
    public function filter($in, $out, &$consumed, bool $closing): int {
        while ($bucket = stream_bucket_make_writeable($in)) {
            $consumed += strlen($bucket->data);
            $bucket->data = $this->filtername === 'lessoncase.upper'
                ? strtoupper($bucket->data) : strtolower($bucket->data);
            stream_bucket_append($out, $bucket);
        }
        return PSFS_PASS_ON;
    }
}
stream_filter_register('lessoncase.*', NamedCase::class);
echo lessonFilter('lessoncase.upper', ['Tea']), "\n";
echo lessonFilter('lessoncase.lower', ['Tea']), "\n";
var_dump(stream_filter_register('lessoncase.*', NamedCase::class));

TEA
tea
bool(false)

Нет парной функции stream_filter_unregister. Реестр принадлежит текущему выполнению PHP; в долгоживущем worker выбирайте стабильные имена, не регистрируйте новый случайный класс на каждое сообщение. Регистрация сама по себе не доказывает, что класс удастся создать: ошибки класса/наследования/методов могут проявиться при прикреплении. Сигнатуры должны соответствовать php_user_filter, consumed обязательно по ссылке.

Связанные операции: php_user_filter::onCreate, php_user_filter::filter, stream_filter_append, stream_get_filters.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_filter_register

PHP 5.1.0+ · standard

stream_filter_remove(resource $stream_filter): bool

Завершить накопленные данные и отсоединить конкретный фильтр, сохранив поток открытым.

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

Handle фильтра — отдельный ресурс, полученный append/prepend. Удаление сначала просит фильтр завершить накопленные данные и передать их дальше по цепочке. Оно не отменяет уже записанные байты и не закрывает сам поток.

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    $filter = stream_filter_append($stream, 'string.toupper', STREAM_FILTER_WRITE);
    fwrite($stream, 'tea');
    var_dump(stream_filter_remove($filter));
    fwrite($stream, '+milk');
    rewind($stream);
    echo stream_get_contents($stream), "\n";
} finally { fclose($stream); }

bool(true)
TEA+milk

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    $filter = stream_filter_append($stream, 'convert.base64-encode', STREAM_FILTER_WRITE);
    fwrite($stream, 'a');
    var_dump(stream_filter_remove($filter));
    rewind($stream);
    echo stream_get_contents($stream), "\n";
    var_dump(is_resource($filter));
} finally { fclose($stream); }

bool(true)
YQ==
bool(false)

Связанные операции: stream_filter_append, php_user_filter::onClose, php_user_filter::filter.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_filter_remove

PHP 5+ · standard

stream_get_filters(): array

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

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

Перед использованием необязательного преобразователя проверьте реестр установленной сборки. Список относится к доступным именам, а не к фильтрам уже открытого потока. Некоторые записи — семейства со звёздочкой; convert.* не перечисляет каждую возможность отдельной строкой.

<?php
declare(strict_types=1);

if (!in_array('string.toupper', stream_get_filters(), true)) {
    throw new RuntimeException('Нет преобразования ASCII-артикулов');
}
$stream = fopen('php://memory', 'w+b');
try {
    $filter = stream_filter_append($stream, 'string.toupper', STREAM_FILTER_WRITE);
    if ($filter === false) { throw new RuntimeException('Не подключить фильтр'); }
    fwrite($stream, 'tea-104');
    stream_filter_remove($filter);
    rewind($stream); echo stream_get_contents($stream), "\n";
} finally { fclose($stream); }

TEA-104

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
var_dump(in_array('lesson.export', stream_get_filters(), true));
stream_filter_register('lesson.export', LessonCopyFilter::class);
var_dump(in_array('lesson.export', stream_get_filters(), true));
echo lessonFilter('lesson.export', ['order=12']), "\n";

bool(false)
bool(true)
order=12

Связанные операции: stream_filter_register, stream_filter_append, stream_get_wrappers, stream_get_transports.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_get_filters

PHP 5+; StreamBucket PHP 8.4+ · standard

stream_bucket_append(resource $brigade, StreamBucket $bucket): void

Поместить обработанный блок в конец выходной очереди фильтра.

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

Внутри filter вход $in и выход $out — не строки, а ресурсы очередей блоков (bucket brigades). make_writeable извлекает очередной блок из входа; $bucket->data даёт его строку байтов. append/prepend помещает блок в выход. Таким образом, «извлечь» ещё не значит «передать»: забытый выходной блок означает потерянные данные. Размер блока не обещает совпадения со строкой CSV, символом UTF-8 или вызовом fwrite.

Первое действие — перенести блок без изменения. consumed увеличиваем на исходную длину до любой замены. Очередь хранит порядок; append ставит очередной результат после уже подготовленных выходных блоков.

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class PassBytes extends php_user_filter {
    public function filter($in, $out, &$consumed, bool $closing): int {
        while ($bucket = stream_bucket_make_writeable($in)) {
            $consumed += strlen($bucket->data);
            stream_bucket_append($out, $bucket);
        }
        return PSFS_PASS_ON;
    }
}
stream_filter_register('lesson.pass', PassBytes::class);
echo lessonFilter('lesson.pass', ['tea', '+milk']), "\n";

tea+milk

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class EscapeComma extends php_user_filter {
    public function filter($in, $out, &$consumed, bool $closing): int {
        while ($bucket = stream_bucket_make_writeable($in)) {
            $consumed += strlen($bucket->data);
            $bucket->data = str_replace(',', '[comma]', $bucket->data);
            stream_bucket_append($out, $bucket);
        }
        return PSFS_PASS_ON;
    }
}
stream_filter_register('lesson.comma', EscapeComma::class);
echo lessonFilter('lesson.comma', ['tea,milk']), "\n";

tea[comma]milk

Связанные операции: stream_bucket_make_writeable, stream_bucket_prepend, stream_bucket_new, php_user_filter::filter.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_bucket_append

PHP 5+; StreamBucket PHP 8.4+ · standard

stream_bucket_prepend(resource $brigade, StreamBucket $bucket): void

Вставить блок в начало текущей очереди, не меняя уже отправленную часть потока.

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

Внутри filter вход $in и выход $out — не строки, а ресурсы очередей блоков (bucket brigades). make_writeable извлекает очередной блок из входа; $bucket->data даёт его строку байтов. append/prepend помещает блок в выход. Таким образом, «извлечь» ещё не значит «передать»: забытый выходной блок означает потерянные данные. Размер блока не обещает совпадения со строкой CSV, символом UTF-8 или вызовом fwrite.

prepend нужен, когда новый блок должен оказаться перед тем, что уже добавлено в этой выходной очереди. Он не перемещает назад байты, уже отправленные предыдущими вызовами filter. Поэтому простой prepend каждого блока не разворачивает весь файл задом наперёд.

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class PrefixOnce extends php_user_filter {
    private bool $started = false;
    public function filter($in, $out, &$consumed, bool $closing): int {
        while ($bucket = stream_bucket_make_writeable($in)) {
            $consumed += strlen($bucket->data);
            stream_bucket_append($out, $bucket);
            if (!$this->started) {
                stream_bucket_prepend($out, stream_bucket_new($this->stream, 'items:'));
                $this->started = true;
            }
        }
        return PSFS_PASS_ON;
    }
}
stream_filter_register('lesson.prefix', PrefixOnce::class);
echo lessonFilter('lesson.prefix', ['tea', ',milk']), "\n";

items:tea,milk

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class MarkChunk extends php_user_filter {
    public function filter($in, $out, &$consumed, bool $closing): int {
        while ($bucket = stream_bucket_make_writeable($in)) {
            $consumed += strlen($bucket->data);
            stream_bucket_append($out, stream_bucket_new($this->stream, $bucket->data . ']'));
            stream_bucket_prepend($out, stream_bucket_new($this->stream, '['));
        }
        return PSFS_PASS_ON;
    }
}
stream_filter_register('lesson.chunk', MarkChunk::class);
echo lessonFilter('lesson.chunk', ['tea']), "\n";

[tea]

Допустимо возвращать bucket в начало входной очереди для специального алгоритма, но без изменения условия цикл тут же извлечёт тот же блок снова. Это легко создаёт бесконечную обработку. Начинайте с одностороннего движения $in → $out; не увеличивайте consumed второй раз для одних и тех же принятых байтов.

Связанные операции: stream_bucket_append, stream_bucket_new, php_user_filter::filter.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_bucket_prepend

PHP 5+; StreamBucket PHP 8.4+ · standard

stream_bucket_make_writeable(resource $brigade): ?StreamBucket

Извлечь следующий входной блок для изменения либо получить null, когда очередь пуста.

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

Внутри filter вход $in и выход $out — не строки, а ресурсы очередей блоков (bucket brigades). make_writeable извлекает очередной блок из входа; $bucket->data даёт его строку байтов. append/prepend помещает блок в выход. Таким образом, «извлечь» ещё не значит «передать»: забытый выходной блок означает потерянные данные. Размер блока не обещает совпадения со строкой CSV, символом UTF-8 или вызовом fwrite.

Имя функции написано writeable именно так. Она забирает следующий доступный bucket из brigade и даёт обёртку для изменения. null означает, что сейчас брать нечего; это не отдельный пустой bucket. Цикл должен передать или осознанно задержать каждый извлечённый вход.

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class UpperBytes extends php_user_filter {
    public function filter($in, $out, &$consumed, bool $closing): int {
        while (($bucket = stream_bucket_make_writeable($in)) !== null) {
            $consumed += strlen($bucket->data);
            $bucket->data = strtoupper($bucket->data);
            stream_bucket_append($out, $bucket);
        }
        return PSFS_PASS_ON;
    }
}
stream_filter_register('lesson.upper', UpperBytes::class);
echo lessonFilter('lesson.upper', ['tea']), "\n";

TEA

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class RemoveZeroByte extends php_user_filter {
    public function filter($in, $out, &$consumed, bool $closing): int {
        while ($bucket = stream_bucket_make_writeable($in)) {
            $consumed += strlen($bucket->data);
            $bucket->data = str_replace("\0", '', $bucket->data);
            stream_bucket_append($out, $bucket);
        }
        return PSFS_PASS_ON;
    }
}
stream_filter_register('lesson.nozero', RemoveZeroByte::class);
echo lessonFilter('lesson.nozero', ["te\0a"]), "\n";

tea

Связанные операции: stream_bucket_append, stream_bucket_new, php_user_filter::filter.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_bucket_make_writeable

PHP 5+; StreamBucket PHP 8.4+ · standard

stream_bucket_new(resource $stream, string $buffer): StreamBucket

Создать отдельный блок байтов для последующей передачи из пользовательского фильтра.

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

Новый блок нужен, когда результат не совпадает с одним входным bucket: например, фильтр накопил части строки или должен выпустить завершающий маркер. stream — ресурс исходного потока, buffer — новые байты. Само создание ничего не записывает; bucket ещё надо поставить в $out.

<?php
declare(strict_types=1);

$stream = fopen('php://temp', 'w+');
try {
    $bucket = stream_bucket_new($stream, 'tea');
    echo get_class($bucket), ':', $bucket->data, ':', $bucket->dataLength, "\n";
    echo fstat($stream)['size'], "\n";
} finally { fclose($stream); }

StreamBucket:tea:3
0

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
stream_filter_register('lesson.lines', LessonLineFilter::class);
echo lessonFilter('lesson.lines', ['te', "a\nmi", 'lk']), "\n";

TEA
MILK

Связанные операции: stream_bucket_append, stream_bucket_prepend, php_user_filter::filter.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_bucket_new

PHP 5+ · standard

php_user_filter::filter(resource $in, resource $out, int &$consumed, bool $closing): int

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

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

Внешний код вызывает fwrite или fread, а PHP внутри вызывает ваш filter. Параметры $in/$out — очереди блоков. &$consumed передан по ссылке: прибавляя к нему, вы сообщаете движку, сколько входных байтов приняли. $closing говорит, что это завершающий проход. Не считайте число вызовов: PHP выбирает разбиение данных самостоятельно.

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class SpacesToDots extends php_user_filter {
    public function filter($in, $out, &$consumed, bool $closing): int {
        while ($bucket = stream_bucket_make_writeable($in)) {
            $consumed += strlen($bucket->data);
            $bucket->data = str_replace(' ', '.', $bucket->data);
            stream_bucket_append($out, $bucket);
        }
        return PSFS_PASS_ON;
    }
}
stream_filter_register('lesson.dots', SpacesToDots::class);
echo lessonFilter('lesson.dots', ['tea ', 'and milk']), "\n";

tea.and.milk

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
stream_filter_register('lesson.lines', LessonLineFilter::class);
$whole = lessonFilter('lesson.lines', ["tea\nmilk"]);
$split = lessonFilter('lesson.lines', ['t', 'e', "a\nm", 'ilk']);
echo $whole, "\n";
var_dump($whole === $split);

TEA
MILK
bool(true)

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
stream_filter_register('lesson.lines', LessonLineFilter::class);
$stream = fopen('php://temp', 'w+');
$warning = false;
set_error_handler(function ($level) use (&$warning) {
    if ($level === E_WARNING) { $warning = true; return true; }
    return false;
});
try {
    stream_filter_append($stream, 'lesson.lines', STREAM_FILTER_WRITE);
    $written = fwrite($stream, str_repeat('x', 1025));
    var_dump($written === false);
} finally { fclose($stream); restore_error_handler(); }

bool(true)

Во время closing вход может быть пуст, а ваш собственный буфер — нет. filter должен корректно завершить формат или отказать. onClose предназначен для освобождения ресурсов; выдавать хвост данных нужно здесь, где есть $out. Не логируйте сырые buckets, если они содержат токены/личные данные. Маскирование по одному bucket небезопасно: секрет может быть разрезан между ними.

Связанные операции: stream_bucket_make_writeable, stream_bucket_append, stream_bucket_new, php_user_filter::onCreate, php_user_filter::onClose.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: php_user_filter::filter

PHP 5+ · standard

php_user_filter::onCreate(): bool

Проверить параметры и подготовить состояние экземпляра до обработки данных.

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

Один зарегистрированный класс может создавать отдельные экземпляры с разными настройками. onCreate проверяет params и готовит свойства до первого блока. __construct при создании фильтра движком не вызывается. Не открывайте сеть ради простой проверки параметра; отказ надо вернуть до обработки пользовательских данных.

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class PreparedCopy extends LessonCopyFilter {
    public static array $events = [];
    public function __construct() { self::$events[] = 'constructor'; }
    public function onCreate(): bool {
        self::$events[] = 'create:' . $this->filtername;
        return true;
    }
}
stream_filter_register('lesson.prepared', PreparedCopy::class);
echo lessonFilter('lesson.prepared', ['tea']), "\n";
echo implode(',', PreparedCopy::$events), "\n";

tea
create:lesson.prepared

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class CheckedCopy extends LessonCopyFilter {
    public function onCreate(): bool {
        return is_array($this->params) && ($this->params['format'] ?? null) === 'plain';
    }
}
stream_filter_register('lesson.checked', CheckedCopy::class);
echo lessonFilter('lesson.checked', ['tea'], ['format' => 'plain']), "\n";
$stream = fopen('php://temp', 'w+');
set_error_handler(fn($level) => $level === E_WARNING);
try { var_dump(stream_filter_append($stream, 'lesson.checked', STREAM_FILTER_WRITE, ['format' => 'unknown'])); }
finally { restore_error_handler(); fclose($stream); }

tea
bool(false)

filtername уже содержит конкретное имя, params — переданную настройку. На stream нельзя полагаться при onCreate: он может быть доступен только во время filter с closing=false. Не делайте здесь fstat($this->stream) как универсальный контракт. Храните отдельные ресурсы для дальнейшей обработки в объявленных свойствах; очистите их в onClose и при частично неудачной инициализации.

Связанные операции: stream_filter_register, stream_filter_append, php_user_filter::filter, php_user_filter::onClose.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: php_user_filter::onCreate

PHP 5+ · standard

php_user_filter::onClose(): void

Освободить ресурсы экземпляра после завершения фильтра, не формируя новые выходные данные.

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

Обработчик может иметь счётчики, временный ресурс или собственный буфер. onClose — финальная уборка после завершения обработки. Это не место для возврата строк в поток и не гарантия фиксации бизнес-операции: аварийное завершение процесса может оборвать обычный жизненный цикл.

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class ClosingCopy extends LessonCopyFilter {
    public static int $closed = 0;
    public function onClose(): void { self::$closed++; }
}
stream_filter_register('lesson.closing', ClosingCopy::class);
echo lessonFilter('lesson.closing', ['tea']), "\n";
echo ClosingCopy::$closed, "\n";

tea
1

<?php
declare(strict_types=1);

require __DIR__ . '/filter-lab.php';
class AuditedCopy extends LessonCopyFilter {
    private $audit = null;
    private int $bytes = 0;
    public function onCreate(): bool {
        $this->audit = fopen(__DIR__ . '/filter-audit.txt', 'wb');
        return $this->audit !== false;
    }
    public function filter($in, $out, &$consumed, bool $closing): int {
        $before = $consumed;
        $status = parent::filter($in, $out, $consumed, $closing);
        $this->bytes += $consumed - $before;
        return $status;
    }
    public function onClose(): void {
        try {
            $line = 'Принято байтов: ' . $this->bytes . "\n";
            if (fwrite($this->audit, $line) !== strlen($line)) {
                throw new RuntimeException('Журнал фильтра записан не полностью');
            }
        } finally { fclose($this->audit); }
    }
}
stream_filter_register('lesson.audit', AuditedCopy::class);
echo lessonFilter('lesson.audit', ['104:', "ready\n"]);
echo file_get_contents(__DIR__ . '/filter-audit.txt');

104:ready
Принято байтов: 10

Параметров нет, возвращаемое значение игнорируется; современная сигнатура void. Последний вывод создавайте в filter($closing=true), где PHP ещё дал выходную очередь. Не вызывайте вручную onClose, пока фильтр живёт в цепочке: повторная уборка может испортить состояние. Ссылки на ресурсы проверяйте, а исключения из cleanup не должны скрывать первоначальную ошибку приложения.

Связанные операции: php_user_filter::filter, php_user_filter::onCreate, stream_filter_remove.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: php_user_filter::onClose

PHP 4.3.2+ · standard

stream_wrapper_register(string $protocol, string $class, int $flags = 0): bool

Связать собственную схему URL с классом-обработчиком потоков.

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

Нужно дать существующему коду привычный fopen, хотя данные находятся за вашей абстракцией. Регистрация связывает схему lesson с классом, и fopen("lesson://store/tea.txt", "rb") передаёт открытие его stream_open. Это не регистрация фильтра: wrapper предоставляет сам источник, а фильтр преобразует байты источника.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
if (!stream_wrapper_register('lesson', LessonFileBridge::class)) { throw new RuntimeException('Не зарегистрировать схему'); }
echo file_get_contents('lesson://store/pickup.txt');

Заказ104: выдать две дрели

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
stream_wrapper_register('lesson', LessonFileBridge::class);
$warning = false;
set_error_handler(function ($level) use (&$warning) {
    if ($level === E_WARNING) { $warning = true; return true; }
    return false;
});
try { var_dump(stream_wrapper_register('lesson', LessonFileBridge::class), $warning); }
finally { restore_error_handler(); stream_wrapper_unregister('lesson'); }

bool(false)
bool(true)

protocol содержит только латинские буквы/цифры, точку, плюс и дефис; URL для этой системы должен использовать ://. flags=0 обозначает локальную схему, STREAM_IS_URL — URL-протокол с соответствующими ограничениями allow_url_fopen/allow_url_include. Флаг не проверяет адреса за вас: класс обязан ограничивать пути, полномочия и допустимые операции. Локальная маркировка не делает источник безопасным.

Имя класса должно разрешаться при регистрации; отсутствие класса может вызвать TypeError в современной PHP, некорректное имя/занятое имя — warning и false. У класса публично объявляют $context, чтобы PHP мог передать ресурс контекста без динамического свойства. Методы реализуют именно поддерживаемые операции: наличие stream_open не обещает работоспособности mkdir, stat и directory iteration.

Связанные операции: stream_wrapper_unregister, stream_wrapper_restore, stream_get_wrappers, streamWrapper::stream_open.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_wrapper_register

PHP 4.3.0+; alias · standard

stream_register_wrapper(string $protocol, string $class, int $flags = 0): bool

Связать собственную схему URL с классом-обработчиком потоков.

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

Нужно дать существующему коду привычный fopen, хотя данные находятся за вашей абстракцией. Регистрация связывает схему lesson с классом, и fopen("lesson://store/tea.txt", "rb") передаёт открытие его stream_open. Это не регистрация фильтра: wrapper предоставляет сам источник, а фильтр преобразует байты источника.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
if (!stream_register_wrapper('lesson', LessonFileBridge::class)) { throw new RuntimeException('Не зарегистрировать схему'); }
echo file_get_contents('lesson://store/pickup.txt');

Заказ104: выдать две дрели

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
stream_register_wrapper('lesson', LessonFileBridge::class);
$warning = false;
set_error_handler(function ($level) use (&$warning) {
    if ($level === E_WARNING) { $warning = true; return true; }
    return false;
});
try { var_dump(stream_register_wrapper('lesson', LessonFileBridge::class), $warning); }
finally { restore_error_handler(); stream_wrapper_unregister('lesson'); }

bool(false)
bool(true)

protocol содержит только латинские буквы/цифры, точку, плюс и дефис; URL для этой системы должен использовать ://. flags=0 обозначает локальную схему, STREAM_IS_URL — URL-протокол с соответствующими ограничениями allow_url_fopen/allow_url_include. Флаг не проверяет адреса за вас: класс обязан ограничивать пути, полномочия и допустимые операции. Локальная маркировка не делает источник безопасным.

Имя класса должно разрешаться при регистрации; отсутствие класса может вызвать TypeError в современной PHP, некорректное имя/занятое имя — warning и false. У класса публично объявляют $context, чтобы PHP мог передать ресурс контекста без динамического свойства. Методы реализуют именно поддерживаемые операции: наличие stream_open не обещает работоспособности mkdir, stat и directory iteration.

Связанные операции: stream_wrapper_unregister, stream_wrapper_restore, stream_get_wrappers, streamWrapper::stream_open.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_register_wrapper

PHP 5.1.0+ · standard

stream_wrapper_unregister(string $protocol): bool

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

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

Отмена регистрации убирает имя из реестра будущих открытий. Уже открытый поток продолжает владеть своим экземпляром и ресурсом. Изменение общего реестра — существенный эффект: используйте для собственной схемы в лаборатории или строго контролируемого жизненного цикла приложения, не как незаметный побочный эффект библиотечной функции.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php'; lessonRegister();
var_dump(in_array('lesson', stream_get_wrappers(), true));
var_dump(stream_wrapper_unregister('lesson'));
var_dump(in_array('lesson', stream_get_wrappers(), true));

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

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php'; lessonRegister();
$stream = fopen('lesson://store/tea.txt', 'rb');
stream_wrapper_unregister('lesson');
try { echo stream_get_contents($stream); }
finally { fclose($stream); }

tea
milk

Связанные операции: stream_wrapper_register, stream_wrapper_restore, stream_get_wrappers.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_wrapper_unregister

PHP 5.1.0+ · standard

stream_wrapper_restore(string $protocol): bool

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

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

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

<?php
declare(strict_types=1);

var_dump(stream_wrapper_unregister('data'));
try { var_dump(in_array('data', stream_get_wrappers(), true)); }
finally { var_dump(stream_wrapper_restore('data')); }
echo file_get_contents('data://text/plain,tea'), "\n";

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

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php'; lessonRegister();
stream_wrapper_unregister('lesson');
set_error_handler(fn($level) => $level === E_WARNING);
try { var_dump(stream_wrapper_restore('lesson')); }
finally { restore_error_handler(); }
var_dump(stream_wrapper_register('lesson', LessonFileBridge::class));
stream_wrapper_unregister('lesson');

bool(false)
bool(true)

Связанные операции: stream_wrapper_unregister, stream_wrapper_register, stream_get_wrappers.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: stream_wrapper_restore

PHP 4.3.2+ · standard

streamWrapper::stream_open(string $path, string $mode, int $options, ?string &$opened_path): bool

Подготовить экземпляр wrapper для конкретного адреса и режима открытия.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

Обычный вызывающий код знает адрес и режим, но не знает устройство источника. stream_open должен проверить их, открыть внутренний ресурс и сохранить его в свойстве объекта. Возвращаемое true означает «экземпляр готов»; строку содержимого этот callback не возвращает.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        try { echo stream_get_contents($stream); }
        finally { fclose($stream); }
        var_dump(in_array('open', LessonFileBridge::$events, true));

tea
milk
bool(true)

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        set_error_handler(fn($level) => in_array($level, [E_WARNING, E_USER_WARNING], true));
        try { $stream = fopen('lesson://other/pickup.txt', 'rb'); }
        finally { restore_error_handler(); }
        if ($stream === false) { echo "Этот адрес не принадлежит учебному хранилищу.\n"; }
        else { fclose($stream); }
        echo file_get_contents('lesson://store/pickup.txt');

Этот адрес не принадлежит учебному хранилищу.
Заказ104: ready

path приходит в форме scheme://…; варианты scheme: и scheme:/ этот протокол не поддерживает. parse_url может помочь разделить части, но не валидирует полномочия/безопасность. mode следует контракту fopen: r требует существующий файл, w обнуляет, a дописывает, x требует нового файла, c создаёт без обнуления, + разрешает чтение/запись; wrapper обязан выбрать поддерживаемые режимы, а не молча заменить их.

options — битовая маска: STREAM_USE_PATH просит учитывать include_path; при успешном поиске &$opened_path должен получить действительный полный адрес открытого ресурса. STREAM_REPORT_ERRORS определяет, должен ли wrapper сообщать ошибки открытия. В этой лаборатории разрешены абсолютные lesson://store/... адреса без поиска include_path; она не изображает общий resolver. $context PHP задаёт публичному свойству при переданном контексте.

Связанные операции: stream_wrapper_register, streamWrapper::__construct, streamWrapper::stream_read, stream_context_get_options.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_open

PHP 4.3.2+ · standard

streamWrapper::stream_read(int $count): string|false

Вернуть следующую порцию байтов из источника и обновить его позицию.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

read возвращает максимум count байтов и продвигает внутреннюю позицию на их фактическое количество. Пустая строка означает отсутствие доступных байтов; false — отказ чтения. Внешний fread(3) не обещает вызов stream_read(3): PHP может запросить больше и сохранить остаток во внутреннем буфере.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        try { echo fread($stream, 3), "\n"; echo stream_get_contents($stream); }
        finally { fclose($stream); }

tea

milk

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/empty.txt', 'rb');
        if ($stream === false) { throw new RuntimeException('Список недоступен'); }
        try {
            $data = fread($stream, 100);
            if ($data === false) { throw new RuntimeException('Ошибка чтения'); }
            echo $data === '' ? "Заказов на выдачу пока нет.\n" : $data;
        } finally { fclose($stream); }

Заказов на выдачу пока нет.

Связанные операции: streamWrapper::stream_eof, streamWrapper::stream_seek, stream_get_contents.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_read

PHP 4.3.2+ · standard

streamWrapper::stream_write(string $data): int

Записать доступное количество входных байтов и вернуть точное число принятых.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

write принимает строку байтов и возвращает число действительно записанных. int здесь не произвольный код успеха: true или 1 вместо длины сообщает запись одного байта. При ограниченном источнике разрешена частичная запись; вызывающему коду нужно продолжить с оставшейся части, не дублируя уже записанную.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/result.txt', 'wb');
        if ($stream === false) { throw new RuntimeException('Не открыть результат'); }
        try {
            $text = "104:ready\n";
            if (fwrite($stream, $text) !== strlen($text)) { throw new RuntimeException('Запись неполная'); }
        } finally { fclose($stream); }
        echo file_get_contents(__DIR__ . '/store/result.txt');

104:ready

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'r+b');
        try {
            fseek($stream, 4);
            echo fwrite($stream, 'silk'), "\n";
            rewind($stream);
            echo stream_get_contents($stream);
        } finally { fclose($stream); }

4
tea
silk

Если ничего сохранить нельзя, возвращают 0. Завышенное число больше strlen(data) вызывает warning и ограничивается длиной входа; это баг wrapper, а не механизм подтверждения доставки. Наш мост переводит false внутреннего fwrite в 0 и оставляет его warning; production-адаптер должен описать собственную диагностику и частичный результат. Успешная запись не означает fsync, получение другой стороной или фиксацию бизнес-транзакции.

Связанные операции: streamWrapper::stream_open, streamWrapper::stream_flush, streamWrapper::stream_truncate.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_write

PHP 4.3.2+ · standard

streamWrapper::stream_seek(int $offset, int $whence): bool

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

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

seek меняет позицию, а не содержимое. offset измеряется в байтах. SEEK_SET отсчитывает от начала, SEEK_CUR от текущей позиции, SEEK_END от конца; отрицательный offset допустим относительно конца/текущего, пока итоговая позиция допустима для источника.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        try { var_dump(fseek($stream, 4)); echo fread($stream, 4), "\n"; }
        finally { fclose($stream); }

int(0)
milk

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        try { fseek($stream, -5, SEEK_END); echo stream_get_contents($stream); }
        finally { fclose($stream); }

milk

В текущей реализации PHP преобразует SEEK_CUR в SEEK_SET перед callback; корректная общая реализация всё же описывает все три режима. Некоторые перемещения движок выполняет внутри собственного read-буфера, не вызывая wrapper. После успешного stream_seek PHP запрашивает stream_tell; отказ определения позиции превращает операцию в неуспех. Источник без произвольного доступа должен вернуть false, а не симулировать перемещение счётчиком.

Связанные операции: streamWrapper::stream_tell, streamWrapper::stream_read, stream_set_read_buffer.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_seek

PHP 4.3.2+ · standard

streamWrapper::stream_tell(): int

Вернуть текущую внутреннюю позицию источника для согласования операций seek.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

tell сообщает внутреннюю текущую позицию wrapper в байтах. PHP использует её при синхронизации перемотки. Внешний ftell учитывает также свой буфер; не вычисляйте возвращаемую позицию по числу вызовов read, потому что чтение может быть упреждающим.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/queue.txt', 'rb');
        try {
            echo 'Первый заказ: ', rtrim(fgets($stream)), "\n";
            $next = ftell($stream);
            echo 'Позиция следующего: ', $next, "\n";
            rewind($stream);
            if (fseek($stream, $next) !== 0) { throw new RuntimeException('Не восстановить позицию'); }
            echo 'Продолжение: ', rtrim(fgets($stream)), "\n";
        } finally { fclose($stream); }

Первый заказ: 104
Позиция следующего: 4
Продолжение: 105

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        try { echo fread($stream, 3), ':', ftell($stream), "\n"; rewind($stream); echo ftell($stream), "\n"; }
        finally { fclose($stream); }

tea:3
0

Связанные операции: streamWrapper::stream_seek, streamWrapper::stream_read.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_tell

PHP 4.3.2+ · standard

streamWrapper::stream_eof(): bool

Сообщить настоящий конец источника без потребления данных.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

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

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        try { var_dump(feof($stream)); echo stream_get_contents($stream); var_dump(feof($stream)); }
        finally { fclose($stream); }

bool(false)
tea
milk
bool(true)

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        try { stream_get_contents($stream); rewind($stream); var_dump(feof($stream)); echo fread($stream, 3), "\n"; }
        finally { fclose($stream); }

bool(false)
tea

Связанные операции: streamWrapper::stream_read, streamWrapper::stream_seek, stream_select.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_eof

PHP 5.4+ · standard

streamWrapper::stream_truncate(int $new_size): bool

Изменить размер открытого хранилища по запросу ftruncate.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

truncate меняет размер хранилища. Уменьшение отбрасывает хвост; увеличение для обычного файла добавляет нулевые байты. Это не то же самое, что перемещение курсора: прежняя позиция может остаться за новым концом. Реализация своего хранилища обязана явно обеспечить выбранную семантику.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/status.txt', 'r+b');
        try {
            $status = 'ready';
            if (fwrite($stream, $status) !== strlen($status)) { throw new RuntimeException('Неполная запись'); }
            if (!ftruncate($stream, strlen($status))) { throw new RuntimeException('Не удалить старый хвост'); }
            rewind($stream); echo stream_get_contents($stream), "\n";
        } finally { fclose($stream); }

ready

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/small.txt', 'r+b');
        try { ftruncate($stream, 5); rewind($stream); echo bin2hex(stream_get_contents($stream)), "\n"; }
        finally { fclose($stream); }

7465610000

Связанные операции: streamWrapper::stream_write, streamWrapper::stream_stat, streamWrapper::stream_seek.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_truncate

PHP 4.3.2+ · standard

streamWrapper::__construct()

Подготовить независимый объект обработчика перед операцией над адресом.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

В отличие от php_user_filter, обычный wrapper получает вызов __construct. PHP создаёт объект перед stream_open, не передаёт в конструктор аргументы fopen и только затем просит открыть конкретный адрес. Поэтому URL и mode обрабатывают в stream_open, а в конструкторе готовят нейтральное состояние.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        echo implode(',', array_slice(LessonFileBridge::$events, 0, 2)), "\n";
        fclose($stream);

construct,open

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $first = fopen('lesson://store/tea.txt', 'rb');
        $second = fopen('lesson://store/tea.txt', 'rb');
        try {
            echo count(array_filter(LessonFileBridge::$events, fn($event) => $event === 'construct')), "\n";
            echo fread($first, 3), ':', fread($second, 3), "\n";
        } finally { fclose($first); fclose($second); }

2
tea:tea

Не требуйте обязательный аргумент конструктора: движок вызывает его без параметров. Контекст доступен публичному свойству wrapper по правилам операции; параметры пути надёжнее разбирать при открытии. Конструктор также может появиться ради url_stat/unlink и других операций по URL — объект не обязательно станет долгоживущим открытым файлом.

Связанные операции: stream_wrapper_register, streamWrapper::stream_open, php_user_filter::onCreate, streamWrapper::__destruct.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::__construct

PHP 4.3.2+ · standard

streamWrapper::__destruct()

Завершить жизнь объекта wrapper, различая её с закрытием самого потока.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

Деструктор относится к времени жизни объекта, а stream_close — к закрытию открытого потока. Обычно эти события идут рядом, но ссылка на wrapper_data может удерживать объект после fclose. Поэтому необходимые файловые ресурсы освобождают в stream_close, а не рассчитывают, что деструктор немедленно завершит всё.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/result.txt', 'wb');
        fwrite($stream, 'tea');
        fclose($stream);
        $events = LessonFileBridge::$events;
        var_dump(array_search('flush', $events, true) < array_search('close', $events, true));
        var_dump(array_search('close', $events, true) < array_search('destruct', $events, true));

bool(true)
bool(true)

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        $wrapper = stream_get_meta_data($stream)['wrapper_data'];
        fclose($stream);
        var_dump(in_array('close', LessonFileBridge::$events, true));
        var_dump(in_array('destruct', LessonFileBridge::$events, true));
        unset($wrapper);
        var_dump(in_array('destruct', LessonFileBridge::$events, true));

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

Связанные операции: streamWrapper::stream_close, streamWrapper::stream_flush, stream_get_meta_data.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::__destruct

PHP 4.3.2+ · standard

streamWrapper::stream_close(): void

Освободить ресурсы конкретного открытого потока при fclose.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

close вызывается для закрытия открытого stream resource. Освободите внутренние файлы, временные handles и удержанные блокировки. Метод ничего не возвращает; завершать данные следует раньше в stream_flush, если у wrapper есть буфер. Полагаться только на автоматическую уборку в конце запроса неудобно для долгих workers.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/pickup.txt', 'wb');
        fwrite($stream, "104:ready\n");
        fclose($stream);
        echo is_resource($stream) ? "Ресурс ещё открыт\n" : "Открытый ресурс закрыт\n";
        echo 'Файл сохранён: ', file_get_contents(__DIR__ . '/store/pickup.txt');

Открытый ресурс закрыт
Файл сохранён: 104:ready

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $first = fopen('lesson://store/tea.txt', 'rb');
        $second = fopen('lesson://store/tea.txt', 'rb');
        fclose($first);
        try { echo stream_get_contents($second); }
        finally { fclose($second); }

tea
milk

Связанные операции: streamWrapper::__destruct, streamWrapper::stream_flush, streamWrapper::dir_closedir.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_close

PHP 4.3.2+ · standard

streamWrapper::stream_flush(): bool

Сбросить собственный кэш wrapper в нижележащее хранилище.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

Если wrapper принял байты в собственный кэш, fflush просит передать их в нижележащее хранилище. true означает, что кэш сброшен либо сбрасывать нечего. Это не автоматическая гарантия fsync, доставки по сети или транзакционной фиксации: смысл зависит от вашего хранилища.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/report.txt', 'wb');
        try {
            $text = "104:ready\n";
            if (fwrite($stream, $text) !== strlen($text) || !fflush($stream)) {
                throw new RuntimeException('Нельзя объявить отчёт готовым');
            }
            echo "Запись передана нижнему хранилищу.\n";
        } finally { fclose($stream); }
        echo file_get_contents(__DIR__ . '/store/report.txt');

Запись передана нижнему хранилищу.
104:ready

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/empty.txt', 'wb');
        try { var_dump(fflush($stream)); echo fstat($stream)['size'], "\n"; }
        finally { fclose($stream); }

bool(true)
0

PHP вызывает callback при fflush и при закрытии, когда были несброшенные записи. Если метод не реализован, предполагается false. Ошибку финализации лучше обнаруживать явным fflush до объявления экспорта готовым; stream_close не возвращает отдельный boolean вашей бизнес-логике.

Связанные операции: streamWrapper::stream_write, streamWrapper::stream_close, stream_set_write_buffer.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_flush

PHP 4.3.2+ · standard

streamWrapper::stream_stat(): array|false

Сообщить сведения stat для уже открытого stream resource.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

fstat спрашивает сведения уже открытого экземпляра: размер, тип, времена и остальные поля stat. Wrapper должен вернуть массив в формате stat, а не только строку размера. Если данных нет, возвращают false; неизвестные поля заполняют осмысленно, обычно нулём, а не случайными значениями.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/pickup.txt', 'rb');
        try {
            $info = fstat($stream);
            if ($info === false || $info['size'] > 100) { throw new RuntimeException('Нужен порционный читатель'); }
            echo 'Размер: ', $info['size'], " байт\n";
            echo stream_get_contents($stream, 101);
        } finally { fclose($stream); }

Размер: 10 байт
104:ready

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/report.txt', 'w+b');
        try { fwrite($stream, 'tea'); echo fstat($stream)['size'], "\n"; ftruncate($stream, 1); echo fstat($stream)['size'], "\n"; }
        finally { fclose($stream); }

3
1

Обычный stat содержит числовые индексы 0–12 и соответствующие имена. Для виртуального источника следуйте этому формату и ограничениям платформы. Отсутствующий stream_stat вызывает E_WARNING; не скрывайте его фиктивным успешным массивом, если библиотеки действительно опираются на эти сведения.

Связанные операции: streamWrapper::url_stat, streamWrapper::stream_truncate, stream_get_meta_data.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_stat

PHP 4.3.2+ · standard

streamWrapper::url_stat(string $path, int $flags): array|false

Получить stat-сведения по адресу, включая тихие проверки существования и сведения о ссылке.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

url_stat проверяет адрес без предварительного fopen. Он нужен не только stat: file_exists, is_file, is_dir, filesize, filemtime и множество операций SplFileInfo используют тот же протокол. Поэтому read-only wrapper без url_stat может хорошо читаться и одновременно не проходить проверку существования в библиотеке.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $url = 'lesson://store/pickup.txt';
        if (!is_file($url)) { throw new RuntimeException('Нет готового листа выдачи'); }
        echo 'Лист, ', filesize($url), " байт:\n", file_get_contents($url);

Лист, 10 байт:
104:ready

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $reported = 0;
        set_error_handler(function ($level) use (&$reported) {
            if (error_reporting() & $level) { $reported++; }
            return true;
        });
        try { var_dump(file_exists('lesson://store/missing.txt')); }
        finally { restore_error_handler(); }
        echo $reported, "\n";

bool(false)
0

STREAM_URL_STAT_LINK просит сведения о самой ссылке, не о её цели (lstat/is_link/filetype). STREAM_URL_STAT_QUIET запрещает wrapper сообщать ошибку; без флага он отвечает за корректную диагностику. Context обновляется при его передаче вызывающей операции. PHP может кэшировать stat: после изменения пути в тесте очищайте clearstatcache; кэш не должен изображать реальное отсутствие гонок между проверкой и открытием.

Связанные операции: streamWrapper::stream_stat, streamWrapper::stream_open, stream_context_get_options.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::url_stat

PHP 5.3+ · standard

streamWrapper::stream_cast(int $cast_as): resource|false

Предоставить PHP внутренний ресурс, пригодный для запрошенного низкоуровневого действия.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

Не каждую абстракцию можно передать системному select. stream_cast позволяет вернуть настоящий внутренний stream resource, для которого ОС умеет ожидать готовность. Вернуть произвольный целый descriptor или сам внешний wrapper нельзя. Если подходящего ресурса нет, честный ответ — false.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $object = new LessonFileBridge();
        $opened = null;
        $object->stream_open('lesson://store/tea.txt', 'rb', 0, $opened);
        try {
            $inner = $object->stream_cast(STREAM_CAST_AS_STREAM);
            echo get_resource_type($inner), ':', fread($inner, 3), "\n";
        } finally { $object->stream_close(); }

stream:tea

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        require __DIR__ . '/tcp-lab.php';
        [$client, $peer] = lessonTcpPair();
        class SocketBridge {
            public $context = null;
            public static $inner;
            public function stream_open($path, $mode, $options, &$opened): bool { return is_resource(self::$inner); }
            public function stream_cast($castAs) { return self::$inner; }
            public function stream_read($count): string|false { return fread(self::$inner, $count); }
            public function stream_eof(): bool { return feof(self::$inner); }
            public function stream_close(): void { fclose(self::$inner); }
        }
        SocketBridge::$inner = $client;
        stream_wrapper_register('castlab', SocketBridge::class);
        $wrapped = fopen('castlab://pair', 'rb');
        try {
            lessonWriteAll($peer, 'tea');
            $read = [$wrapped]; $write = null; $except = null;
            echo stream_select($read, $write, $except, 1), "\n";
            echo lessonReadExact($wrapped, 3), "\n";
        } finally { fclose($wrapped); fclose($peer); stream_wrapper_unregister('castlab'); }

1
tea

cast_as равен STREAM_CAST_FOR_SELECT при ожидании готовности или STREAM_CAST_AS_STREAM для иных применений. Возвращаемый underlying resource должен поддерживать нужное действие; обычный файл на Windows нельзя считать пригодным для socket select. Краткая таблица констант ошибочно называет streamWrapper::stream_select — такого callback нет: вызывает глобальная stream_select.

Связанные операции: stream_select, stream_socket_client, streamWrapper::stream_close.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_cast

PHP 5+ · standard

streamWrapper::stream_lock(int $operation): bool

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

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

Блокировка имеет смысл только тогда, когда все конкурирующие участники используют совместимый механизм. Нельзя реализовать stream_lock как return true без настоящей блокировки: file_put_contents(..., LOCK_EX) тогда создаёт ложную уверенность в защите параллельной записи.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/stock.txt', 'r+b');
        try {
            if (!flock($stream, LOCK_EX)) { throw new RuntimeException('Остаток занят'); }
            try {
                $stock = (int) stream_get_contents($stream);
                if ($stock < 2) { throw new RuntimeException('Недостаточно товара'); }
                $next = (string) ($stock - 2);
                rewind($stream);
                if (fwrite($stream, $next) !== strlen($next) || !ftruncate($stream, strlen($next)) || !fflush($stream)) {
                    throw new RuntimeException('Остаток не сохранён');
                }
            } finally { flock($stream, LOCK_UN); }
        } finally { fclose($stream); }
        echo 'После выдачи двух: ', file_get_contents('lesson://store/stock.txt'), "\n";

После выдачи двух: 10

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $first = fopen('lesson://store/tea.txt', 'r+b');
        $second = fopen('lesson://store/tea.txt', 'r+b');
        try {
            flock($first, LOCK_EX);
            var_dump(flock($second, LOCK_EX | LOCK_NB));
            flock($first, LOCK_UN);
            var_dump(flock($second, LOCK_EX | LOCK_NB));
            flock($second, LOCK_UN);
        } finally { fclose($first); fclose($second); }

bool(false)
bool(true)

operation содержит LOCK_SH, LOCK_EX или LOCK_UN, иногда вместе с LOCK_NB. Не делайте сравнение только ===LOCK_EX, забыв снять/проверить NB. Callback связан с flock и записью с LOCK_EX; закрытие освобождает удержанное состояние underlying ресурса. Современный stream_set_blocking идёт через stream_set_option, несмотря на старое упоминание в описании stream_lock. Advisory lock не защищает от кода, который её игнорирует, и не равен транзакции БД.

Связанные операции: stream_supports_lock, streamWrapper::stream_close, streamWrapper::stream_set_option.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_lock

PHP 5.3+ · standard

streamWrapper::stream_set_option(int $option, int $arg1, ?int $arg2): bool

Перевести запрос blocking, таймаута или буфера в настройку underlying ресурса.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

Этот callback переводит общую настройку потока в возможности конкретного источника. Не возвращайте true просто потому, что узнали имя option: нижний ресурс должен принять соответствующую настройку. Буфер, таймаут и blocking — разные вещи.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        try {
            stream_set_blocking($stream, true);
            var_dump(in_array('option:' . STREAM_OPTION_BLOCKING . ':null', LessonFileBridge::$events, true));
        } finally { fclose($stream); }

bool(true)

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $stream = fopen('lesson://store/tea.txt', 'rb');
        try {
            var_dump(stream_set_read_buffer($stream, 0));
            echo fread($stream, 3), "\n";
        } finally { fclose($stream); }

int(0)
tea

STREAM_BUFFER_LINE существует в общем наборе констант, но описанные пользовательские setters не дают обещания универсального line-buffering. Неизвестный/неподдерживаемый option возвращает false. Таймаут нужен сетевому ожиданию; обычный локальный файл не следует выдавать за сервер, который реально соблюдает такую сетевую политику.

Связанные операции: stream_set_blocking, stream_set_timeout, stream_set_read_buffer, stream_set_write_buffer.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_set_option

PHP 5.4+ · standard

streamWrapper::stream_metadata(string $path, int $option, mixed $value): bool

Изменить время, режим или владельца по URL согласно конкретному option.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

metadata меняет сведения по URL: время, права или владельца. Открытый файл для этого не обязателен. option определяет тип value; нельзя обрабатывать любое значение как одинаковый массив. Неподдерживаемая операция должна возвращать false, не имитировать административное действие.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $url = 'lesson://store/tea.txt';
        if (!touch($url, 1700000000, 1700000000)) { throw new RuntimeException('Не изменить время'); }
        clearstatcache();
        echo 'Готов с: ', gmdate('Y-m-d H:i:s', filemtime($url)), " UTC\n";
        echo file_get_contents($url);

Готов с: 2023-11-14 22:13:20 UTC
tea
milk

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $object = new LessonFileBridge();
        var_dump($object->stream_metadata('lesson://store/tea.txt', STREAM_META_OWNER_NAME, 'demo-owner'));
        var_dump($object->stream_metadata('lesson://store/tea.txt', STREAM_META_GROUP, 123));

bool(false)
bool(false)

URL должен иметь ://; PHP обновляет context при его передаче. Времена/права/владельцы зависят от ОС и хранилища. Например chmod под Windows не создаёт полноценную POSIX-модель разрешений. После успешного изменения учитывайте stat-кэш; успех setter не делает проверку доступа приложением ненужной.

Связанные операции: streamWrapper::url_stat, stream_context_get_options.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::stream_metadata

PHP 4.3.2+ · standard

streamWrapper::dir_opendir(string $path, int $options): bool

Подготовить отдельный источник имён каталога по URL.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

Каталог — поток имён, а не поток содержимого файлов. opendir создаёт объект wrapper и вызывает dir_opendir; после true вызывающий код получает directory resource. Реализация хранит собственный iterator/handle в экземпляре, отдельно от состояния обычного stream_open.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $directory = opendir('lesson://store/items');
        if ($directory === false) { throw new RuntimeException('Не открыть список'); }
        $names = [];
        try {
            while (($name = readdir($directory)) !== false) {
                if ($name !== '.' && $name !== '..') { $names[] = $name; }
            }
        } finally { closedir($directory); }
        sort($names, SORT_STRING);
        echo 'Документы: ', implode(', ', $names), "\n";

Документы: a.txt, b.txt

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        set_error_handler(fn($level) => $level === E_WARNING);
        try { var_dump(opendir('lesson://store/missing')); }
        finally { restore_error_handler(); }

bool(false)

path — исходный URL, options — переданные движком флаги. Официальная страница не определяет для этого callback самостоятельный пользовательский набор значений options, поэтому не придумывайте режимы вроде «1 = рекурсивно». Отсутствие поддерживаемой directory-операции лучше сообщить отказом; реализация чтения файлов не обязана уметь перечислять каталог.

Связанные операции: streamWrapper::dir_readdir, streamWrapper::dir_closedir, streamWrapper::mkdir.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::dir_opendir

PHP 4.3.2+ · standard

streamWrapper::dir_readdir(): string|bool

Вернуть следующее имя каталога либо строго false при завершении обхода.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

dir_readdir возвращает следующее имя строкой, а когда записи закончились — строго false. Имя "0" является допустимым, поэтому цикл while ($name = readdir(...)) неверен: он остановится на таком файле. Возвращать true вместо конца исторически тоже завершает обход, но использовать следует именно false.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $directory = opendir('lesson://store/items');
        $names = [];
        try {
            while (($name = readdir($directory)) !== false) {
                if ($name !== '.' && $name !== '..') { $names[] = $name; }
            }
        } finally { closedir($directory); }
        sort($names, SORT_STRING);
        echo implode(',', $names), "\n";

a.txt,b.txt

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $directory = opendir('lesson://store/names');
        try {
            while (($name = readdir($directory)) !== false) {
                if ($name === '0') { echo $name, ': ', file_get_contents('lesson://store/names/' . $name); }
            }
        } finally { closedir($directory); }

0: Заказ без присвоенного номера

Небулевы исторические значения движок приводит к строке, но новый wrapper должен соблюдать string|false. Callback возвращает имя элемента, не его содержимое; чтение выполняется отдельным fopen. Не выдавайте неконтролируемую бесконечную последовательность: состояние обхода должно двигаться вперёд. При отсутствующем методе PHP выдаёт E_WARNING.

Связанные операции: streamWrapper::dir_opendir, streamWrapper::dir_rewinddir, streamWrapper::dir_closedir.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::dir_readdir

PHP 4.3.2+ · standard

streamWrapper::dir_rewinddir(): bool

Сбросить iterator каталога к началу для следующего readdir.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

rewinddir сбрасывает состояние перечисления так, чтобы следующий readdir снова вернул первый элемент. Это не fseek по байтам: directory iterator может быть списком имён архива, запросом к хранилищу или системным directory handle.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $directory = opendir('lesson://store/items');
        try {
            foreach (['Первый просмотр', 'После rewinddir'] as $label) {
                $names = [];
                while (($name = readdir($directory)) !== false) {
                    if ($name !== '.' && $name !== '..') { $names[] = $name; }
                }
                sort($names, SORT_STRING); echo $label, ': ', implode(', ', $names), "\n";
                rewinddir($directory);
            }
        } finally { closedir($directory); }

Первый просмотр: a.txt, b.txt
После rewinddir: a.txt, b.txt

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $directory = opendir('lesson://store/items');
        try {
            $names = [];
            while (($name = readdir($directory)) !== false) {
                if ($name !== '.' && $name !== '..') { $names[] = $name; }
            }
            sort($names, SORT_STRING); echo 'Предпросмотр: ', implode(', ', $names), "\n";
            rewinddir($directory);
            $documents = [];
            while (($name = readdir($directory)) !== false) {
                if ($name !== '.' && $name !== '..') { $documents[$name] = file_get_contents('lesson://store/items/' . $name); }
            }
            ksort($documents, SORT_STRING);
            foreach ($documents as $name => $text) { echo $name, ': ', $text; }
        } finally { closedir($directory); }

Предпросмотр: a.txt, b.txt
a.txt: Заказ104: ready
b.txt: Заказ105: packed

Связанные операции: streamWrapper::dir_readdir, streamWrapper::dir_opendir.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::dir_rewinddir

PHP 4.3.2+ · standard

streamWrapper::dir_closedir(): bool

Освободить ресурсы открытого перечисления каталога.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

closedir завершает именно directory resource. В callback освободите iterator, файлы архива или блокировки, которые выделили для перечисления. Для обычного файла используется stream_close; смешивание этих handles вызывает ошибки.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $directory = opendir('lesson://store/items');
        closedir($directory);
        echo is_resource($directory) ? "Список ещё открыт\n" : "Ресурс списка закрыт\n";
        echo 'Документ сохранён: ', file_get_contents('lesson://store/items/a.txt'), "\n";

Ресурс списка закрыт
Документ сохранён: A

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $directory = opendir('lesson://store/items');
        try {
            while (($name = readdir($directory)) !== false) {
                if ($name === 'a.txt') { echo "Найден a.txt\n"; break; }
            }
        } finally { closedir($directory); }
        var_dump(in_array('dir_close', LessonFileBridge::$events, true));

Найден a.txt
bool(true)

Связанные операции: streamWrapper::dir_opendir, streamWrapper::stream_close.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::dir_closedir

PHP 5+ · standard

streamWrapper::mkdir(string $path, int $mode, int $options): bool

Создать каталог в хранилище wrapper с учётом режима и запроса рекурсивного создания.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

mkdir по собственной схеме должен создать каталог именно в её хранилище. mode и recursive — запросы к этой реализации, а не доказательство, что любую файловую систему можно преобразовать в POSIX. Если wrapper вообще не поддерживает создание каталогов, официальный контракт рекомендует не объявлять метод: PHP сможет сообщить отсутствие операции.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

if (!mkdir('lesson://store/new', 0750)) { throw new RuntimeException('Не создать каталог'); }
file_put_contents('lesson://store/new/104.txt', "104:ready\n");
echo file_get_contents('lesson://store/new/104.txt');

104:ready

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

if (!mkdir('lesson://store/new/exports', 0750, true)) { throw new RuntimeException('Не создать каталог'); }
file_put_contents('lesson://store/new/exports/104.txt', "104:ready\n");
echo file_get_contents('lesson://store/new/exports/104.txt');

104:ready

Связанные операции: streamWrapper::rmdir, streamWrapper::url_stat, stream_context_get_options.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::mkdir

PHP 5+ · standard

streamWrapper::rename(string $path_from, string $path_to): bool

Переименовать файл или каталог, проверив исходный и целевой адреса.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

rename переносит имя файла или каталога внутри возможностей данного wrapper. Обе стороны нужно проверить независимо; безопасный исходный путь не делает безопасным target. Удаление существующего destination, атомарность и поддержка перемещения между хранилищами определяются backend — callback не добавляет эти гарантии автоматически.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        var_dump(rename('lesson://store/tea.txt', 'lesson://store/menu.txt'));
        clearstatcache();
        var_dump(file_exists('lesson://store/tea.txt'));
        echo file_get_contents('lesson://store/menu.txt');

bool(true)
bool(false)
tea
milk

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        var_dump(rename('lesson://store/items', 'lesson://store/archive'));
        echo file_get_contents('lesson://store/archive/a.txt'), "\n";
        clearstatcache();
        var_dump(is_dir('lesson://store/items'));

bool(true)
A
bool(false)

Связанные операции: streamWrapper::url_stat, streamWrapper::unlink, streamWrapper::mkdir.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::rename

PHP 5+ · standard

streamWrapper::rmdir(string $path, int $options): bool

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

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

rmdir удаляет каталог по договору хранилища. Обычный PHP rmdir не является рекурсивным удалением дерева. На странице callback упомянут общий options с STREAM_MKDIR_RECURSIVE; это не даёт внешнему rmdir параметр recursive и не требует автоматически удалять дочерние файлы. Наша лаборатория поддерживает только пустой каталог и отвергает такой рекурсивный запрос.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        mkdir('lesson://store/empty', 0750);
        var_dump(rmdir('lesson://store/empty'));
        clearstatcache();
        var_dump(is_dir('lesson://store/empty'));

bool(true)
bool(false)

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        set_error_handler(fn($level) => $level === E_WARNING);
        try { var_dump(rmdir('lesson://store/items')); }
        finally { restore_error_handler(); }
        echo file_get_contents('lesson://store/items/a.txt'), "\n";

bool(false)
A

Связанные операции: streamWrapper::mkdir, streamWrapper::unlink, streamWrapper::url_stat.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::rmdir

PHP 5+ · standard

streamWrapper::unlink(string $path): bool

Удалить файл по адресу в пределах возможностей и полномочий wrapper.

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

streamWrapper — название протокола методов в документации, не существующий базовый класс. Эти методы пишет наш LessonFileBridge; PHP вызывает их через обычные файловые функции. Полный wrapper-lab.php приложен к каждому примеру. Он делегирует операции файлам исключительно временной папки этого опыта. Это прозрачный учебный мост, не защита произвольного пути загрузки: в настоящем сервисе нужны полномочия, политика путей, контроль ссылок и гонок.

unlink удаляет имя файла по URL. Это операция по адресу, а не закрытие открытого handle; для закрытия используют fclose/stream_close. На некоторых ОС файл с открытым handle ведёт себя иначе, поэтому пример сначала завершает запись и только потом удаляет свой временный экспорт.

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        $url = 'lesson://store/export.tmp';
        file_put_contents($url, "104:ready\n");
        echo 'Прочитано: ', file_get_contents($url);
        if (!unlink($url)) { throw new RuntimeException('Не удалить промежуточный файл'); }
        clearstatcache();
        echo file_exists($url) ? "Копия осталась\n" : "Промежуточная копия удалена\n";

Прочитано: 104:ready
Промежуточная копия удалена

<?php
declare(strict_types=1);

require __DIR__ . '/wrapper-lab.php';
lessonRegister();

        unlink('lesson://store/tea.txt');
        set_error_handler(fn($level) => $level === E_WARNING);
        try { var_dump(unlink('lesson://store/tea.txt')); }
        finally { restore_error_handler(); }
        var_dump(file_exists('lesson://store/items/a.txt'));

bool(false)
bool(true)

Связанные операции: streamWrapper::stream_close, streamWrapper::rmdir, streamWrapper::url_stat.

Маршрут от первого потока к контекстам и фильтрам.

• PHP: streamWrapper::unlink