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

<?php
$text = '  Отчёт  ';
echo '[', ltrim($text), "]\n";
echo '[', $text, "]\n";

[Отчёт  ]
[  Отчёт  ]

Квадратные скобки — подсказка для глаз, не часть входных данных. Возвращается новая строка, исходная переменная остаётся прежней. Второй аргумент задаёт набор отдельных удаляемых байтов, а не слово или целый суффикс.

<?php
$line = "\t  stock=8 \r\n";
$clean = ltrim($line, " \t");
echo 'После обработки: ', str_replace(["\r", "\n", "\t"], ['<CR>', '<LF>', '<TAB>'], $clean), "\n";

После обработки: stock=8 <CR><LF>

Маска содержит пробел и TAB: только они считаются служебным отступом. Переводы строк справа остаются. str_replace в последней строке лишь делает невидимые символы видимыми. Если нужно убрать строго один конечный CRLF, rtrim не подходит: он снимает всю последовательность подходящих крайних байтов.

<?php
$text = '  Отчёт  ';
echo '[', rtrim($text), "]\n";
echo '[', $text, "]\n";

[  Отчёт]
[  Отчёт  ]

Квадратные скобки — подсказка для глаз, не часть входных данных. Возвращается новая строка, исходная переменная остаётся прежней. Второй аргумент задаёт набор отдельных удаляемых байтов, а не слово или целый суффикс.

<?php
$line = "\t  stock=8 \r\n";
$clean = rtrim($line, "\r\n");
echo 'После обработки: ', str_replace(["\r", "\n", "\t"], ['<CR>', '<LF>', '<TAB>'], $clean), "\n";

После обработки: <TAB>  stock=8 

В маске только CR и LF. Поэтому справа убрано окончание строки, а пробел перед ним и отступ слева сохранены. str_replace в последней строке лишь делает невидимые символы видимыми. Если нужно убрать строго один конечный CRLF, rtrim не подходит: он снимает всю последовательность подходящих крайних байтов.

<?php
$text = '  Отчёт  ';
echo '[', chop($text), "]\n";
echo '[', $text, "]\n";

[  Отчёт]
[  Отчёт  ]

Квадратные скобки — подсказка для глаз, не часть входных данных. Возвращается новая строка, исходная переменная остаётся прежней. Второй аргумент задаёт набор отдельных удаляемых байтов, а не слово или целый суффикс.

<?php
$line = "\t  stock=8 \r\n";
$clean = chop($line, "\r\n");
echo 'После обработки: ', str_replace(["\r", "\n", "\t"], ['<CR>', '<LF>', '<TAB>'], $clean), "\n";

После обработки: <TAB>  stock=8 

В маске только CR и LF. Поэтому справа убрано окончание строки, а пробел перед ним и отступ слева сохранены. str_replace в последней строке лишь делает невидимые символы видимыми. Если нужно убрать строго один конечный CRLF, rtrim не подходит: он снимает всю последовательность подходящих крайних байтов.

<?php
$label = 'OLD-0042';
echo substr_replace($label, 'NEW', 0, 3), "\n";
echo substr_replace('0042', '-', 2, 0), "\n";
echo substr_replace('ORDER-0042', '', 0, 6), "\n";

NEW-0042
00-42
0042

Аргументы: исходный текст, новый текст, начало и длина удаляемого участка. Длина 0 означает вставку без удаления, пустая замена — удаление. Все позиции байтовые. В первом примере формат фиксирован; если префикс неизвестен, сначала проверяют его.

<?php
$reference = 'REQUEST-781245';
$shown = substr_replace($reference, '****', -6, 4);
echo 'Заявка: ', $shown, "\n";
echo 'Исходный номер: ', $reference, "\n";

Заявка: REQUEST-****45
Исходный номер: REQUEST-781245

Начало -6 отсчитывается от конца, длина 4 заменяет первые четыре цифры номера. Так можно ограничить отображение внутреннего идентификатора, когда полный номер не нужен. Маскирование на странице не удаляет исходное значение из памяти и не заменяет проверку доступа.

<?php
$labels = ['OLD-0042', 'OLD-0043'];
$updated = substr_replace($labels, 'NEW', 0, 3);
echo implode(', ', $updated), "\n";
echo substr_replace('ABC-42-END', 'X', 4, -4), "\n";

NEW-0042, NEW-0043
ABC-X-END

Массив исходных строк даёт массив результатов. Отрицательная длина задаёт конец заменяемой области относительно конца строки: -4 оставляет суффикс -END. Списки смещений, длин и замен работают по договору, описанному в таблице параметров; не используйте байтовые позиции для середины русской буквы.

<?php
$number = '42';
$label = str_pad($number, 6, '0', STR_PAD_LEFT);
echo 'Заказ № ', $label, "\n";
echo str_pad('1234567', 6, '0', STR_PAD_LEFT), "\n";

Заказ № 000042
1234567

Константа STR_PAD_LEFT выбирает левую сторону. Если аргумент не задан, дополнение идёт справа. Второй результат длиннее шести знаков: задана минимальная, а не максимальная длина. Уникальные номера создаёт хранилище, а str_pad лишь оформляет уже имеющийся номер.

<?php
$stock = ['BRUSH' => 8, 'TAPE' => 15];
foreach ($stock as $code => $quantity) {
    echo str_pad($code, 8, '.'), $quantity, "\n";
}
echo str_pad('SALE', 9, '-', STR_PAD_BOTH), "\n";

BRUSH...8
TAPE....15
--SALE---

Заполнитель . добавляется справа до восьми байтов. STR_PAD_BOTH распределяет заполнение по сторонам; при нечётном остатке справа один знак больше. Для русского текста str_pad считает байты, поэтому столбцы могут разъехаться. mb_str_pad учитывает кодовые точки, но не фактическую ширину шрифта; для сайта используйте HTML-таблицу.

<?php
echo "Кисть: 1 шт.\n";
echo str_repeat('-', 12), "\n";
echo "Итого: 250 руб.\n";

Кисть: 1 шт.
------------
Итого: 250 руб.

Первый аргумент — повторяемый текст, второй — число повторов. Ответ можно вывести, сохранить или добавить к другой строке. str_repeat("ab", 3) вернул бы ababab: три копии целой строки.

<?php
$requests = ['Пн' => 3, 'Вт' => 5, 'Ср' => 0];
foreach ($requests as $day => $count) {
    if ($count < 0 || $count > 20) {
        echo $day, ": число вне диапазона\n";
        continue;
    }
    echo $day, ': ', str_repeat('#', $count), ' (', $count, ")\n";
}

Пн: ### (3)
Вт: ##### (5)
Ср:  (0)

Длина шкалы имеет понятный смысл: один # — одна заявка. При нуле повторов получается пустая строка, но числовая подпись сохраняет ясность. Лимит проверяется до создания строки: число из запроса нельзя бесконтрольно использовать как размер. Отрицательное число повторов вызывает ValueError.

<?php
$code = 'ABCD1234EF56';
$parts = str_split($code, 4);
echo implode('-', $parts), "\n";
echo 'Первая группа: ', $parts[0], "\n";

ABCD-1234-EF56
Первая группа: ABCD

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

<?php
$parts = str_split('Я');
echo 'Кусков по одному байту: ', count($parts), "\n";
foreach ($parts as $byte) {
    echo 'Байт в HEX: ', bin2hex($byte), "\n";
}
echo 'Кусков в пустой строке: ', count(str_split('')), "\n";

Кусков по одному байту: 2
Байт в HEX: d0
Байт в HEX: af
Кусков в пустой строке: 0

Каждый байт по отдельности уже не является полной UTF-8-буквой, поэтому выводим шестнадцатеричную запись, а не повреждённый текст. Для букв используют mb_str_split, для графем — grapheme_str_split. С PHP 8.2 пустая строка даёт пустой массив. Длина куска меньше 1 вызывает ValueError.

<?php
echo strrev('ABCD'), "\n";
echo strrev('LEVEL'), "\n";

DCBA
LEVEL

Функция возвращает новую строку. Она не сортирует, не шифрует и не знает, где в тексте начинаются слова.

<?php
foreach (['LEVEL', 'TOOL'] as $word) {
    echo $word, ': ', strrev($word) === $word ? 'палиндром' : 'не палиндром', "\n";
}
echo 'Байты Я: ', bin2hex('Я'), "\n";
echo 'После strrev: ', bin2hex(strrev('Я')), "\n";

LEVEL: палиндром
TOOL: не палиндром
Байты Я: d0af
После strrev: afd0

Первое применение рассчитано на согласованные ASCII-слова без пробелов. Русская Я занимает D0 AF, разворот создаёт AF D0 — уже неверную UTF-8-последовательность. Для пользовательских слов нужны графемы и отдельно определённые правила регистра, пробелов и нормализации. Поэтому strrev редко является правильным инструментом для переворота подписи на сайте.

<?php
echo chunk_split('ABCDEF', 2, '/'), "\n";
echo implode('/', str_split('ABCDEF', 2)), "\n";

AB/CD/EF/
AB/CD/EF

Длина 2 относится к байтам исходной строки. В первом варианте разделитель есть в конце, во втором — только между элементами. Это разные договоры формата, выбирайте нужный заранее.

<?php
$encoded = base64_encode('REPORT: READY');
$wrapped = chunk_split($encoded, 8, "\r\n");
echo $wrapped;
echo 'После обратного декодирования: ', base64_decode($wrapped, true), "\n";

UkVQT1JU
OiBSRUFE
WQ==
После обратного декодирования: REPORT: READY

Base64 представляет байты ASCII-символами; она не шифрует содержимое. Для наглядности блоки здесь по восемь символов, а не стандартная длина конкретного MIME-формата. Настоящий формат задаёт документация протокола. Вывод в файле содержит CRLF; показанный результат нормализует их как переносы строк. Письмо или запрос этот код не отправляет.

<?php
$text = 'Order ready for pickup';
echo wordwrap($text, 11, "\n"), "\n";

Order ready
for pickup

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

<?php
$code = 'TRACKING123';
echo 'Сохранить код: ', wordwrap($code, 4, '|'), "\n";
echo 'Разрезать код: ', wordwrap($code, 4, '|', true), "\n";

Сохранить код: TRACKING123
Разрезать код: TRAC|KING|123

true разрешает разрезать длинное слово. Для кода отслеживания это может мешать копированию, поэтому требование нужно согласовать. Для русского UTF-8 принудительный байтовый разрез может повредить букву. На веб-странице перенос текста обычно решают средствами CSS, а не вставкой переносов через PHP.

<?php
echo str_increment('A9'), "\n";
echo str_increment('Z'), "\n";

B0
AA

Нужен PHP 8.3+. Кавычки оставляют метку строкой. Алгоритм понимает ASCII-буквы и цифры; длина результата может измениться на границе Z/AA. Исходная переменная сама не обновляется.

<?php
$label = 'A9';
for ($i = 0; $i < 2; $i++) {
    echo 'Полка ', $label, "\n";
    $label = str_increment($label);
}
try {
    str_increment('A-9');
} catch (ValueError) {
    echo "Дефис не входит в эту последовательность\n";
}

Полка A9
Полка B0
Дефис не входит в эту последовательность

for выполняет ровно две итерации; на каждой сначала печатается текущая метка, затем вычисляется соседняя. Пустые и неподходящие строки недопустимы; str_decrement также не может уменьшить некоторые начальные значения вроде A или 0. Для уникальных номеров в параллельных запросах нужен отдельный механизм хранилища, эта функция не резервирует значения.

<?php
echo str_decrement('B0'), "\n";
echo str_decrement('AA'), "\n";

A9
Z

Нужен PHP 8.3+. Кавычки оставляют метку строкой. Алгоритм понимает ASCII-буквы и цифры; длина результата может измениться на границе Z/AA. Исходная переменная сама не обновляется.

<?php
$label = 'B0';
for ($i = 0; $i < 2; $i++) {
    echo 'Полка ', $label, "\n";
    $label = str_decrement($label);
}
try {
    str_decrement('A-9');
} catch (ValueError) {
    echo "Дефис не входит в эту последовательность\n";
}

Полка B0
Полка A9
Дефис не входит в эту последовательность

for выполняет ровно две итерации; на каждой сначала печатается текущая метка, затем вычисляется соседняя. Пустые и неподходящие строки недопустимы; str_decrement также не может уменьшить некоторые начальные значения вроде A или 0. Для уникальных номеров в параллельных запросах нужен отдельный механизм хранилища, эта функция не резервирует значения.

<?php
$letter = chr(65);
echo 'Буква: ', $letter, "\n";
echo 'Размер: ', strlen($letter), " байт\n";

Буква: A
Размер: 1 байт

65 передаётся как целое число, ответ является строкой. chr не превращает произвольный Unicode-код в UTF-8: для такого преобразования есть mb_chr. Рабочий диапазон одного байта — от 0 до 255.

<?php
$brightness = 80;
if ($brightness < 0 || $brightness > 100) {
    throw new InvalidArgumentException('Яркость должна быть от 0 до 100');
}
$packet = chr(2) . chr(16) . chr($brightness) . chr(3);
echo 'Пакет: ', bin2hex($packet), "\n";
echo 'Размер пакета: ', strlen($packet), " байта\n";

Пакет: 02105003
Размер пакета: 4 байта

Учебный договор: 02 — начало, 10 HEX (16 десятичное) — команда яркости, 50 HEX (80 десятичное) — значение, 03 — конец. Точка . соединяет байты. Пример только собирает пакет, не отправляет его и не управляет оборудованием. Настоящий протокол берут из документации устройства; диапазон chr проверяют до вызова, вне 0–255 в PHP 8.5 выдаётся deprecation.

<?php
echo 'Код A: ', ord('A'), "\n";
echo 'Нулевой байт: ', ord("\0"), "\n";

Код A: 65
Нулевой байт: 0

Нулевой байт законен и даёт число 0. В PHP-строке он не обозначает конец строки. В ord передают ровно один байт; пустая строка или целая многобайтовая строка с PHP 8.5 вызывают deprecation.

<?php
$packet = "\x02\x10\x50\x03";
if (strlen($packet) !== 4 || $packet[0] !== "\x02" || $packet[3] !== "\x03") {
    throw new InvalidArgumentException('Повреждён учебный пакет');
}
$command = ord($packet[1]);
$brightness = ord($packet[2]);
if ($command === 16 && $brightness <= 100) {
    echo 'Контроллер сообщил яркость: ', $brightness, "%\n";
} else {
    echo "Неизвестная команда или значение\n";
}

Контроллер сообщил яркость: 80%

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

<?php
$text = "\xEF\xBB\xBFname;stock";
$prefix = substr($text, 0, 3);
echo 'Первые три байта: ', bin2hex($prefix), "\n";
echo 'Обычная буква A: ', bin2hex('A'), "\n";

Первые три байта: efbbbf
Обычная буква A: 41

Запись \xEF в двойных кавычках создаёт один байт с кодом EF. Шестнадцатеричная запись компактно показывает непечатаемые байты. Функция не определяет автоматически формат файла; здесь конкретный известный префикс проверяется нами.

<?php
$header = "\xEF\xBB\xBFname;stock";
$bom = "\xEF\xBB\xBF";
if (str_starts_with($header, $bom)) {
    $header = substr($header, strlen($bom));
}
$columns = explode(';', $header);
echo 'Первая колонка: [', $columns[0], "]\n";
echo 'Вторая колонка: [', $columns[1], "]\n";

Первая колонка: [name]
Вторая колонка: [stock]

Теперь ключ колонки действительно name, а не name с невидимым началом. Снимается только точная последовательность в начале; нельзя удалять любые «странные символы» из всего файла. Для полноценного CSV нужен fgetcsv. Небольшой искусственный образец безопасен для диагностики; не выводите в HEX реальные токены и личные документы.

<?php
$hex = '02105003';
$packet = hex2bin($hex);
echo 'Символов в HEX: ', strlen($hex), "\n";
echo 'Байтов в пакете: ', strlen($packet), "\n";
echo 'Яркость: ', ord($packet[2]), "%\n";

Символов в HEX: 8
Байтов в пакете: 4
Яркость: 80%

Исходник задан автором и корректен. Для внешнего HEX сначала нужны проверки следующего примера. При обратном bin2hex($packet) получим исходную запись в нижнем регистре. Код ничего не отправляет устройству.

<?php
$fields = ['4142', '00', '123', '0x41'];
foreach ($fields as $field) {
    if (strlen($field) > 16 || strlen($field) % 2 !== 0 || !ctype_xdigit($field)) {
        echo $field, ": неверный HEX\n";
        continue;
    }
    $bytes = hex2bin($field);
    if ($bytes === false) {
        echo "Не удалось декодировать\n";
        continue;
    }
    echo $field, ': получено ', strlen($bytes), " байт\n";
}

4142: получено 2 байт
00: получено 1 байт
123: неверный HEX
0x41: неверный HEX

16 символов — выбранный лимит учебного поля, % 2 проверяет чётность, ctype_xdigit — состав. Префикс 0x не входит в допустимый HEX этой функции. Без предварительной проверки ошибочный вход вызвал бы warning и дал false, а не исключение. Пустая строка допустима для hex2bin, но наше поле намеренно требует хотя бы одну цифру.

<?php
$text = 'Status: READY';
$position = stripos($text, 'ready');
if ($position !== false) {
    echo 'Метка найдена в позиции ', $position, "\n";
}

Метка найдена в позиции 8

Метод поиска не меняет текст. Проверка !== false нужна и здесь: слово могло стоять в самом начале и дать 0. Проверять состояние заказа по произвольному комментарию нельзя — пример относится к известной служебной строке; отдельное поле состояния надёжнее.

<?php
$lines = ['ERROR: printer offline', 'info: started', 'Error: paper empty'];
foreach ($lines as $line) {
    if (stripos($line, 'error:') === 0) {
        echo trim(substr($line, 6)), "\n";
    }
}
var_dump(stripos('ERROR', 'missing'));
var_dump(stripos('Я', 'я'));

printer offline
paper empty
bool(false)
bool(false)

=== 0 требует метку в начале, а не в любом месте текста. После неё снимаются ровно шесть байтов error:. Последние проверки показывают отсутствие и ограничение ASCII-регистра. Для UTF-8 есть mb_stripos; реальный структурный журнал разбирают по его формату, а не по слову, случайно встретившемуся в сообщении.

<?php
$path = 'reports/2026/orders.csv';
$position = strrpos($path, '/');
echo 'Папка: ', substr($path, 0, $position), "\n";
echo 'Имя: ', substr($path, $position + 1), "\n";

Папка: reports/2026
Имя: orders.csv

Пример работает с заданной строкой, в которой разделитель известен. Это разбор текста с прямыми слешами, а не универсальный разбор Windows/Linux-путей. Для файловых путей сравните dirname, basename и pathinfo; отдельно решайте, какие папки разрешено читать.

<?php
foreach (['reports/orders.csv', 'orders.csv'] as $path) {
    $position = strrpos($path, '/');
    $name = $position === false ? $path : substr($path, $position + 1);
    echo $name, "\n";
}
echo 'Последнее совпадение: ', strrpos('AB|ab|AB', 'AB'), "\n";
echo 'Искать не правее позиции 5: ', strrpos('AB|ab|AB', 'AB', -3), "\n";

orders.csv
orders.csv
Последнее совпадение: 6
Искать не правее позиции 5: 0

Выражение условие ? значение1 : значение2 выбирает результат в зависимости от наличия разделителя. Отрицательное смещение у поиска последнего вхождения задаёт крайнюю позицию начала совпадения справа: это не просто запуск обычного поиска с этой позиции. Позиции всегда байтовые; выход смещения за диапазон — ValueError.

<?php
$path = 'reports/2026/orders.csv';
$position = strripos($path, '/');
echo 'Папка: ', substr($path, 0, $position), "\n";
echo 'Имя: ', substr($path, $position + 1), "\n";

Папка: reports/2026
Имя: orders.csv

Пример работает с заданной строкой, в которой разделитель известен. Это разбор текста с прямыми слешами, а не универсальный разбор Windows/Linux-путей. Для файловых путей сравните dirname, basename и pathinfo; отдельно решайте, какие папки разрешено читать.

<?php
foreach (['reports/orders.csv', 'orders.csv'] as $path) {
    $position = strripos($path, '/');
    $name = $position === false ? $path : substr($path, $position + 1);
    echo $name, "\n";
}
echo 'Последнее совпадение: ', strripos('AB|ab|AB', 'ab'), "\n";
echo 'Искать не правее позиции 5: ', strripos('AB|ab|AB', 'ab', -3), "\n";

orders.csv
orders.csv
Последнее совпадение: 6
Искать не правее позиции 5: 3

Выражение условие ? значение1 : значение2 выбирает результат в зависимости от наличия разделителя. Отрицательное смещение у поиска последнего вхождения задаёт крайнюю позицию начала совпадения справа: это не просто запуск обычного поиска с этой позиции. Позиции всегда байтовые; выход смещения за диапазон — ValueError.

<?php
$record = 'delivery=pickup';
echo 'От совпадения: [', strstr($record, '='), "]\n";
echo 'До совпадения: [', strstr($record, '=', true), "]\n";

От совпадения: [=pickup]
До совпадения: [delivery]

Третий аргумент true меняет сторону извлечения. Сам разделитель включён в хвост и не включён в начало. Квадратные скобки показывают оставшиеся пробелы. Исходный текст не меняется.

<?php
foreach (['delivery=pickup', 'unknown'] as $record) {
    $tail = strstr($record, '=');
    if ($tail === false) {
        echo "Нужное поле не найдено\n";
        continue;
    }
    echo 'Значение: ', substr($tail, strlen('=')), "\n";
}

Значение: pickup
Нужное поле не найдено

false означает отсутствие совпадения. От пустой строки его отличают строго: пустое начало перед совпадением может быть нормальным результатом. strlen метки задаёт число пропускаемых байтов. Для нескольких полей key=value часто удобнее explode с limit=2; для формального протокола используйте его парсер. Пустой needle разрешён с PHP 8 и имеет отдельное поведение, описанное в договоре.

<?php
$record = 'delivery=pickup';
echo 'От совпадения: [', strchr($record, '='), "]\n";
echo 'До совпадения: [', strchr($record, '=', true), "]\n";

От совпадения: [=pickup]
До совпадения: [delivery]

Третий аргумент true меняет сторону извлечения. Сам разделитель включён в хвост и не включён в начало. Квадратные скобки показывают оставшиеся пробелы. Исходный текст не меняется.

<?php
foreach (['delivery=pickup', 'unknown'] as $record) {
    $tail = strchr($record, '=');
    if ($tail === false) {
        echo "Нужное поле не найдено\n";
        continue;
    }
    echo 'Значение: ', substr($tail, strlen('=')), "\n";
}

Значение: pickup
Нужное поле не найдено

false означает отсутствие совпадения. От пустой строки его отличают строго: пустое начало перед совпадением может быть нормальным результатом. strlen метки задаёт число пропускаемых байтов. Для нескольких полей key=value часто удобнее explode с limit=2; для формального протокола используйте его парсер. Пустой needle разрешён с PHP 8 и имеет отдельное поведение, описанное в договоре.

<?php
$record = 'Order 42; STATUS:ready';
echo 'От совпадения: [', stristr($record, 'status:'), "]\n";
echo 'До совпадения: [', stristr($record, 'status:', true), "]\n";

От совпадения: [STATUS:ready]
До совпадения: [Order 42; ]

Третий аргумент true меняет сторону извлечения. Сам разделитель включён в хвост и не включён в начало. Квадратные скобки показывают оставшиеся пробелы. Исходный текст не меняется.

<?php
foreach (['Order 42; STATUS:ready', 'unknown'] as $record) {
    $tail = stristr($record, 'status:');
    if ($tail === false) {
        echo "Нужное поле не найдено\n";
        continue;
    }
    echo 'Значение: ', substr($tail, strlen('status:')), "\n";
}

Значение: ready
Нужное поле не найдено

false означает отсутствие совпадения. От пустой строки его отличают строго: пустое начало перед совпадением может быть нормальным результатом. strlen метки задаёт число пропускаемых байтов. Для нескольких полей key=value часто удобнее explode с limit=2; для формального протокола используйте его парсер. Пустой needle разрешён с PHP 8 и имеет отдельное поведение, описанное в договоре.

<?php
$name = 'archive.stock.csv';
echo 'Последний суффикс: ', strrchr($name, '.'), "\n";
echo 'До последней точки: ', strrchr($name, '.', true), "\n";

Последний суффикс: .csv
До последней точки: archive.stock

Второй вывод использует before_needle, доступный с PHP 8.3. Для разбора настоящего файлового пути обычно удобнее pathinfo; здесь изучается ровно операция над строкой.

<?php
foreach (['report.csv', 'README'] as $name) {
    $suffix = strrchr($name, '.csv');
    echo $name, ': ', $suffix === false ? 'нет точки' : $suffix, "\n";
}
echo strrchr('report.txt', '.csv'), "\n";

report.csv: .csv
README: нет точки
.txt

Передача .csv не заставляет искать .csv целиком: берётся только первый байт — точка. Поэтому report.txt тоже даёт результат. Используйте str_ends_with для проверки точного суффикса. Пустой needle у strrchr ищет NUL, а не любую пустую границу; Unicode-разделитель также не обрабатывается целой буквой.

<?php
$record = 'TOOL-42;8,main';
$tail = strpbrk($record, ',;');
echo 'Хвост: ', $tail, "\n";
echo 'Сам разделитель: ', $tail[0], "\n";

Хвост: ;8,main
Сам разделитель: ;

В известной строке разделитель есть. [0] читает первый байт возвращённого хвоста. Маска ,; — набор, а не двухсимвольная последовательность. Диапазоны вида a-z здесь не задаются.

<?php
foreach (['TOOL-42', 'TOOL-42;TAPE-8', ''] as $code) {
    if ($code === '') {
        echo "Код не указан\n";
    } elseif (strpbrk($code, ',;') !== false) {
        echo "Передайте один код, а не список\n";
    } else {
        echo 'Принят один код: ', $code, "\n";
    }
}

Принят один код: TOOL-42
Передайте один код, а не список
Код не указан

Отсутствие разделителей — только одно правило нашего поля. Допустимый алфавит, длина и существование товара проверяются отдельно. Пустой второй аргумент самой strpbrk вызывает ValueError, поэтому набор разделителей задаёт программа.

<?php
$batch = '123-PAINT';
$length = strspn($batch, '0123456789');
echo 'Длина цифрового префикса: ', $length, "\n";
echo 'Префикс: ', substr($batch, 0, $length), "\n";

Длина цифрового префикса: 3
Префикс: 123

Набор перечисляет каждый допустимый байт. Запись 0-9 не означает диапазон в этой функции. strspn не превращает префикс в число и не подтверждает правильность остальной части кода.

<?php
foreach (['0', '123', '12kg', ''] as $quantity) {
    $allDigits = $quantity !== '' && strspn($quantity, '0123456789') === strlen($quantity);
    echo '[', $quantity, ']: ', $allDigits ? 'только цифры' : 'не подходит', "\n";
}

[0]: только цифры
[123]: только цифры
[12kg]: не подходит
[]: не подходит

Разрешённый префикс должен занимать всю непустую строку. Так не принимаются 12kg и пустота, но сохраняется 0. Для такой проверки также подходит ctype_digit. Допустимый диапазон количества и защита от переполнения при преобразовании — отдельный шаг.

<?php
$record = 'TOOL-42;8,main';
$length = strcspn($record, ',;');
echo 'Длина первого поля: ', $length, "\n";
echo 'Код: ', substr($record, 0, $length), "\n";

Длина первого поля: 7
Код: TOOL-42

Набор состоит из отдельных байтов. Длина возвращается числом, хвост не создаётся. Для самого хвоста подходит strpbrk. Это простая служебная запись без CSV-кавычек.

<?php
foreach (['TOOL-42', ';8', 'TOOL-42,8'] as $record) {
    $first = substr($record, 0, strcspn($record, ',;'));
    echo '[', $first, "]\n";
}

[TOOL-42]
[]
[TOOL-42]

При отсутствии запрещённого байта длина равна размеру всей строки; если он первый, длина 0. Это нормальные ответы, а не false. Строковые поля с кавычками и вложенной структурой нужно разбирать специализированным парсером. Дополнительные start/length ограничивают выбранный участок по правилам таблицы параметров.

<?php
$template = 'Заказ {order}. При получении назовите номер {order}.';
echo 'Мест для номера: ', substr_count($template, '{order}'), "\n";
echo 'Мест для имени: ', substr_count($template, '{name}'), "\n";

Мест для номера: 2
Мест для имени: 0

Оба аргумента — строки, а ответ — число. Если важен просто факт наличия, str_contains точнее выражает задачу. Поиск чувствителен к регистру.

<?php
echo 'В aaaa пар aa: ', substr_count('aaaa', 'aa'), "\n";
echo 'Только в теле: ', substr_count('head:ERR|body:ERR ERR', 'ERR', 9), "\n";
echo 'В первых 8 байтах: ', substr_count('head:ERR|body:ERR ERR', 'ERR', 0, 8), "\n";

В aaaa пар aa: 2
Только в теле: 2
В первых 8 байтах: 1

После найденного aa поиск продолжается после него, поэтому не считает перекрывающуюся пару с середины. offset и length выбирают байтовый участок. Пустой needle и недопустимые границы вызывают ValueError. Для смыслового подсчёта событий журнала сначала разберите записи: ERR может оказаться частью другого слова.

<?php
$record = 'ID:READY:42';
if (substr_compare($record, 'READY', 3, 5) === 0) {
    echo "В записи указана готовность\n";
}

В записи указана готовность

Аргументы — исходная строка, сравниваемая строка, начальная позиция и длина. Ответ использует знак порядка как strcmp; для совпадения сравнивайте с нулём. Формат записи должен быть известен заранее.

<?php
$file = 'report.CSV';
echo substr_compare($file, '.csv', -4, 4) === 0 ? "Совпало\n" : "Регистр различается\n";
echo substr_compare($file, '.csv', -4, 4, true) === 0 ? "Суффикс совпал без ASCII-регистра\n" : "Не совпал\n";

Регистр различается
Суффикс совпал без ASCII-регистра

Отрицательная позиция отсчитывается от конца. Пятый аргумент true включает ASCII-сравнение без регистра. При точной проверке суффикса проще str_ends_with. Суффикс имени не доказывает формат содержимого файла и не заменяет проверку загружаемого файла.

<?php
$left = 'photo2.jpg';
$right = 'photo10.jpg';
$order = strcmp($left, $right);
if ($order < 0) {
    echo $left, ' раньше ', $right, "\n";
} elseif ($order > 0) {
    echo $right, ' раньше ', $left, "\n";
} else {
    echo "Строки равны по этому правилу\n";
}

photo10.jpg раньше photo2.jpg

Отрицательный результат означает «левое раньше правого», ноль — равенство, положительный — наоборот. Программа использует знак, а не конкретное значение вроде -1. Равенство по правилу без учёта регистра не означает совпадение исходных байтов.

<?php
$files = ['photo10.jpg', 'photo2.jpg', 'photo1.jpg'];
usort($files, 'strcmp');
echo implode("\n", $files), "\n";
echo strcmp('READY', 'ready') === 0 ? "Регистр не различён\n" : "Регистр различён\n";

photo1.jpg
photo10.jpg
photo2.jpg
Регистр различён

В usort передаётся имя функции строкой: PHP сам вызывает её для сравнения пар при сортировке. Самостоятельно обходить все пары не нужно. usort меняет порядок массива и переиндексирует числовые ключи. Для сохранения ключей есть uasort. Локализованный порядок русских слов и имён требует Collator, а не ASCII-сравнения.

<?php
$left = 'photo2.jpg';
$right = 'photo10.jpg';
$order = strcasecmp($left, $right);
if ($order < 0) {
    echo $left, ' раньше ', $right, "\n";
} elseif ($order > 0) {
    echo $right, ' раньше ', $left, "\n";
} else {
    echo "Строки равны по этому правилу\n";
}

photo10.jpg раньше photo2.jpg

Отрицательный результат означает «левое раньше правого», ноль — равенство, положительный — наоборот. Программа использует знак, а не конкретное значение вроде -1. Равенство по правилу без учёта регистра не означает совпадение исходных байтов.

<?php
$files = ['photo10.jpg', 'photo2.jpg', 'photo1.jpg'];
usort($files, 'strcasecmp');
echo implode("\n", $files), "\n";
echo strcasecmp('READY', 'ready') === 0 ? "Регистр не различён\n" : "Регистр различён\n";

photo1.jpg
photo10.jpg
photo2.jpg
Регистр не различён

В usort передаётся имя функции строкой: PHP сам вызывает её для сравнения пар при сортировке. Самостоятельно обходить все пары не нужно. usort меняет порядок массива и переиндексирует числовые ключи. Для сохранения ключей есть uasort. Локализованный порядок русских слов и имён требует Collator, а не ASCII-сравнения.

<?php
$message = 'READY:42';
if (strncmp($message, 'READY:', 6) === 0) {
    echo 'Готов заказ ', substr($message, 6), "\n";
}

Готов заказ 42

Третий аргумент ограничивает сравнение шестью байтами, включая :. Ноль означает совпадение этого участка. Для чувствительной к регистру проверки начала в PHP 8+ выразительнее str_starts_with; ограниченное сравнение полезно при работе с существующим протоколом или кодом.

<?php
echo strncmp('READY:42', 'READY:99', 6) === 0 ? "Префикс совпадает\n" : "Префикс различается\n";
echo strncmp('READY:42', 'READY:99', 8) === 0 ? "Вся строка совпадает\n" : "Номера различаются\n";
echo strncmp('A', 'B', 0) === 0 ? "Ноль байтов всегда совпадает\n" : "Различается\n";

Префикс совпадает
Номера различаются
Ноль байтов всегда совпадает

Нулевая длина не проверяет ничего и даёт равенство. Отрицательная длина вызывает ValueError. Позиции относятся к байтам, а не русским буквам. Если длина берётся извне, сначала проверяйте её смысл; нельзя превращать пустой критерий в разрешение доступа.

<?php
$message = 'READY:42';
if (strncasecmp($message, 'ready:', 6) === 0) {
    echo 'Готов заказ ', substr($message, 6), "\n";
}

Готов заказ 42

Третий аргумент ограничивает сравнение шестью байтами, включая :. Ноль означает совпадение этого участка. Для чувствительной к регистру проверки начала в PHP 8+ выразительнее str_starts_with; ограниченное сравнение полезно при работе с существующим протоколом или кодом.

<?php
echo strncasecmp('READY:42', 'READY:99', 6) === 0 ? "Префикс совпадает\n" : "Префикс различается\n";
echo strncasecmp('READY:42', 'READY:99', 8) === 0 ? "Вся строка совпадает\n" : "Номера различаются\n";
echo strncasecmp('A', 'B', 0) === 0 ? "Ноль байтов всегда совпадает\n" : "Различается\n";

Префикс совпадает
Номера различаются
Ноль байтов всегда совпадает

Нулевая длина не проверяет ничего и даёт равенство. Отрицательная длина вызывает ValueError. Позиции относятся к байтам, а не русским буквам. Если длина берётся извне, сначала проверяйте её смысл; нельзя превращать пустой критерий в разрешение доступа.

<?php
$left = 'photo2.jpg';
$right = 'photo10.jpg';
$order = strnatcmp($left, $right);
if ($order < 0) {
    echo $left, ' раньше ', $right, "\n";
} elseif ($order > 0) {
    echo $right, ' раньше ', $left, "\n";
} else {
    echo "Строки равны по этому правилу\n";
}

photo2.jpg раньше photo10.jpg

Отрицательный результат означает «левое раньше правого», ноль — равенство, положительный — наоборот. Программа использует знак, а не конкретное значение вроде -1. Равенство по правилу без учёта регистра не означает совпадение исходных байтов.

<?php
$files = ['photo10.jpg', 'photo2.jpg', 'photo1.jpg'];
usort($files, 'strnatcmp');
echo implode("\n", $files), "\n";
echo strnatcmp('READY', 'ready') === 0 ? "Регистр не различён\n" : "Регистр различён\n";

photo1.jpg
photo2.jpg
photo10.jpg
Регистр различён

В usort передаётся имя функции строкой: PHP сам вызывает её для сравнения пар при сортировке. Самостоятельно обходить все пары не нужно. usort меняет порядок массива и переиндексирует числовые ключи. Для сохранения ключей есть uasort. Локализованный порядок русских слов и имён требует Collator, а не ASCII-сравнения.

<?php
$left = 'photo2.jpg';
$right = 'photo10.jpg';
$order = strnatcasecmp($left, $right);
if ($order < 0) {
    echo $left, ' раньше ', $right, "\n";
} elseif ($order > 0) {
    echo $right, ' раньше ', $left, "\n";
} else {
    echo "Строки равны по этому правилу\n";
}

photo2.jpg раньше photo10.jpg

Отрицательный результат означает «левое раньше правого», ноль — равенство, положительный — наоборот. Программа использует знак, а не конкретное значение вроде -1. Равенство по правилу без учёта регистра не означает совпадение исходных байтов.

<?php
$files = ['photo10.jpg', 'photo2.jpg', 'photo1.jpg'];
usort($files, 'strnatcasecmp');
echo implode("\n", $files), "\n";
echo strnatcasecmp('READY', 'ready') === 0 ? "Регистр не различён\n" : "Регистр различён\n";

photo1.jpg
photo2.jpg
photo10.jpg
Регистр не различён

В usort передаётся имя функции строкой: PHP сам вызывает её для сравнения пар при сортировке. Самостоятельно обходить все пары не нужно. usort меняет порядок массива и переиндексирует числовые ключи. Для сохранения ключей есть uasort. Локализованный порядок русских слов и имён требует Collator, а не ASCII-сравнения.

<?php
$names = ['Кисть', 'Валик', 'Лента'];
echo join(', ', $names), "\n";
echo implode(', ', $names), "\n";

Кисть, Валик, Лента
Кисть, Валик, Лента

Первый аргумент — разделитель, второй — массив значений. Оба вызова возвращают строку, а echo выводит её. Ключи массива в подпись не входят. Исторический обратный порядок аргументов в PHP 8 не поддерживается.

<?php
$lines = ['Заказ 42', 'Кисть — 2 шт.', 'Выдача: завтра'];
$receipt = join("\n", $lines);
echo $receipt, "\n";
echo 'Пустой список: [', join(', ', []), "]\n";

Заказ 42
Кисть — 2 шт.
Выдача: завтра
Пустой список: []

\n в двойных кавычках означает перенос строки. Так можно подготовить тело текстового уведомления. Функция не отправляет письмо и не сериализует CSV: если разделитель может встречаться внутри значения, для формата нужен соответствующий кодировщик.

<?php
$text = 'READY: order 42; ready: order 43';
$count = 0;
$updated = str_ireplace('ready', 'Available', $text, $count);
echo $updated, "\n";
echo 'Заменено меток: ', $count, "\n";

Available: order 42; Available: order 43
Заменено меток: 2

Первые три аргумента — что найти, замена и исходный текст. Четвёртый получает число замен. Это точная подстрока без проверки границ слова: ready заменилось бы и внутри already. Для состояния заказа лучше отдельное поле, чем анализ произвольного комментария.

<?php
echo str_ireplace(['DRAFT', 'READY'], ['READY', 'SENT'], 'draft ready'), "\n";
echo str_ireplace('КИСТЬ', 'Валик', 'кисть широкая'), "\n";

SENT SENT
кисть широкая

Массив поиска обрабатывается последовательно: DRAFT становится READY, затем тоже SENT. Вставленные значения могут попасть под следующую замену. Для независимых меток лучше карта strtr. С PHP 8.2 игнорируется только ASCII-регистр; для русскоязычного поиска сначала выбирают подходящий Unicode-инструмент.

<?php
$entered = 'save10';
$code = strtoupper($entered);
echo 'Ищем промокод: ', $code, "\n";

Ищем промокод: SAVE10

Канонический вид — выбранная одинаковая запись значения. strtoupper меняет ASCII-буквы, а не проверяет наличие кода и право на скидку.

<?php
$promotions = ['SAVE10' => 'Скидка 10%'];
$entered = '  Save10  ';
$code = strtoupper(trim($entered));
echo $promotions[$code] ?? 'Промокод не найден', "\n";
echo strtoupper('скидка'), "\n";

Скидка 10%
скидка

Сначала trim нормализует оговорённые пробелы, затем strtoupper — регистр. ?? даёт запасной текст при отсутствии ключа. Срок действия, совместимость скидок и количество применений — отдельные проверки. Пароли и чувствительные к регистру токены так не нормализуют. Для русских букв нужен mb_strtoupper.

<?php
$field = 'OrderStatus';
echo lcfirst($field), "\n";
echo lcfirst(' OrderStatus'), "\n";

orderStatus
 OrderStatus

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

<?php
$names = ['OrderStatus', 'DeliveryDate'];
foreach ($names as $field) {
    echo lcfirst($field), "\n";
}
echo lcfirst('язык'), "\n";

orderStatus
deliveryDate
язык

Сценарий относится к вашим техническим ASCII-именам. PHP-имя класса или свойства нельзя без проверки строить из произвольного пользовательского текста. Unicode-регистр этим вызовом не обрабатывается.

<?php
$field = 'orderStatus';
echo ucfirst($field), "\n";
echo ucfirst(' orderStatus'), "\n";

OrderStatus
 orderStatus

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

<?php
$names = ['orderStatus', 'deliveryDate'];
foreach ($names as $field) {
    echo ucfirst($field), "\n";
}
echo ucfirst('язык'), "\n";

OrderStatus
DeliveryDate
язык

Сценарий относится к вашим техническим ASCII-именам. PHP-имя класса или свойства нельзя без проверки строить из произвольного пользовательского текста. Unicode-регистр этим вызовом не обрабатывается.

<?php
echo ucwords('paint tools'), "\n";
echo ucwords('PAINT tools'), "\n";
echo ucwords('кисть широкая'), "\n";

Paint Tools
PAINT Tools
кисть широкая

Остальные буквы слова не переводятся в нижний регистр. Русские буквы не преобразуются: функция работает с ASCII. Для текста на естественном языке выбирайте Unicode-инструменты и редакторское правило, а не автоматически «исправляйте» имена людей.

<?php
echo ucwords('water-based paint', ' -'), "\n";
echo ucwords(strtolower('PAINT TOOLS')), "\n";

Water-Based Paint
Paint Tools

Второй аргумент — набор отдельных байтов-разделителей: здесь пробел и дефис. Во второй строке нижний регистр задаётся отдельной операцией, потому что ucwords не делает этого сама. Такое преобразование применимо к заранее согласованным ASCII-рубрикам, но может испортить аббревиатуры.

<?php
$title = 'Steel bolt';
echo 'Слов: ', str_word_count($title), "\n";
$words = str_word_count($title, 1);
echo 'Первое: ', $words[0], "\n";
echo 'Второе: ', $words[1], "\n";

Слов: 2
Первое: Steel
Второе: bolt

Без второго аргумента функция возвращает число. При 1 возвращается массив; [0] и [1] выбирают его элементы. Пример использует ASCII и стандартное начальное окружение C. Это не универсальный счётчик слов любого языка: классификация зависит от локали и не поддерживает многобайтовую локаль.

<?php
$text = 'Steel bolt ready';
foreach (str_word_count($text, 2) as $offset => $word) {
    echo 'Позиция ', $offset, ': ', $word, "\n";
}
echo 'Обычное правило: ', implode(' / ', str_word_count('Bolt M10 ready', 1)), "\n";
echo 'Разрешены цифры: ', implode(' / ', str_word_count('Bolt M10 ready', 1, '0..9')), "\n";

Позиция 0: Steel
Позиция 6: bolt
Позиция 11: ready
Обычное правило: Bolt / M / ready
Разрешены цифры: Bolt / M10 / ready

В режиме 2 ключ — место начала слова в байтах. Дополнительный набор 0..9 разрешает цифры внутри выбранного понятия «слово», поэтому M10 не теряет 10. Это всё ещё не проверка артикула: бизнес-правила и поиск товара выполняются отдельно. Для Unicode-границ слов рассмотрите IntlBreakIterator.

<?php
echo strtok('КИСТЬ,ВАЛИК', ','), "\n";
echo strtok(','), "\n";
$next = strtok(',');
if ($next === false) {
    echo "Все коды прочитаны\n";
}

КИСТЬ
ВАЛИК
Все коды прочитаны

Во второй вызов исходная строка не передаётся: функция продолжает прошлый разбор. false означает конец, а не пустой код. Разделитель здесь один ASCII-байт; кириллические слова остаются целыми, потому что их байты не входят в набор разделителей.

<?php
$text = ' КИСТЬ,,ВАЛИК;0 ';
$code = strtok($text, ' ,;');
while ($code !== false) {
    echo 'Код: ', $code, "\n";
    $code = strtok(' ,;');
}

Код: КИСТЬ
Код: ВАЛИК
Код: 0

Каждый символ второго аргумента — отдельный разделитель. Повторные разделители пропускаются. while повторяет тело до false; проверка по истинности ошибочно остановилась бы на строке "0". Для таблицы, где пустое поле значимо, этот разбор не подходит; explode сохраняет пустые поля, CSV разбирают str_getcsv.

<?php
echo strtok('КИСТЬ,ВАЛИК', ','), "\n";
echo strtok('склад|магазин', '|'), "\n";
echo strtok('|'), "\n";
if (strtok(',') === false) {
    echo "Продолжения списка товаров больше нет\n";
}

КИСТЬ
склад
магазин
Продолжения списка товаров больше нет

Второй двухаргументный вызов заменил внутреннее состояние. ВАЛИК потерялся для продолжения, хотя исходный текст не менялся. Для независимых или вложенных разборов удобнее получить массив explode/preg_split и хранить его в собственной переменной.

<?php
$events = 'ABBAA';
$counts = count_chars($events, 1);
echo 'Событий A: ', $counts[ord('A')], "\n";
echo 'Событий B: ', $counts[ord('B')], "\n";

Событий A: 3
Событий B: 2

Режим 1 оставляет только встреченные байты. Ключи массива — их числовые коды; ord("A") даёт 65. В этом примере наличие A и B видно во входе. Для произвольного журнала отсутствующий код читают через ?? 0.

<?php
$events = 'AABXBA';
foreach (count_chars($events, 1) as $byte => $count) {
    echo 'Код ', chr($byte), ': ', $count, "\n";
}
echo 'Набор кодов: ', count_chars($events, 3), "\n";

Код A: 3
Код B: 2
Код X: 1
Набор кодов: ABX

Так диагностический отчёт обнаруживает неожиданный X, который можно сопоставить с документацией устройства. Режим 3 возвращает каждый байт один раз в порядке его кода. Для неизвестного бинарного ввода печатайте bin2hex(chr($byte)), иначе управляющие байты повлияют на терминал.

<?php
$source = 'BOLT';
foreach (['TOBL', 'TOOL'] as $answer) {
    $same = count_chars($source, 1) === count_chars($answer, 1);
    echo $answer, ': ', $same ? 'буквы совпали' : 'состав отличается', "\n";
}
echo 'Всего возможных байтов: ', count(count_chars('AB', 0)), "\n";
echo 'Отсутствующих байтов: ', count(count_chars('AB', 2)), "\n";
echo 'Размер строки отсутствующих байтов: ', strlen(count_chars('AB', 4)), "\n";

TOBL: буквы совпали
TOOL: состав отличается
Всего возможных байтов: 256
Отсутствующих байтов: 254
Размер строки отсутствующих байтов: 254

Важно количество каждой буквы, а не только набор: TOOL имеет лишнюю O и не имеет B. Эта проверка ещё не доказывает, что ответ является словом. Последние строки показывают режимы 0, 2 и 4; строку отсутствующих байтов не выводим напрямую, потому что она содержит управляющие значения.

<?php
mt_srand(42);
$word = 'BOLT';
$puzzle = str_shuffle($word);
echo 'Задание: ', $puzzle, "\n";
echo 'Ответ: ', $word, "\n";

Задание: OBTL
Ответ: BOLT

mt_srand(42) фиксирует начало псевдослучайной последовательности только для повторения учебного результата в используемом PHP 8.5. В игре эту строку убирают: перестановка тогда может отличаться, а иногда совпадёт с исходным словом. Seed влияет на общий генератор процесса, поэтому не устанавливайте его внутри библиотечной функции. str_shuffle не меняет $word.

<?php
$word = 'BOLT';
foreach ([' bolt ', 'TOOL'] as $entered) {
    $answer = strtoupper(trim($entered));
    if ($answer === $word) {
        echo "Верно: BOLT означает болт\n";
    } else {
        echo 'Попробуйте ещё: ', $answer, "\n";
    }
}

Верно: BOLT означает болт
Попробуйте ещё: TOOL

Это продолжение головоломки: trim убирает крайние пробелы, strtoupper нормализует ASCII-регистр, === проверяет точный ответ. Перемешанный вариант предназначен для показа, а правильное слово хранится отдельно. Для нового кода Random\Randomizer изолирует состояние генератора; для секретов нужны random_bytes/random_int или Secure engine, а не str_shuffle.

<?php
$encoded = str_rot13('BOLT-41');
echo $encoded, "\n", str_rot13($encoded), "\n";

OBYG-41
BOLT-41

Одна функция выполняет оба направления, потому что два сдвига по 13 дают полный латинский алфавит из 26 букв.

<?php
$answer = 'steel bolt / болт';
$spoiler = str_rot13($answer);
echo $spoiler, "\n";
var_dump(str_rot13($spoiler) === $answer);

fgrry obyg / болт
bool(true)

Русское слово осталось видимым. Модель годится для соглашения о спойлерах в ASCII-тексте; для конфиденциальности она не годится даже с дополнительным Base64.

<?php
$name = "O'Neil";
$stored = addslashes($name);
echo 'Имя: ', $name, "\n";
echo 'Старое представление: ', $stored, "\n";

Имя: O'Neil
Старое представление: O\'Neil

Двойные кавычки в PHP-коде позволяют записать одинарную без дополнительного экранирования самого кода. Обратная черта в $stored — реальный добавленный байт. $name не изменился. Функция также обрабатывает двойную кавычку, обратную черту и NUL.

<?php
$original = "A\0B\\C";
$stored = addslashes($original);
$restored = stripslashes($stored);
echo 'Записано: ', $stored, "\n";
echo 'Восстановленные байты: ', bin2hex($restored), "\n";
echo $restored === $original ? "Исходные байты сохранены\n" : "Данные изменились\n";

Записано: A\0B\\C
Восстановленные байты: 4100425c43
Исходные байты сохранены

NUL является байтом 00, а не окончанием PHP-строки. Для наглядности восстановленные данные показаны в HEX. Парная операция уместна потому, что формат точно известен. Для SQL применяют параметры prepare/execute, для HTML — htmlspecialchars, для JSON — json_encode. Переносить сюда addslashes нельзя.

<?php
$stored = "O\\'Neil";
$name = stripslashes($stored);
echo 'В хранилище: ', $stored, "\n";
echo 'Имя: ', $name, "\n";

В хранилище: O\'Neil
Имя: O'Neil

Две черты внутри двойных кавычек PHP создают одну настоящую черту в строке. Функция получает уже это значение, а не текст исходного PHP-файла. Современные $_POST и записи базы не нуждаются в автоматическом stripslashes: старые magic_quotes удалены ещё в PHP 5.4.

<?php
$path = 'C:\temp\report.txt';
echo 'Исходный путь: ', $path, "\n";
echo 'После stripslashes: ', stripslashes($path), "\n";
echo 'Строка с буквальным n: ', stripslashes('\n'), "\n";

Исходный путь: C:\temp\report.txt
После stripslashes: C:tempreport.txt
Строка с буквальным n: n

Обратные черты были частью пути, а не служебным слоем. Функция не может сама определить происхождение строки. Последний вызов оставляет букву n: stripslashes не является C-декодером переводов строк, для такого отдельного договора существует stripcslashes.

<?php
$record = "Кисть\t12\n";
$visible = addcslashes($record, "\t\n");
echo 'Получено: ', $visible, "\n";

Получено: Кисть\t12\n

\t и \n внутри двойных кавычек исходного кода создают настоящие управляющие байты. Результат содержит уже два печатных символа на каждый из них: черту и букву. Так легче увидеть, почему поле неожиданно переносится. Сам журнал может содержать чувствительные данные — кодирование не делает их публичными.

<?php
$raw = "A\0B\tC\n";
$visible = addcslashes($raw, "\0..\37\\");
echo 'Диагностика: ', $visible, "\n";
echo 'После обратного разбора: ', bin2hex(stripcslashes($visible)), "\n";
echo 'Опасная буквенная маска: ', addcslashes('name', 'a..z'), "\n";

Диагностика: A\000B\tC\n
После обратного разбора: 41004209430a
Опасная буквенная маска: \n\a\m\e

Диапазон \0..\37 задаёт байты от 0 до 31 в восьмеричной записи; также выбрана обратная черта. Произвольная буквенная маска опасна: добавив черту к n, вы создадите последовательность, которая при обратном разборе станет переносом. Это не экранирование для SQL, HTML или shell.

<?php
$encoded = 'Кисть\nВалик';
echo 'До: ', $encoded, "\n";
echo "После:\n", stripcslashes($encoded), "\n";

До: Кисть\nВалик
После:
Кисть
Валик

Одинарные кавычки PHP сохраняют \n как два обычных символа. Именно функция создаёт LF. В консоли он виден как новая строка; при выводе обычного HTML перенос сам по себе не создаёт <br>. Для HTML используют нужную разметку после экранирования текста.

<?php
$encoded = '\x42\12241';
echo 'Полученный код: ', stripcslashes($encoded), "\n";
$packet = stripcslashes('BR41\0qty=12\r\n');
echo 'Байты пакета: ', bin2hex($packet), "\n";

Полученный код: BR41
Байты пакета: 42523431007174793d31320d0a

\x42 — шестнадцатеричная B, \122 — восьмеричная R. Это байты, а не универсальная запись Unicode-кодовых точек. Пакет содержит NUL и CRLF, поэтому показан в HEX. Для JSON вызывают json_decode; для addslashes-слоя — stripslashes. У каждой записи свой синтаксис.

<?php
echo quotemeta('bolt(4)+washer.txt'), "\n";
echo quotemeta('a|b{2}/c'), "\n";
var_dump(quotemeta(''));

bolt\(4\)\+washer\.txt
a|b{2}/c
string(0) ""

Второй вывод специально содержит символы, которые не были защищены. Нельзя переносить договор quotemeta на весь синтаксис PCRE.

<?php
$label = 'bolt(4)|washer';
$pattern = '~' . preg_quote($label, '~') . '~';
var_dump(preg_match($pattern, 'item: bolt(4)|washer') === 1);
var_dump(preg_match($pattern, 'item: bolt(4)') === 1);

bool(true)
bool(false)

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

<?php
$quantity = 2;
echo 'Количество: ', $quantity, "\n";

Количество: 2

echo — конструкция языка. После неё перечислены три части: подпись в кавычках, переменная без кавычек и перенос \n. Запятые отделяют части, точка с запятой завершает команду. echo не добавляет ни пробелов, ни переносов самостоятельно.

<?php
$quantity = 2;
echo 'Было: ', $quantity, "\n";
$quantity = $quantity + 1;
echo 'Стало: ', $quantity, "\n";
echo 'Заказ ', 42, ': готов', "\n";

Было: 2
Стало: 3
Заказ 42: готов

Программа выполняется сверху вниз. В каждом месте echo читает текущее значение переменной. Ранее выведенная строка не обновляется, когда переменная меняется. Для построения строки без немедленного вывода используют соединение точкой или sprintf.

<?php
$name = 'Кисть <Pro> & валик';
$quantity = 2;
echo '<p>Товар: ', htmlspecialchars($name, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'), "</p>\n";
echo '<p>Количество: ', $quantity, "</p>\n";

<p>Товар: Кисть &lt;Pro&gt; &amp; валик</p>
<p>Количество: 2</p>

Авторские <p> создают абзацы. Название проходит htmlspecialchars, чтобы <Pro> отображалось буквальным текстом. Число в этом примере задано автором. В окне ниже показан браузерный результат; в текстовом выводе выше видна отправленная разметка. Обычный \n внутри HTML не заменяет отдельный абзац.

<?php $name = 'Кисть'; ?>
<p>Товар: <?= htmlspecialchars($name, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8') ?></p>

<p>Товар: Кисть</p>

Короткая запись <?= выражение ?> означает вывод выражения и работает независимо от short_open_tag. HTML вокруг остаётся обычной разметкой. Внутри шаблона тоже нужно защищать внешние данные для места вывода.

<?php
$message = 'Заказ сохранён';
print $message . "\n";

Заказ сохранён

print принимает одно выражение. Здесь точка соединяет сообщение с переносом строки. В отличие от echo перечислить несколько частей через запятую нельзя. Для повседневного вывода обе конструкции подходят, выбор не меняет правила безопасности HTML.

<?php
$result = print "Сохранено 2 товара\n";
echo 'Ответ print: ', $result, "\n";

Сохранено 2 товара
Ответ print: 1

Сначала выполняется print и появляется сообщение, затем $result получает 1. Два сохранённых товара, длина строки и число 1 — разные вещи. Не используйте этот результат для проверки записи в базу: такую проверку делают по результату операции с базой.

<?php
$count = 0;
$message = $count === 0 ? 'Каталог пока пуст' : 'Товары загружены';
print $message . "\n";

Каталог пока пуст

Условный оператор ?: выбирает одну из двух строк. Выбор и вывод записаны отдельно, поэтому не приходится угадывать приоритет print внутри сложного условия. Конструкция всегда возвращает 1: делать вывод условием успешности операции не нужно.

<?php
printf("%s: %d шт.\n", 'Кисть', 3);

Кисть: 3 шт.

Шаблон в двойных кавычках содержит настоящий перевод строки \n. %s заменяется названием, %d — целым количеством. Дополнительный echo вокруг printf не нужен: функция уже печатает.

<?php
$written = printf('SKU=%s', 'A42');
echo "\nВозвращено байтов: ", $written, "\n";
$saved = sprintf('SKU=%s', 'A42');
echo 'Сохранённый текст: ', $saved, "\n";

SKU=A42
Возвращено байтов: 7
Сохранённый текст: SKU=A42

В $written находится 7, а не SKU=A42. Когда сообщение нужно передать в другую функцию или вернуть из своей функции, используйте sprintf. Байты не равны числу русских букв. Все флаги, позиционные аргументы и ошибки формата описаны в общей грамматике.

<?php
fprintf(STDOUT, "%s: %d шт.\n", 'Кисть', 3);

Кисть: 3 шт.

STDOUT — заранее открытый поток стандартного вывода в PHP CLI. Благодаря ему первый вызов можно запустить без работы с файлами. Первым передаётся поток, вторым формат, затем значения. В обработчике HTTP этот CLI-поток не предполагается: для обычного вывода страницы есть echo/printf. Следующий пример открывает собственный файл.

<?php
$path = __DIR__ . '/stock-report-demo.txt';
$stream = fopen($path, 'xb');
if ($stream === false) {
    throw new RuntimeException('Не удалось создать новый файл отчёта');
}
try {
    $written = fprintf($stream, "%s: %d шт.\n", 'Кисть', 3);
    if ($written !== strlen("Кисть: 3 шт.\n")) {
        throw new RuntimeException('Строка записана не полностью');
    }
} finally {
    fclose($stream);
}
echo "Содержимое созданного отчёта:\n";
echo file_get_contents($path);

Содержимое созданного отчёта:
Кисть: 3 шт.

Запускайте в отдельной учебной папке. Режим xb создаёт новый файл и отказывается перезаписывать существующий; повторный запуск требует нового имени/папки. __DIR__ привязывает путь к папке PHP-файла. Возвращаемое число сравнивается с длиной известной строки, чтобы не принять неполную запись за успех. finally закрывает поток и при исключении. Пример действительно записывает и читает файл. В реальной работе обрабатывают и предупреждения/отказы открытия; общее устройство потоков объясняется в главе о файлах.

<?php
$format = '%s: %d шт.';
$values = ['Кисть', 3];
vprintf($format . "\n", $values);

Кисть: 3 шт.

Буква v обозначает форму с массивом аргументов. Это удобно, когда значения уже подготовлены как список. Формат принадлежит программе; не передавайте вместо него произвольный текст клиента.

<?php
$rows = [['Кисть', 3], ['Валик', 2]];
foreach ($rows as $values) {
    vprintf("%s: %d шт.\n", $values);
}

Кисть: 3 шт.
Валик: 2 шт.

Внешний массив содержит строки заказа, внутренний — значения одной строки. foreach передаёт каждый внутренний массив форматтеру. При недостаточном числе значений возникает ошибка; задавайте и проверяйте схему данных до форматирования. Для HTML полученный текст нужно экранировать.

<?php
$format = '%s: %d шт.';
$values = ['Кисть', 3];
$message = vsprintf($format, $values);
echo $message, "\n";

Кисть: 3 шт.

Буква v обозначает форму с массивом аргументов. Это удобно, когда значения уже подготовлены как список. Формат принадлежит программе; не передавайте вместо него произвольный текст клиента.

<?php
$rows = [['Кисть', 3], ['Валик', 2]];
foreach ($rows as $values) {
    $line = vsprintf("%s: %d шт.", $values); echo $line, "\n";
}

Кисть: 3 шт.
Валик: 2 шт.

Внешний массив содержит строки заказа, внутренний — значения одной строки. foreach передаёт каждый внутренний массив форматтеру. При недостаточном числе значений возникает ошибка; задавайте и проверяйте схему данных до форматирования. Для HTML полученный текст нужно экранировать.

<?php
vfprintf(STDOUT, "%s: %d шт.\n", ['Кисть', 3]);

Кисть: 3 шт.

STDOUT — заранее открытый поток стандартного вывода в PHP CLI. Благодаря ему первый вызов можно запустить без работы с файлами. Первым передаётся поток, вторым формат, затем значения. В обработчике HTTP этот CLI-поток не предполагается: для обычного вывода страницы есть echo/printf. Следующий пример открывает собственный файл.

<?php
$path = __DIR__ . '/stock-report-demo.txt';
$stream = fopen($path, 'xb');
if ($stream === false) {
    throw new RuntimeException('Не удалось создать новый файл отчёта');
}
try {
    $written = vfprintf($stream, "%s: %d шт.\n", ['Кисть', 3]);
    if ($written !== strlen("Кисть: 3 шт.\n")) {
        throw new RuntimeException('Строка записана не полностью');
    }
} finally {
    fclose($stream);
}
echo "Содержимое созданного отчёта:\n";
echo file_get_contents($path);

Содержимое созданного отчёта:
Кисть: 3 шт.

Запускайте в отдельной учебной папке. Режим xb создаёт новый файл и отказывается перезаписывать существующий; повторный запуск требует нового имени/папки. __DIR__ привязывает путь к папке PHP-файла. Возвращаемое число сравнивается с длиной известной строки, чтобы не принять неполную запись за успех. finally закрывает поток и при исключении. Пример действительно записывает и читает файл. В реальной работе обрабатывают и предупреждения/отказы открытия; общее устройство потоков объясняется в главе о файлах.

<?php
$values = sscanf('T=23.5 H=48', 'T=%f H=%d');
echo 'Температура: ', $values[0], " °C\n";
echo 'Влажность: ', $values[1], "%\n";

Температура: 23.5 °C
Влажность: 48%

При двух аргументах ответ — массив, индексы 0 и 1 соответствуют спецификаторам формата. Здесь строка известна и корректна. Для данных извне нельзя сразу обращаться к результату и считать частично прочитанную запись успешной.

<?php
$records = ['T=23.5 H=48', 'T=23.5', 'T=23.5 H=48oops'];
foreach ($records as $record) {
    $temperature = $humidity = $used = null;
    $assigned = sscanf($record, 'T=%f H=%d%n', $temperature, $humidity, $used);
    if ($assigned !== 3 || $used !== strlen($record) || $humidity < 0 || $humidity > 100) {
        echo "Измерение отклонено\n";
        continue;
    }
    echo 'Принято: ', $temperature, ' °C, ', $humidity, "%\n";
}

Принято: 23.5 °C, 48%
Измерение отклонено
Измерение отклонено

Дополнительные аргументы получают значения по ссылке; ответ функции теперь число присваиваний. %n сохраняет количество прочитанных байтов. Сравнение с strlen запрещает хвост oops. Инициализация null не позволяет случайно использовать прошлое значение после неудачи. Проверка влажности — правило нашего формата, не свойство sscanf.

<?php
$value = 12345.5;
$shown = number_format($value, 2, ',', ' ');
echo $shown, " руб.\n";
echo 'Тип результата: ', get_debug_type($shown), "\n";

12 345,50 руб.
Тип результата: string

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

<?php
$kopecks = 1234550;
$roubles = intdiv($kopecks, 100);
$fraction = $kopecks % 100;
$shown = number_format($roubles, 0, ',', ' ') . ',' . sprintf('%02d', $fraction);
echo $shown, " руб.\n";

12 345,50 руб.

В этом примере неотрицательная сумма хранится целым числом: intdiv берёт целые рубли, % — остаток копеек. sprintf дополняет 5 копеек до 05. Это избегает деления суммы на float в показанном диапазоне обычных сумм; number_format всё равно принимает float, поэтому для огромных целых нужна иная стратегия, а отрицательные суммы требуют отдельно обработать знак.

<?php
echo number_format(12345.678, 2, ',', ' '), "\n";
echo number_format(12345, -2, ',', ' '), "\n";
echo number_format(-0.01, 0), "\n";
echo number_format(12345.5, 2, '.', ''), "\n";

12 345,68
12 300
0
12345.50

decimals=-2 округляет до сотен с PHP 8.3. Малое отрицательное число при округлении до нуля не выводится как -0 с PHP 7.2. Пустой четвёртый аргумент отключает группировку. Округление представления не должно незаметно менять бизнес-расчёт; десятичные финансовые правила задаются отдельно.

<?php
$query = 'name=Anna+Petrova&qty=0';
parse_str($query, $fields);
echo 'Имя: ', $fields['name'], "\n";
echo 'Количество: ', $fields['qty'], "\n";
echo 'Тип количества: ', get_debug_type($fields['qty']), "\n";

Имя: Anna Petrova
Количество: 0
Тип количества: string

Переменную $fields создаёт/заполняет вызов. Запись $fields = parse_str(...) была бы ошибочной: возвращаемое значение void не содержит массива. Для обычного текущего HTTP-запроса параметры уже доступны в $_GET; повторный ручной разбор обычно не нужен.

<?php
parse_str('tag=paint&tag=tools', $single);
parse_str('tag[]=paint&tag[]=tools&user.name=Anna', $multiple);
echo 'Обычный повтор: ', $single['tag'], "\n";
echo 'Явный список: ', implode(', ', $multiple['tag']), "\n";
echo 'Ключ после нормализации: ', $multiple['user_name'], "\n";

Обычный повтор: tools
Явный список: paint, tools
Ключ после нормализации: Anna

Обычный повтор перезаписывает предыдущее значение, [] явно формирует массив. Точки и пробелы в именах PHP заменяет на подчёркивания. Это конкретные правила PHP, а не универсальные правила любого API. Если поле должно быть строкой, проверяйте is_string: пользователь может передать name[]=... .

<?php
$record = '"Кисть ""Профи"", широкая",8';
$fields = str_getcsv($record, ',', '"', '');
echo 'Название: ', $fields[0], "\n";
echo 'Остаток: ', $fields[1], "\n";
echo 'Число полей: ', count($fields), "\n";

Название: Кисть "Профи", широкая
Остаток: 8
Число полей: 2

Переданы запись, запятая-разделитель, двойная кавычка и пустой escape. Последний аргумент отключает дополнительный нестандартный backslash-механизм; оставлять его по умолчанию deprecated с PHP 8.4. Полученный остаток ещё строка: число полей, типы и диапазоны проверяются по схеме импорта.

<?php
$record = "\"Кисть\nширокая\",8";
$fields = str_getcsv($record, ',', '"', '');
echo 'Полей: ', count($fields), "\n";
echo "Название:\n";
echo $fields[0], "\n";
echo 'Остаток: ', $fields[1], "\n";
$blank = str_getcsv('', ',', '"', '');
var_dump($blank);

Полей: 2
Название:
Кисть
широкая
Остаток: 8
array(1) {
  [0]=>
  NULL
}

Первое поле включает настоящий перевод строки. Поэтому целый CSV-файл нельзя сначала поделить через explode("\n"): это разрушит одну запись. Для чтения файла по логическим записям есть fgetcsv. Пустая CSV-строка даёт [null], а не пустой массив — правило пропуска пустых записей задайте явно.

<?php
$comment = "Привезите после 18:00.\nПозвоните у ворот <Б>.";
$safeComment = htmlspecialchars($comment, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
$htmlComment = nl2br($safeComment, false);
echo '<p>', $htmlComment, "</p>\n";

<p>Привезите после 18:00.<br>
Позвоните у ворот &lt;Б&gt;.</p>

Обработка выполняется в двух отдельных строках, чтобы был виден порядок. false выбирает HTML-тег <br>; значение по умолчанию true даёт <br />. Перевод строки остаётся и в исходнике: функция добавляет тег, а не удаляет LF. Читатель ниже видит обе строки результата.

<?php
$text = "Кисть\nВалик";
$wrong = htmlspecialchars(nl2br($text, false), ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
$right = nl2br(htmlspecialchars($text, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'), false);
echo 'Обратный порядок: ', $wrong, "\n";
echo 'Нужный порядок: ', $right, "\n";

Обратный порядок: Кисть<br>
Валик
Нужный порядок: Кисть<br>
Валик

В первом случае htmlspecialchars защищает и добавленный автором <br>, превращая его в текст. В обычном HTML появится надпись <br>. Во втором защищены только исходные данные, а авторский тег добавлен после этого. В textarea и pre переносы отображаются и без nl2br; туда вставляют экранированный исходный текст.

<?php
echo nl2br('Кисть\nВалик', false), "\n";
echo nl2br("Кисть\nВалик", false), "\n";

Кисть\nВалик
Кисть<br>
Валик

В одинарных кавычках \n сохраняется как два обычных символа, поэтому функция не находит перенос. В двойных кавычках PHP создаёт настоящий LF. Для отображения текста также можно оставить PHP-строку без br и задать контейнеру CSS white-space: pre-wrap; экранирование всё равно требуется.

<?php
$text = '© 2026 Кисть & валик';
echo htmlentities($text, ENT_QUOTES | ENT_HTML5, 'UTF-8'), "\n";
echo htmlspecialchars($text, ENT_QUOTES | ENT_HTML5, 'UTF-8'), "\n";

© 2026 Кисть & валик
© 2026 Кисть & валик

В словаре HTML5 есть именованные сущности для использованных кириллических букв, поэтому первая строка заметно длиннее. htmlspecialchars сохранила буквы и ©, изменив только специальный знак &. Результаты имеют одинаковый вид в браузере, но разную текстовую запись. Для обычного вывода русского текста в HTML не требуется заменять буквы сущностями.

<?php
$text = "Цена: 5 €; кавычка: '";
echo htmlentities($text, ENT_QUOTES | ENT_HTML5 | ENT_SUBSTITUTE, 'UTF-8'), "\n";
echo htmlentities($text, ENT_QUOTES | ENT_HTML401 | ENT_SUBSTITUTE, 'UTF-8'), "\n";

Цена: 5 €; кавычка: '
Цена: 5 €; кавычка: '

HTML5 имеет больше именованных сущностей: здесь заменились кириллица, двоеточия и точка с запятой. HTML 4.01 оставил их исходными символами. Флаги типа документа меняют допустимый словарь, а ENT_SUBSTITUTE отвечает за повреждённую последовательность кодировки. Не смешивайте HTML-кодирование с URL-кодированием, SQL-параметрами или JSON: каждое предназначено для своей границы.

<?php
$stored = 'Кисть &amp; валик';
$text = htmlspecialchars_decode($stored, ENT_QUOTES | ENT_HTML5);
echo $text, "\n";
echo htmlspecialchars_decode('&copy; &lt;Pro&gt;', ENT_QUOTES | ENT_HTML5), "\n";

Кисть & валик
&copy; <Pro>

Функция раскрыла специальные < и >, но не ©: &copy; осталась как запись. Для всех сущностей выбранного типа документа существует html_entity_decode. Уже раскрытая <Pro> является обычной PHP-строкой, но браузер может принять её за тег, если вывести без экранирования.

<?php
$stored = '&quot;Pro&quot; &#039;Blue&#039; &amp;';
echo htmlspecialchars_decode($stored, ENT_NOQUOTES), "\n";
echo htmlspecialchars_decode($stored, ENT_COMPAT), "\n";
echo htmlspecialchars_decode($stored, ENT_QUOTES), "\n";

"Pro" 'Blue' &
"Pro" 'Blue' &
"Pro" 'Blue' &

ENT_NOQUOTES сохраняет оба вида кавычек закодированными; ENT_COMPAT раскрывает двойные, ENT_QUOTES — оба вида. Знак & раскрывается во всех трёх примерах. Настройки должны соответствовать формату источника; многократное декодирование неизвестного текста может изменить намеренные буквальные последовательности.

<?php
$encoded = '&copy; 2026 Кисть &amp; валик';
$text = html_entity_decode($encoded, ENT_QUOTES | ENT_HTML5, 'UTF-8');
echo $text, "\n";

© 2026 Кисть & валик

Вход должен действительно быть HTML-представлением. Если пользователь написал буквальное &copy; в объяснении кода, автоматическое декодирование исказит его сообщение. Не декодируйте строку повторно без знания источника.

<?php
$encoded = '&nbsp;Кисть&nbsp;';
$text = html_entity_decode($encoded, ENT_QUOTES | ENT_HTML5, 'UTF-8');
echo 'Размер после trim: ', strlen(trim($text)), " байт\n";
echo 'Первый символ в HEX: ', bin2hex(substr($text, 0, 2)), "\n";
echo 'После mb_trim: [', mb_trim($text, encoding: 'UTF-8'), "]\n";

Размер после trim: 14 байт
Первый символ в HEX: c2a0
После mb_trim: [Кисть]

&nbsp; превратился в неразрывный пробел U+00A0, а не в обычный ASCII-пробел. Для выбранного правила очистки здесь подходит mb_trim из PHP 8.4 и mbstring. Декодирование и очистка краёв — две разные операции.

<?php
$encoded = '&lt;strong&gt;Кисть&lt;/strong&gt;';
$text = html_entity_decode($encoded, ENT_QUOTES | ENT_HTML5, 'UTF-8');
echo 'Раскрытый текст: ', $text, "\n";
echo 'Для буквального показа в HTML: ', htmlspecialchars($text, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'), "\n";

Раскрытый текст: <strong>Кисть</strong>
Для буквального показа в HTML: &lt;strong&gt;Кисть&lt;/strong&gt;

В CLI обе строки видны как текст. В браузере первая могла бы стать оформлением, а вторая сохранит буквальное написание тегов. Декодер не проверяет допустимость разметки и не является санитайзером. Если нужна разрешённая пользовательская разметка, проверяется структура, атрибуты и ссылки отдельным инструментом.

<?php
$table = get_html_translation_table(HTML_SPECIALCHARS, ENT_QUOTES | ENT_HTML5, 'UTF-8');
echo '& записывается как ', $table['&'], "\n";
echo '< записывается как ', $table['<'], "\n";
echo 'Всего специальных символов: ', count($table), "\n";

& записывается как &
< записывается как &lt;
Всего специальных символов: 5

Массив удобно читать по ключу-символу. Тип документа и флаги кавычек влияют на таблицу. Сама функция не кодирует переданный пользовательский текст: такого аргумента у неё нет.

<?php
$special = get_html_translation_table(HTML_SPECIALCHARS, ENT_QUOTES | ENT_HTML5, 'UTF-8');
$all = get_html_translation_table(HTML_ENTITIES, ENT_QUOTES | ENT_HTML5, 'UTF-8');
echo 'В специальных: ', $special['©'] ?? 'нет замены', "\n";
echo 'В полной таблице HTML5: ', $all['©'], "\n";

В специальных: нет замены
В полной таблице HTML5: ©

Это наглядное различие HTML_SPECIALCHARS и HTML_ENTITIES. Простая strtr по таблице не повторит все проверки повреждённого UTF-8, double_encode и флагов настоящего кодировщика. Обратный array_flip также не заменяет декодер: один символ может иметь несколько сущностей.

<?php
$html = '<strong>Кисть</strong> — 8 шт.';
$text = strip_tags($html);
echo $text, "\n";
echo strip_tags('<p>Кисть</p><p>Валик</p>'), "\n";

Кисть — 8 шт.
КистьВалик

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

<?php
$ownHtml = '<strong>Кисть &amp; валик</strong><!-- служебная заметка -->';
$withoutTags = strip_tags($ownHtml);
$plainText = html_entity_decode($withoutTags, ENT_QUOTES | ENT_HTML5, 'UTF-8');
echo 'После удаления тегов: ', $withoutTags, "\n";
echo 'Обычный текст: ', $plainText, "\n";

После удаления тегов: Кисть & валик
Обычный текст: Кисть & валик

Это преобразование собственного известного фрагмента в обычный текст, например для текстового отчёта. Если полученный текст затем снова помещают в HTML, его заново экранируют для этого контекста. Декодирование может восстановить угловые скобки и поэтому не делает строку безопасной разметкой.

<?php
$html = '<b class="stock" data-note="internal">Кисть</b><i> 8 шт.</i>';
echo strip_tags($html, ['b']), "\n";

<b class="stock" data-note="internal">Кисть</b> 8 шт.

Массив allowed_tags оставляет тег b целиком, включая атрибуты. Так же могли бы сохраниться опасные атрибуты событий: список тегов не проверяет атрибуты и URL. Если разрешаете пользователю форматированный HTML, нужен специализированный санитайзер; если нужен буквальный текст — htmlspecialchars. Показанный результат намеренно выводится как исходный HTML, а не как обещание безопасности.

<?php
$before = setlocale(LC_NUMERIC, '0');
$chosen = setlocale(LC_NUMERIC, 'C');
echo 'Выбрана локаль: ', $chosen, "\n";
echo sprintf('amount=%.2f', 12.5), "\n";
if ($before !== false) {
    setlocale(LC_NUMERIC, $before);
}

Выбрана локаль: C
amount=12.50

Строка "0" запрашивает текущее имя без изменения. C — базовая доступная локаль, LC_NUMERIC ограничивает область изменения. В долгоживущем обработчике восстановление при ошибке также обязательно; следующий пример использует finally. Для фиксированного протокола часто проще сразу выбрать независимый от локали %F.

<?php
$before = setlocale(LC_NUMERIC, '0');
if ($before === false || setlocale(LC_NUMERIC, 'C') === false) {
    throw new RuntimeException('Не удалось выбрать числовые правила');
}
try {
    echo sprintf('amount=%.2f', 12.5), "\n";
} finally {
    setlocale(LC_NUMERIC, $before);
}
echo 'Без изменения локали: ', sprintf('amount=%.2F', 12.5), "\n";

amount=12.50
Без изменения локали: amount=12.50

finally выполняется и при исключении внутри try, поэтому соседний код не получает чужую настройку. Заглавная F создаёт дробную точку независимо от LC_NUMERIC; для этого простого протокола она избавляет от изменения общего окружения. На реальной операции сначала выбирают формат данных, а не глобально ставят LC_ALL.

<?php
declare(strict_types=1);
$before = setlocale(LC_COLLATE, '0');
$chosen = setlocale(LC_COLLATE, ['php_manual_missing_locale_41', 'C']);
echo 'Доступная альтернатива: ', $chosen, "\n";
if ($before !== false) {
    setlocale(LC_COLLATE, $before);
}
try {
    setlocale(LC_COLLATE, 0);
} catch (TypeError) {
    echo "Для чтения нужна строка 0, а не целое число\n";
}

Доступная альтернатива: C
Для чтения нужна строка 0, а не целое число

Имена проверяются по порядку: выдуманной локали нет, C доступна. Если не подошло ни одно имя, возвращается false — нельзя продолжать так, будто нужный язык установлен. Последний вызов намеренно показывает правило PHP 8.5 в строгом режиме; в обычном коде пишут "0". Имена локалей и их наличие различаются между ОС.

<?php
$before = setlocale(LC_NUMERIC, '0');
setlocale(LC_NUMERIC, 'C');
$rules = localeconv();
echo 'Дробный разделитель: [', $rules['decimal_point'], "]\n";
echo 'Разделитель тысяч: [', $rules['thousands_sep'], "]\n";
if ($before !== false) {
    setlocale(LC_NUMERIC, $before);
}

Дробный разделитель: [.]
Разделитель тысяч: []

Ключи массива называют свойства результата. Скобки показывают, что thousands_sep действительно пуст, а не потерялся в выводе. Денежные поля относятся к LC_MONETARY и могут быть не определены в C; их нельзя автоматически считать готовой настройкой валюты.

<?php
$before = setlocale(LC_NUMERIC, '0');
setlocale(LC_NUMERIC, 'C');
try {
    $rules = localeconv();
    echo 'Правила C: ', number_format(1234.5, 2, $rules['decimal_point'], $rules['thousands_sep']), "\n";
    echo 'Подпись витрины: ', number_format(1234.5, 2, ',', ' '), " руб.\n";
} finally {
    if ($before !== false) {
        setlocale(LC_NUMERIC, $before);
    }
}

Правила C: 1234.50
Подпись витрины: 1 234,50 руб.

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

<?php
$before = setlocale(LC_COLLATE, '0');
setlocale(LC_COLLATE, 'C');
$comparison = strcoll('bolt', 'washer');
if ($comparison < 0) {
    echo "bolt располагается раньше washer\n";
}
echo strcoll('bolt', 'bolt') === 0 ? "Одинаковый порядок для bolt и bolt\n" : "Порядок различается\n";
if ($before !== false) {
    setlocale(LC_COLLATE, $before);
}

bolt располагается раньше washer
Одинаковый порядок для bolt и bolt

Важно, меньше ли число нуля, равно или больше; конкретное значение -1 не обещается. C выбрана ради воспроизводимости и не означает естественный алфавитный порядок любого языка. Для русского Unicode-каталога удобнее Collator с явно заданной локалью.

<?php
$labels = ['washer', 'bolt', 'clamp'];
$before = setlocale(LC_COLLATE, '0');
setlocale(LC_COLLATE, 'C');
try {
    usort($labels, 'strcoll');
    echo implode(', ', $labels), "\n";
} finally {
    if ($before !== false) {
        setlocale(LC_COLLATE, $before);
    }
}

bolt, clamp, washer

usort вызывает переданный компаратор много раз с парами элементов. Строка "strcoll" здесь является именем вызываемой функции. usort меняет массив и перенумеровывает числовые ключи; если ключи связывают подпись с товаром, изучите uasort. Во время сортировки нельзя менять локаль.

<?php
$first = "BR\0A";
$second = "BR\0Z";
$before = setlocale(LC_COLLATE, '0');
setlocale(LC_COLLATE, 'C');
echo strcoll($first, $second) === 0 ? "strcoll не заметила различие после NUL\n" : "strcoll различила строки\n";
echo strcmp($first, $second) === 0 ? "Байты одинаковы\n" : "strcmp различила полные строки\n";
if ($before !== false) {
    setlocale(LC_COLLATE, $before);
}

strcoll не заметила различие после NUL
strcmp различила полные строки

strcoll не binary-safe: NUL ограничивает строку для этой системной операции. Идентификаторы могут различаться после него, поэтому сортировка для человека не должна задавать правило авторизации или равенства ключей. Для точного равенства обычных строк подходит ===, для чувствительного сравнения хешей — hash_equals.

<?php
if (!function_exists('nl_langinfo')) {
    echo "В Windows используйте localeconv для числовых правил\n";
} else {
    echo "nl_langinfo доступна: проверяйте нужную константу\n";
}

В Windows используйте localeconv для числовых правил

Точный ожидаемый вывод относится к проверенной Windows-сборке PHP 8.5.11. На Unix будет другая ветка; она не объявляется выполненной этим запуском.

<?php
$old = setlocale(LC_NUMERIC, '0'); setlocale(LC_NUMERIC, 'C');
$point = false;
if (function_exists('nl_langinfo') && defined('RADIXCHAR')) {
    $point = nl_langinfo(constant('RADIXCHAR'));
}
if ($point === false) { $point = localeconv()['decimal_point']; }
echo $point, "\n";
if ($old !== false) { setlocale(LC_NUMERIC, $old); }

.

Короткое замыкание && не обращается к отсутствующей константе. В Windows проверен fallback, а не сама Unix-функция. Это ограничение доказательства сохранено в реестре примеров.

<?php
$legacy = "Caf\xE9";
$text = mb_convert_encoding($legacy, 'UTF-8', 'ISO-8859-1');
echo 'Название: ', $text, "\n";
echo 'До: ', bin2hex($legacy), "\n";
echo 'После: ', bin2hex($text), "\n";

Название: Café
До: 436166e9
После: 436166c3a9

\xE9 в двойных кавычках задаёт один конкретный байт, поэтому редактор не перекодирует учебный источник незаметно. mb_convert_encoding получает сначала целевую, затем исходную кодировку. Слово осталось тем же, изменилась его байтовая запись. Требуется mbstring.

<?php
$deprecated = false;
set_error_handler(function (int $level) use (&$deprecated): bool {
    if ($level === E_DEPRECATED) {
        $deprecated = true;
        return true;
    }
    return false;
});
try {
    $text = utf8_encode("Caf\xE9");
} finally {
    restore_error_handler();
}
echo 'Название: ', $text, "\n";
echo $deprecated ? "Нужно заменить устаревший вызов\n" : "Предупреждения нет\n";

Название: Café
Нужно заменить устаревший вызов

Собственно старое преобразование — одна строка $text = utf8_encode(...). Обработчик вокруг нужен только для явного наблюдения E_DEPRECATED в PHP 8.5 и затем снимается. В приложении заменяют вызов, а не скрывают предупреждение. Не пропускайте через utf8_encode текст, который уже является UTF-8: он будет испорчен.

<?php
$euroByte = "\x80";
echo 'Windows-1252: ', mb_convert_encoding($euroByte, 'UTF-8', 'Windows-1252'), "\n";
$latin1 = mb_convert_encoding($euroByte, 'UTF-8', 'ISO-8859-1');
echo 'Latin-1 даёт байты: ', bin2hex($latin1), "\n";

Windows-1252: €
Latin-1 даёт байты: c280

В Windows-1252 байт 80 означает евро, а в Latin-1 — управляющую кодовую точку U+0080. Её показываем в HEX, поскольку это не печатный знак. Кодировку узнают из договора поставщика, заголовка или достоверной настройки источника, а не из предположения «функция с UTF-8 в имени всё исправит».

<?php
$text = 'Café';
$bytes = mb_convert_encoding($text, 'ISO-8859-1', 'UTF-8');
echo 'Байты для старого получателя: ', bin2hex($bytes), "\n";
echo 'Проверочный показ: ', mb_convert_encoding($bytes, 'UTF-8', 'ISO-8859-1'), "\n";

Байты для старого получателя: 436166e9
Проверочный показ: Café

Latin-1 байты нельзя просто вывести на UTF-8-страницу: они будут прочитаны в другой кодировке. Поэтому отправляемое представление показано как HEX, а для понятной подписи выполняется обратное преобразование. Этот конкретный текст полностью представим.

<?php
$oldSubstitute = mb_substitute_character();
mb_substitute_character(0x3F);
try {
    foreach (['Café', 'Кисть €'] as $text) {
        $bytes = mb_convert_encoding($text, 'ISO-8859-1', 'UTF-8');
        $roundTrip = mb_convert_encoding($bytes, 'UTF-8', 'ISO-8859-1');
        if ($roundTrip !== $text) {
            echo 'Не экспортируем: ', $text, " потеряет символы\n";
        } else {
            echo 'Можно экспортировать: ', $text, "\n";
        }
    }
} finally {
    mb_substitute_character($oldSubstitute);
}

Можно экспортировать: Café
Не экспортируем: Кисть € потеряет символы

Правило этого экспорта — никаких потерь. 0x3F задаёт вопросительный знак как замену для диагностического преобразования; настройка затем восстанавливается. Обратное преобразование сравнивается с исходным текстом. Перед этим внешний вход отдельно проверяют mb_check_encoding на корректность UTF-8; пример использует известные строки.

<?php
set_error_handler(function (int $level): bool {
    return $level === E_DEPRECATED;
});
try {
    $bytes = utf8_decode('Café € Я');
} finally {
    restore_error_handler();
}
echo 'Байты: ', bin2hex($bytes), "\n";
echo 'Что осталось: ', mb_convert_encoding($bytes, 'UTF-8', 'ISO-8859-1'), "\n";

Байты: 436166e9203f203f
Что осталось: Café ? ?

Старый вызов намеренно показан для чтения существующего кода, предупреждение E_DEPRECATED локально перехвачено. Знаки евро и Я уже заменены, поэтому последующее преобразование в UTF-8 не может их восстановить. Новое приложение должно отвергать такую потерю либо иметь явно согласованное правило замены.

<?php
$legacy = "\xC1\xEE\xEB\xF2";
echo mb_convert_encoding($legacy, 'UTF-8', 'Windows-1251'), "\n";
var_dump(function_exists('convert_cyr_string'));

Болт
bool(false)

Проверяется современная миграция с mbstring. Исходные байты записаны hex, чтобы редактор файла не перекодировал их незаметно; удалённая функция не вызывается.

<?php
$dos = "\x81\xAE\xAB\xE2";
$text = mb_convert_encoding($dos, 'UTF-8', 'CP866');
echo $text, "\n";
echo bin2hex(mb_convert_encoding($text, 'Windows-1251', 'UTF-8')), "\n";

Болт
c1eeebf2

Сначала подтверждается кодировка источника CP866, затем выбирается другой целевой формат. Подстановка имени UTF-8 в старый convert_cyr_string невозможна; современный конвертер имеет иной договор.

<?php
$logical = "\xE0\xE1\xE2";
$visual = hebrev($logical);
echo 'До: ', bin2hex($logical), "\n";
echo 'После: ', bin2hex($visual), "\n";
echo 'Порядок букв после преобразования: ', mb_convert_encoding($visual, 'UTF-8', 'ISO-8859-8'), "\n";

До: e0e1e2
После: e2e1e0
Порядок букв после преобразования: גבא

HEX показывает порядок хранения независимо от двунаправленного отображения терминала. Перекодирование последней строки нужно только для просмотра букв в UTF-8. Передача самой UTF-8-строки в hebrev не делает функцию Unicode-алгоритмом.

<?php
$text = 'שלום';
echo '<p lang="he" dir="rtl">', htmlspecialchars($text, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'), "</p>\n";

<p lang="he" dir="rtl">שלום</p>

Видимый результат ниже — приветствие на иврите. lang указывает язык, dir задаёт направление, htmlspecialchars защищает текстовый контекст. Строка хранится в логическом порядке и не проходит hebrev. Для сложных смешанных подписей отдельно рассматривают bdi и изоляцию направления.

<?php
echo "hebrev:\n", hebrev('ABC DEF GHI', 5), "\n";
echo "wordwrap:\n", wordwrap('ABC DEF GHI', 5), "\n";

hebrev:
GHI
DEF
ABC
wordwrap:
ABC
DEF
GHI

Даже английские слова показывают отличие: hebrev меняет порядок получившихся строк. Аргумент max_chars_per_line не означает пиксельную ширину HTML-блока. Для обычного переноса текста не выбирайте функцию перестановки иврита.

<?php
$text = "שלום\nעולם";
$safe = htmlspecialchars($text, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
echo '<div lang="he" dir="rtl">', nl2br($safe, false), "</div>\n";

<div lang="he" dir="rtl">שלום<br>
עולם</div>

Две строки означают «привет» и «мир». false просит nl2br создать HTML-тег <br>. Исходный перевод строки тоже остаётся. Сначала защищается текст, затем добавляются авторские теги; обратный порядок превратил бы <br> в буквальные символы.

<?php
if (!function_exists('hebrevc')) {
    echo "В PHP 8 hebrevc удалена. Нужно обновить старый шаблон.\n";
}

В PHP 8 hebrevc удалена. Нужно обновить старый шаблон.

Проверка объясняет состояние среды, но не заменяет миграцию. Не создавайте автоматически функцию-заглушку с тем же именем: для старого однобайтового визуального формата и нового логического Unicode нужны разные решения. Исторические параметры сохранены в таблице карточки.

<?php
$formatter = new NumberFormatter('en_US', NumberFormatter::CURRENCY);
$label = $formatter->formatCurrency(12.5, 'USD');
if ($label === false) { throw new RuntimeException($formatter->getErrorMessage()); }
echo $label, "\n";
var_dump(function_exists('money_format'));

$12.50
bool(false)

new создаёт объект с собственной локалью; -> вызывает его метод. Нужен intl. Точный образец проверен в проектном ICU/PHP; языковые данные ICU могут меняться, а отсутствующая функция подтверждена на PHP 8.5.

<?php
$cents = 1250;
echo number_format($cents / 100, 2, '.', ''), " USD\n";
echo sprintf('%.2F USD', $cents / 100), "\n";

12.50 USD
12.50 USD

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

<?php
$stored = '$2y$04$abcdefghijklmnopqrstuuXw4/nL3XGUEWc/Gd51kTAXgEzpvX6xK';
$candidate = crypt('demo-stock-41', $stored);
if (strlen($candidate) >= 13 && hash_equals($stored, $candidate)) {
    echo "Учебный пароль совпал со старой записью\n";
} else {
    echo "Пароль не совпал или вычисление завершилось ошибкой\n";
}

Учебный пароль совпал со старой записью

Открытая учебная строка и фиксированная соль нужны только для воспроизводимого примера. Стоимость 04 намеренно мала для демонстрации и не является настройкой реального сайта. В salt передаётся сохранённая запись целиком: crypt берёт из неё параметры. При отказе crypt возвращает короткую строку, поэтому сначала проверена длина.

<?php
$old = '$2y$04$abcdefghijklmnopqrstuuXw4/nL3XGUEWc/Gd51kTAXgEzpvX6xK';
$entered = 'demo-stock-41';
if (password_verify($entered, $old)) {
    $newHash = password_hash($entered, PASSWORD_DEFAULT);
    echo "Пароль подтверждён. Новый хеш готов к сохранению.\n";
    echo password_verify($entered, $newHash) ? "Новая запись проходит проверку\n" : "Ошибка миграции\n";
}
echo password_verify('wrong-demo', $old) ? "Совпадение\n" : "Неверный пароль отклонён\n";

Пароль подтверждён. Новый хеш готов к сохранению.
Новая запись проходит проверку
Неверный пароль отклонён

password_verify совместима с поддерживаемыми crypt-хешами, поэтому ручной crypt для такой проверки часто уже не нужен. Новый хеш каждый раз отличается благодаря соли; точная строка здесь не фиксируется. Для реальной миграции запись сохраняют в базе после успеха, учитывают конкурентный вход и применяют password_needs_rehash. Пример не является полной системой авторизации.

<?php
$result = crypt('demo', '*0');
if (strlen($result) < 13) {
    echo "Хеш не получен: параметры crypt недопустимы\n";
}

Хеш не получен: параметры crypt недопустимы

Неверная соль здесь задана намеренно. Проверка $result !== false была бы ошибочной: crypt возвращает строку даже при таком отказе. Не позволяйте внешнему запросу выбирать алгоритм и вычислительную стоимость.

<?php
$text = 'BR41';
$checksum = md5($text);
echo 'Текст: ', $text, "
";
echo 'Сумма: ', $checksum, "
";
echo 'Длина записи: ', strlen($checksum), "
";

Текст: BR41
Сумма: 41264ab83d64ea83d4cc054475134e84
Длина записи: 32

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

<?php
$expected = '8a63466971fd05efe7d83b0b796d7e78';
$packets = ["BR41;12
", "BR41;13
", 'BR41;12'];
foreach ($packets as $packet) {
    if (md5($packet) === $expected) {
        echo "Байты соответствуют старому манифесту
";
    } else {
        echo "Сумма отличается: остановить импорт и проверить источник
";
    }
}

Байты соответствуют старому манифесту
Сумма отличается: остановить импорт и проверить источник
Сумма отличается: остановить импорт и проверить источник

Второй пакет содержит количество 13 вместо 12. Третий лишён завершающего LF, поэтому тоже отличается. Нельзя произвольно trim-ить пакет перед проверкой. Сравнение строгое ===; слабое == опасно для строк, похожих на научную запись числа. Открытая сумма не подтверждает отправителя: злоумышленник может заменить и данные, и сумму.

<?php
$binary = md5('BR41', true);
echo 'Бинарных байтов: ', strlen($binary), "
";
echo 'Для просмотра: ', bin2hex($binary), "
";

Бинарных байтов: 16
Для просмотра: 41264ab83d64ea83d4cc054475134e84

true во втором аргументе меняет представление результата, а не алгоритм. Бинарную строку не выводят непосредственно в терминал или HTML. Для нового формата выбирают, например, hash("sha256", ...); проверка подлинности требует HMAC или подписи, а пароли — password_hash/password_verify.

<?php
$path = __DIR__ . '/stock.txt';
$expected = '8a63466971fd05efe7d83b0b796d7e78';
$actual = md5_file($path);
if ($actual === false) {
    echo "Не удалось прочитать файл остатков
";
} elseif ($actual !== $expected) {
    echo "Сумма отличается: файл не импортируем
";
} else {
    echo "Файл соответствует старому манифесту
";
    echo 'Сумма: ', $actual, "
";
}

Файл соответствует старому манифесту
Сумма: 8a63466971fd05efe7d83b0b796d7e78

__DIR__ задаёт папку PHP-файла, поэтому запуск из другой рабочей папки не меняет путь. Сначала отличаем false от успешной строки. Если заменить в stock.txt количество 12 на 13, появится сообщение об отличии. CRLF вместо LF также меняет байты. Сам импорт этот пример ещё не выполняет.

<?php
$first = md5_file(__DIR__ . '/first.txt', true);
$second = md5_file(__DIR__ . '/second.txt', true);
if ($first === false || $second === false) {
    throw new RuntimeException('Не удалось прочитать обе копии');
}
echo $first === $second ? "Контрольные суммы копий совпали
" : "Копии отличаются
";
echo 'Размер бинарной суммы: ', strlen($first), "
";

Контрольные суммы копий совпали
Размер бинарной суммы: 16

Имена first.txt и second.txt в сумму не входят — учитывается содержимое. Сырые дайджесты можно сравнить строго, не печатая управляющие байты. Совпадение старого алгоритма не исключает намеренную коллизию. После проверки файл ещё может измениться: эта операция его не блокирует.

<?php
set_error_handler(function (int $level): bool {
    return $level === E_WARNING;
});
try {
    $checksum = md5_file(__DIR__ . '/missing-stock.txt');
} finally {
    restore_error_handler();
}
if ($checksum === false) {
    echo "Файл остатков недоступен. Импорт не начат.
";
}

Файл остатков недоступен. Импорт не начат.

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

<?php
$text = 'BR41';
$checksum = sha1($text);
echo 'Текст: ', $text, "
";
echo 'Сумма: ', $checksum, "
";
echo 'Длина записи: ', strlen($checksum), "
";

Текст: BR41
Сумма: a75892726a630e4e1ff9a3227331718cded15696
Длина записи: 40

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

<?php
$expected = '72986c20946285f315532d162b7eed6bd0597870';
$packets = ["BR41;12
", "BR41;13
", 'BR41;12'];
foreach ($packets as $packet) {
    if (sha1($packet) === $expected) {
        echo "Байты соответствуют старому манифесту
";
    } else {
        echo "Сумма отличается: остановить импорт и проверить источник
";
    }
}

Байты соответствуют старому манифесту
Сумма отличается: остановить импорт и проверить источник
Сумма отличается: остановить импорт и проверить источник

Второй пакет содержит количество 13 вместо 12. Третий лишён завершающего LF, поэтому тоже отличается. Нельзя произвольно trim-ить пакет перед проверкой. Сравнение строгое ===; слабое == опасно для строк, похожих на научную запись числа. Открытая сумма не подтверждает отправителя: злоумышленник может заменить и данные, и сумму.

<?php
$binary = sha1('BR41', true);
echo 'Бинарных байтов: ', strlen($binary), "
";
echo 'Для просмотра: ', bin2hex($binary), "
";

Бинарных байтов: 20
Для просмотра: a75892726a630e4e1ff9a3227331718cded15696

true во втором аргументе меняет представление результата, а не алгоритм. Бинарную строку не выводят непосредственно в терминал или HTML. Для нового формата выбирают, например, hash("sha256", ...); проверка подлинности требует HMAC или подписи, а пароли — password_hash/password_verify.

<?php
$path = __DIR__ . '/stock.txt';
$expected = '72986c20946285f315532d162b7eed6bd0597870';
$actual = sha1_file($path);
if ($actual === false) {
    echo "Не удалось прочитать файл остатков
";
} elseif ($actual !== $expected) {
    echo "Сумма отличается: файл не импортируем
";
} else {
    echo "Файл соответствует старому манифесту
";
    echo 'Сумма: ', $actual, "
";
}

Файл соответствует старому манифесту
Сумма: 72986c20946285f315532d162b7eed6bd0597870

__DIR__ задаёт папку PHP-файла, поэтому запуск из другой рабочей папки не меняет путь. Сначала отличаем false от успешной строки. Если заменить в stock.txt количество 12 на 13, появится сообщение об отличии. CRLF вместо LF также меняет байты. Сам импорт этот пример ещё не выполняет.

<?php
$first = sha1_file(__DIR__ . '/first.txt', true);
$second = sha1_file(__DIR__ . '/second.txt', true);
if ($first === false || $second === false) {
    throw new RuntimeException('Не удалось прочитать обе копии');
}
echo $first === $second ? "Контрольные суммы копий совпали
" : "Копии отличаются
";
echo 'Размер бинарной суммы: ', strlen($first), "
";

Контрольные суммы копий совпали
Размер бинарной суммы: 20

Имена first.txt и second.txt в сумму не входят — учитывается содержимое. Сырые дайджесты можно сравнить строго, не печатая управляющие байты. Совпадение старого алгоритма не исключает намеренную коллизию. После проверки файл ещё может измениться: эта операция его не блокирует.

<?php
set_error_handler(function (int $level): bool {
    return $level === E_WARNING;
});
try {
    $checksum = sha1_file(__DIR__ . '/missing-stock.txt');
} finally {
    restore_error_handler();
}
if ($checksum === false) {
    echo "Файл остатков недоступен. Импорт не начат.
";
}

Файл остатков недоступен. Импорт не начат.

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

<?php
$packet = 'BR41';
$crc = crc32($packet);
echo 'Пакет: ', $packet, "\n";
echo 'CRC32 в HEX: ', sprintf('%08x', $crc), "\n";
echo 'CRC32 десятичная: ', sprintf('%u', $crc), "\n";

Пакет: BR41
CRC32 в HEX: 959546b9
CRC32 десятичная: 2509588153

%08x означает шестнадцатеричную запись шириной восемь знаков с нулями слева. %u показывает беззнаковое десятичное представление: на 32-битной платформе сам PHP int может быть отрицательным. На 64-битной платформе это число помещается как положительное.

<?php
$expectedHex = '959546B9';
foreach (['BR41', 'BR42'] as $packet) {
    $actualHex = sprintf('%08x', crc32($packet));
    if ($actualHex === strtolower($expectedHex)) {
        echo $packet, ": контрольная сумма совпала\n";
    } else {
        echo $packet, ": сумма отличается, запросить пакет повторно\n";
    }
}
echo 'Через hash: ', hash('crc32b', 'BR41'), "\n";

BR41: контрольная сумма совпала
BR42: сумма отличается, запросить пакет повторно
Через hash: 959546b9

Повторная передача здесь показана решением программы, сеть не вызывается. Поле суммы в настоящем протоколе сначала проверяют: ровно восемь ASCII hex-знаков. У hash нужен именно алгоритм crc32b для этого представления. CRC легко пересчитать после намеренного изменения данных; для подлинности отправителя она не подходит.

<?php
echo soundex('Smith'), "\n";
echo soundex('Smyth'), "\n";
var_dump(soundex('Smith') === soundex('Smyth'));

S530
S530
bool(true)

Ключ можно индексировать для предварительного отбора. Список кандидатов затем проверяет человек или более точное правило; это не поиск по точной орфографии.

<?php
$queryKey = soundex('Smith');
$names = ['Smith', 'Smyth', 'Jones'];
foreach ($names as $candidate) {
    if (soundex($candidate) === $queryKey) { echo $candidate, "\n"; }
}

Smith
Smyth

Ввод в этом примере заранее непустой и английский. Реальный поиск ограничивает длину, проверяет алфавит/язык и показывает кандидатов вместо скрытого исправления имени.

<?php
echo metaphone('Steven'), "\n";
echo metaphone('Stephen'), "\n";
var_dump(metaphone('Steven') === metaphone('Stephen'));

STFN
STFN
bool(true)

Ключ можно индексировать для предварительного отбора. Список кандидатов затем проверяет человек или более точное правило; это не поиск по точной орфографии.

<?php
$queryKey = metaphone('Steven');
$names = ['Steven', 'Stephen', 'Jones'];
foreach ($names as $candidate) {
    if (metaphone($candidate) === $queryKey) { echo $candidate, "\n"; }
}

Steven
Stephen

Ввод в этом примере заранее непустой и английский. Реальный поиск ограничивает длину, проверяет алфавит/язык и показывает кандидатов вместо скрытого исправления имени.

<?php
echo levenshtein('BR41', 'BR41'), "\n";
echo levenshtein('BR41', 'BR42'), "\n";
echo levenshtein('BR41', 'BR4'), "\n";
echo levenshtein('A', 'B', 1, 5, 1), "\n";

0
1
1
2

В последнем вызове замена стоит 5, поэтому дешевле удалить A и вставить B за 2. Функция выбирает стоимость пути, а не просто считает несовпавшие позиции.

<?php
$typed = 'BR42';
$catalog = ['BR41', 'BR420', 'NUT9'];
if (strlen($typed) > 32) { throw new InvalidArgumentException('Слишком длинный артикул'); }
foreach ($catalog as $sku) {
    $distance = levenshtein($typed, $sku);
    if ($distance <= 1) { echo $sku, ':', $distance, "\n"; }
}

BR41:1
BR420:1

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

<?php
$percent = 0.0;
$matched = similar_text('BR41', 'BR42', $percent);
echo $matched, "\n", number_format($percent, 1, '.', ''), "%\n";

3
75.0%

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

<?php
$sourceCode = 'ABCA';
$candidateCode = 'CABAA';
echo similar_text($sourceCode, $candidateCode), "\n";
echo similar_text($candidateCode, $sourceCode), "\n";
echo levenshtein($sourceCode, $candidateCode), "\n";

3
2
2

Короткие коды выбраны, чтобы показать неоднозначные общие подстроки. Разный ответ при перестановке не ошибка теста: таков алгоритм выбора. Левенштейн даёт 2: вставить C перед ABCA → CABCA, затем заменить второй C на A → CABAA. Для симметричного расстояния с равными ценами подходит именно эта метрика.

<?php
$text = 'Café=12';
$body = quoted_printable_encode($text);
echo 'Исходный текст: ', $text, "\n";
echo 'Тело MIME-части: ', $body, "\n";
echo 'После декодирования: ', quoted_printable_decode($body), "\n";

Исходный текст: Café=12
Тело MIME-части: Caf=C3=A9=3D12
После декодирования: Café=12

Функция работает с байтами уже выбранного UTF-8. Она не добавляет Content-Type, charset, адреса или MIME-границы. Для отправки реального письма используют почтовую библиотеку, которая согласует эти части; это пример формата тела, а не полное письмо.

<?php
$text = str_repeat('A', 80);
$body = quoted_printable_encode($text);
echo "Передаваемые строки:\n", $body, "\n";
$decoded = quoted_printable_decode($body);
echo 'После восстановления: ', strlen($decoded), " букв A без переноса\n";

Передаваемые строки:
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=
AAAAA
После восстановления: 80 букв A без переноса

В конце первой физической строки = вместе с CRLF означает мягкий перенос. Получатель его удаляет, поэтому исходная строка остаётся непрерывной. Настоящий перевод строки тела и служебный мягкий перенос имеют разный смысл. Длинная запись показана целиком, чтобы можно было увидеть границу.

<?php
$body = 'Caf=C3=A9=3D12';
$text = quoted_printable_decode($body);
echo 'Текст письма: ', $text, "\n";

Текст письма: Café=12

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

<?php
$body = "Заказ BR=\r\n41 готов";
echo quoted_printable_decode($body), "\n";
echo quoted_printable_decode("..stock\r\n"), "Конец\n";

Заказ BR41 готов
..stock
Конец

=CRLF внутри BR41 убирается целиком. Обычный CRLF после ..stock остаётся, как и обе точки: снятие SMTP dot-stuffing — отдельный транспортный шаг. Первая строка демонстрирует именно мягкий перенос; для совместимой отправки исходные русские байты закодирует quoted_printable_encode.

<?php
$record = "BR41;12\n";
$encoded = convert_uuencode($record);
echo "Транспортный блок:\n", $encoded;
echo "Восстановленный текст:\n", convert_uudecode($encoded);

Транспортный блок:
(0E(T,3LQ,@H`
`
Восстановленный текст:
BR41;12

Строки с обратными кавычками и переводами строки являются частью формата, а не PHP-кодом. Не удаляйте их через trim. Функция возвращает только блок данных: строки begin/end с именем и правами файла она не добавляет. В новом протоколе следует использовать оговорённый им формат, часто Base64, а не выбирать uuencode случайно.

<?php
$contents = file_get_contents(__DIR__ . '/stock.txt');
if ($contents === false) {
    throw new RuntimeException('Выгрузка не прочитана');
}
$encoded = convert_uuencode($contents);
echo "Блок для старого получателя:\n", $encoded;
echo 'Исходных байтов: ', strlen($contents), "\n";
echo 'Байтов в блоке: ', strlen($encoded), "\n";

Блок для старого получателя:
(0E(T,3LQ,@H`
`
Исходных байтов: 8
Байтов в блоке: 16

Файл stock.txt приложен к примеру. В коротком блоке доля служебных символов велика; на длинных данных увеличение составляет примерно треть. Чтение целиком подходит только для ограниченного небольшого файла. Ни сетевой отправки, ни защиты от подделки здесь нет.

<?php
$encoded = "(0E(T,3LQ,@H`\n`\n";
$decoded = convert_uudecode($encoded);
if ($decoded === false) {
    throw new RuntimeException('Блок uuencode не прочитан');
}
echo "Восстановленная запись:\n", $decoded;

Восстановленная запись:
BR41;12

Сначала проверяется именно === false. Пустая строка может быть корректным декодированным содержимым и не равна ошибке. Строк begin/end полного контейнера здесь нет: их нельзя передавать этой функции как часть полезного блока.

<?php
$encoded = "(0E(T,3LQ,@H`\n`\n";
$record = convert_uudecode($encoded);
if ($record === false) {
    throw new RuntimeException('Повреждён транспортный блок');
}
$fields = explode(';', rtrim($record, "\r\n"));
if (count($fields) !== 2 || $fields[0] === '' || !ctype_digit($fields[1])) {
    throw new RuntimeException('Нужны код товара и неотрицательный остаток');
}
echo 'Товар: ', $fields[0], "\n";
echo 'Остаток: ', $fields[1], " шт.\n";

Товар: BR41
Остаток: 12 шт.

Это две разные задачи: uudecode снимает представление, explode разделяет уже известный простой формат. Мы проверили число полей и десятичные цифры; в настоящем импорте дополнительно ограничивают длину/диапазон и проверяют товар по каталогу. Формат с кавычками и разделителями внутри значений требует CSV-парсера.

<?php
set_error_handler(function (int $level): bool {
    return $level === E_WARNING;
});
try {
    $broken = convert_uudecode('~');
} finally {
    restore_error_handler();
}
echo $broken === false ? "Повреждённый блок отклонён\n" : "Блок прочитан\n";
$empty = convert_uudecode("`\n");
echo $empty === '' ? "Пустой блок прочитан: данных нет\n" : "Другой результат\n";

Повреждённый блок отклонён
Пустой блок прочитан: данных нет

Повреждённый вызов намеренно изолирован временным обработчиком E_WARNING, чтобы в учебном результате было понятное сообщение. В рабочем импорте ошибка также попадает в закрытый журнал. Полученные имена файлов и пути никогда не должны автоматически определять место записи на сервере.