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

<?php
$name = '  Кисть широкая  ';
$clean = trim($name);
echo 'До: [', $name, "]\n";
echo 'После: [', $clean, "]\n";

До: [  Кисть широкая  ]
После: [Кисть широкая]

Скобки [] в выводе — видимые границы. $name хранит исходную строку, $clean — ответ функции. В вызове trim($name) $name является аргументом. Чтобы заменить исходное значение, присвойте ответ обратно: $name = trim($name).

<?php
$enteredCodes = ['  0  ', '   ', '  TOOL-7  '];
foreach ($enteredCodes as $enteredCode) {
    $code = trim($enteredCode);
    if ($code === '') {
        echo "Укажите код товара\n";
    } else {
        echo 'Ищем товар: ', $code, "\n";
    }
}

Ищем товар: 0
Укажите код товара
Ищем товар: TOOL-7

Три строки изображают три отдельных ввода. foreach берёт их по очереди. Проверка === '' означает именно пустую строку. empty($code) признала бы строку "0" пустой, хотя для нашего каталога это допустимый код. Если данные пришли из формы, перед trim отдельно проверяют is_string: злоумышленник может отправить code[]=... вместо строки.

<?php
$file = 'music.csv';
echo trim($file, '.csv'), "\n";
if (str_ends_with($file, '.csv')) {
    echo substr($file, 0, -4), "\n";
}

musi
music

Во втором аргументе trim каждая из букв c, s, v и точка — отдельный удаляемый байт. После .csv исчезает и последняя c из music. Проверка точного суффикса и substr снимают ровно четыре байта .csv. Это задача извлечения части строки, а не очистки пробелов.

<?php
$name = "\u{00A0}Кисть\u{00A0}";
echo 'После trim осталось байтов: ', strlen(trim($name)), "\n";
echo 'После mb_trim: [', mb_trim($name, encoding: 'UTF-8'), "]\n";

После trim осталось байтов: 14
После mb_trim: [Кисть]

Здесь \u{00A0} в двойных кавычках задаёт неразрывный пробел: визуально он похож на обычный. "Кисть" занимает 10 байтов UTF-8, ещё четыре дают два таких пробела. mb_trim доступна с PHP 8.4 при включённом mbstring. Не удаляйте все невидимые символы из любого текста без правила: переносы и некоторые символы могут быть значимыми.

<?php
$text = 'инструменты,малярные';
$tags = explode(',', $text);
echo 'Первый тег: ', $tags[0], "\n";
echo 'Второй тег: ', $tags[1], "\n";

Первый тег: инструменты
Второй тег: малярные

Первым передаётся разделитель, вторым исходный текст. Переменная $tags уже содержит массив, а запись [0] берёт первый его элемент. Запятая в результат не входит. Здесь два поля гарантированы нашей строкой; для внешних данных число полей проверяют.

<?php
$text = ' инструменты, ,малярные,0 ';
$tags = [];
foreach (explode(',', $text) as $part) {
    $tag = trim($part);
    if ($tag !== '') {
        $tags[] = $tag;
    }
}
echo 'Теги: ', implode(' / ', $tags), "\n";

Теги: инструменты / малярные / 0

explode только разделяет, trim обрабатывает каждый фрагмент, if пропускает пустые фрагменты, [] добавляет оставшийся тег в новый массив. Строка "0" сохранена намеренно. implode собирает результат для подписи. Уникальность тегов и ограничение их количества — отдельные требования.

<?php
$record = 'note=ширина=50 мм';
$parts = explode('=', $record, 2);
if (count($parts) === 2) {
    echo 'Поле: ', $parts[0], "\n";
    echo 'Значение: ', $parts[1], "\n";
}
echo '[', implode('|', explode(';', 'A;;')), "]\n";
echo implode('|', explode('/', 'exports/2026/stock.csv', -1)), "\n";

Поле: note
Значение: ширина=50 мм
[A||]
exports|2026

limit=2 разрешает не более двух частей: всё после первого = остаётся во второй. В A;; два пустых хвостовых поля сохраняются. Отрицательный limit=-1 исключает последнюю часть; если частей недостаточно, результатом будет пустой массив. Пустой разделитель вызывает ValueError — для разбиения на символы предназначены другие функции.

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

В заказе: Кисть, Валик, Лента
[]
TOOL-42

[] задаёт массив. Разделитель относится к промежутку между значениями, поэтому после последнего товара запятая не появляется. Пустой массив даёт пустую строку. Одноаргументный вызов соединяет без разделителя.

<?php
$stock = ['Кисть' => 8, 'Валик' => 0];
$lines = ['Остатки на складе:'];
foreach ($stock as $name => $quantity) {
    $lines[] = $name . ': ' . $quantity . ' шт.';
}
$message = implode("\n", $lines);
echo $message, "\n";

Остатки на складе:
Кисть: 8 шт.
Валик: 0 шт.

На каждой итерации создаётся готовая строка отчёта. Точка . соединяет её части, [] добавляет строку в массив. В конце implode соединяет строки переводами строк. Так получают тело обычного текстового письма или уведомления; отправки в сеть в примере нет. Для HTML, Telegram HTML/Markdown и CSV требуются правила соответствующего формата.

<?php
$title = 'Кисть';
echo 'Текст: ', $title, "\n";
echo 'Байтов: ', strlen($title), "\n";
echo 'Букв в этом слове: ', mb_strlen($title, 'UTF-8'), "\n";

Текст: Кисть
Байтов: 10
Букв в этом слове: 5

strlen получает строку и возвращает целое число, а echo показывает это число вместе с подписью. Для mb_strlen нужно расширение mbstring. Кодовая точка не всегда равна видимому знаку: буква с отдельным комбинируемым ударением может состоять из двух точек; для таких задач есть grapheme_strlen.

<?php
$commands = ['TEMP=21.5', 'DISPLAY=Кисть', "A\0B"];
$maxBytes = 12;
foreach ($commands as $command) {
    $bytes = strlen($command);
    if ($bytes > $maxBytes) {
        echo 'Не отправляем: ', $bytes, ' байтов при лимите ', $maxBytes, "\n";
    } else {
        echo 'Пакет помещается: ', $bytes, " байтов\n";
    }
}

Пакет помещается: 9 байтов
Не отправляем: 18 байтов при лимите 12
Пакет помещается: 3 байтов

Мы проверяем уже сформированную команду, включая DISPLAY=. NUL в A\0B — полноценный байт PHP-строки: размер равен трём. Пример принимает решение до отправки, сам сеть не использует. Проверка strlen после чтения огромного файла не отменяет уже потраченную память: размер входа ограничивают ещё при чтении.

<?php
echo 'Пустой текст: ', strlen(''), "\n";
echo 'Текст 0: ', strlen('0'), "\n";
echo 'Один пробел: ', strlen(' '), "\n";

Пустой текст: 0
Текст 0: 1
Один пробел: 1

Функция не решает, заполнено ли поле по правилам вашей формы. Пробел имеет размер, но имя только из пробелов обычно отклоняют после trim. Нулевой размер — обычный ответ, а не ошибка. Не делите длину UTF-8 на два: латинские буквы, русские буквы и emoji занимают разное число байтов.

<?php
$title = 'Кисть';
echo 'Название: ', $title, "\n";
echo 'Кодовых точек: ', mb_strlen($title, 'UTF-8'), "\n";
echo 'Байтов: ', strlen($title), "\n";

Название: Кисть
Кодовых точек: 5
Байтов: 10

Второй аргумент сообщает, как прочитать байты; он не перекодирует строку. Возвращённое число не изменяет $title. Здесь каждая русская буква — одна кодовая точка и два байта, но это не правило для любого текста: emoji и сочетания знаков устроены иначе.

<?php
$limit = 10;
foreach (['Кисть', 'Кисть широкая'] as $title) {
    $length = mb_strlen($title, 'UTF-8');
    if ($length > $limit) {
        echo $title, ': сократите на ', $length - $limit, " кодовые точки\n";
    } else {
        echo $title, ': подходит, осталось ', $limit - $length, " до лимита\n";
    }
}

Кисть: подходит, осталось 5 до лимита
Кисть широкая: сократите на 3 кодовые точки

Пробел между словами тоже считается. Условие не обрезает данные незаметно: пользователь получает причину отказа. В настоящей форме сначала проверяют, что поле является строкой корректного UTF-8, а размер запроса ограничивают до этой операции. Для лимита именно видимых знаков нужна графемная функция.

<?php
$single = 'é';
$combined = "e\u{0301}";
echo 'Одна кодовая точка: ', mb_strlen($single, 'UTF-8'), "\n";
echo 'Буква и отдельное ударение: ', mb_strlen($combined, 'UTF-8'), "\n";
echo 'Видимых графем во втором варианте: ', grapheme_strlen($combined), "\n";

Одна кодовая точка: 1
Буква и отдельное ударение: 2
Видимых графем во втором варианте: 1

\u{0301} задаёт отдельный комбинируемый знак. mb_strlen правильно видит две кодовые точки, хотя человек воспринимает одну букву с акцентом. grapheme_strlen принадлежит intl. Требование «20 символов» сначала уточняют: байтов, кодовых точек или графем.

<?php
$code = 'ORDER-0042';
$number = substr($code, 6);
echo 'Номер: ', $number, "\n";
echo 'Префикс: ', substr($code, 0, 5), "\n";
echo 'Последние две цифры: ', substr($code, -2), "\n";

Номер: 0042
Префикс: ORDER
Последние две цифры: 42

Второй аргумент — откуда начать, третий — сколько байтов взять. Нумерация начинается с нуля. Отрицательное начало -2 означает два байта от конца. substr ничего не преобразует в число и не удаляет нули.

<?php
$name = 'stock.csv';
echo '[', substr($name, 0, 0), "]\n";
echo '[', substr($name, 50), "]\n";
echo '[', substr($name, 0, -4), "]\n";

[]
[]
[stock]

Нулевая длина и начало за концом дают пустую строку в PHP 8. Отрицательная длина -4 оставляет четыре последних байта вне результата. В реальной обработке сначала проверяют str_ends_with($name, ".csv"), иначе у имени без расширения тоже отрежутся четыре полезных байта.

<?php
$title = 'Кисть широкая';
$maxLetters = 5;
if (mb_strlen($title, 'UTF-8') > $maxLetters) {
    $preview = mb_substr($title, 0, $maxLetters, 'UTF-8') . '…';
} else {
    $preview = $title;
}
echo $preview, "\n";

Кисть…

Здесь нужен именно mb_substr: substr($title, 0, 5) остановился бы посередине UTF-8-буквы. Многоточие добавляется только при сокращении. Для сочетаний emoji и комбинируемых знаков переходят к grapheme_substr. Эта функция готовит обычный текст; перед выводом в HTML его экранируют.

<?php
$title = 'Кисть широкая';
echo 'Первое слово: ', mb_substr($title, 0, 5, 'UTF-8'), "\n";
echo 'Окончание: ', mb_substr($title, -7, null, 'UTF-8'), "\n";
echo 'Полное имя: ', $title, "\n";

Первое слово: Кисть
Окончание: широкая
Полное имя: Кисть широкая

Позиции начинаются с нуля. -7 отсчитывает начало от конца, null в длине означает взять остаток. Для произвольного первого слова лучше искать пробел; здесь длина известна из учебной строки. Возвращаемый фрагмент не меняет исходник.

<?php
$limit = 8;
foreach (['Кисть', 'Кисть широкая'] as $title) {
    if (mb_strlen($title, 'UTF-8') > $limit) {
        $preview = mb_substr($title, 0, $limit - 1, 'UTF-8') . '…';
    } else {
        $preview = $title;
    }
    echo 'Превью: ', $preview, "\n";
}

Превью: Кисть
Превью: Кисть ш…

Одну кодовую точку бюджета оставили для многоточия. Короткое название не изменилось. Это текстовое превью, а не обрезание HTML: теги и составные графемы требуют иного подхода. Если требуется целое слово, сначала выбирают границу слова; функция сама её не ищет.

<?php
echo '[', mb_substr('Кисть', 0, 0, 'UTF-8'), "]\n";
echo '[', mb_substr('Кисть', 1, -1, 'UTF-8'), "]\n";
echo '[', mb_substr('Кисть', 99, null, 'UTF-8'), "]\n";

[]
[ист]
[]

Ноль выбирает пустой фрагмент. Начало 1 пропускает К, отрицательная длина -1 оставляет последнюю ь вне результата. Начало за концом также даёт пустую строку. Скобки позволяют увидеть пустой ответ.

<?php
$text = 'Кисть широкая';
$query = 'Кисть';
if (str_contains($text, $query)) {
    echo "Товар подходит\n";
} else {
    echo "Не подходит\n";
}

Товар подходит

Первым аргументом передаётся проверяемая строка, вторым критерий. if выполняет первую ветку при true, else — при false. Подстрока может находиться в любом месте; функция не проверяет границы слова. Функция сама не выводит текст и не изменяет переменные.

<?php
$items = ['Кисть широкая', 'Валик малярный', 'Кисть узкая'];
$query = 'Кисть';
foreach ($items as $item) {
    if (str_contains($item, $query)) {
        echo $item, "\n";
    }
}

Кисть широкая
Кисть узкая

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

<?php
$query = '';
var_dump(str_contains('Кисть широкая', $query));
if ($query === '') {
    echo "Введите непустой критерий\n";
}
var_dump(str_contains('PAINT-42', 'paint'));

bool(true)
Введите непустой критерий
bool(false)

По правилам этих функций пустая строка подходит любой строке. Интерфейс поиска может выбрать иное поведение, например показать подсказку. Регистр значим: PAINT и paint разные. Проверка имени .csv не доказывает формат содержимого и не делает произвольный путь безопасным.

<?php
$title = 'КИСТЬ широкая';
$query = 'кисть';
$searchTitle = mb_strtolower($title, 'UTF-8');
$searchQuery = mb_strtolower($query, 'UTF-8');
if ($searchQuery !== '' && str_contains($searchTitle, $searchQuery)) {
    echo 'Найдено: ', $title, "\n";
}

Найдено: КИСТЬ широкая

Преобразуются обе поисковые копии, а пользователю показывается исходное название. && означает «оба условия». Нужен mbstring; strtolower умеет только ASCII-регистр в современном PHP. Это простой поиск подстроки, а не морфология, исправление опечаток или учёт всех правил языкового сравнения.

<?php
$text = 'PAINT-42';
$query = 'PAINT-';
if (str_starts_with($text, $query)) {
    echo "Это малярный товар\n";
} else {
    echo "Не подходит\n";
}

Это малярный товар

Первым аргументом передаётся проверяемая строка, вторым критерий. if выполняет первую ветку при true, else — при false. Нужно совпадение строго с начала; X-PAINT-42 под это правило не подходит. Функция сама не выводит текст и не изменяет переменные.

<?php
$items = ['PAINT-42', 'X-PAINT-42', 'PAINT-58'];
$query = 'PAINT-';
foreach ($items as $item) {
    if (str_starts_with($item, $query)) {
        echo $item, "\n";
    }
}

PAINT-42
PAINT-58

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

<?php
$query = '';
var_dump(str_starts_with('PAINT-42', $query));
if ($query === '') {
    echo "Введите непустой критерий\n";
}
var_dump(str_starts_with('PAINT-42', 'paint'));

bool(true)
Введите непустой критерий
bool(false)

По правилам этих функций пустая строка подходит любой строке. Интерфейс поиска может выбрать иное поведение, например показать подсказку. Регистр значим: PAINT и paint разные. Проверка имени .csv не доказывает формат содержимого и не делает произвольный путь безопасным.

<?php
$text = 'stock.csv';
$query = '.csv';
if (str_ends_with($text, $query)) {
    echo "Имя подходит для CSV-импорта\n";
} else {
    echo "Не подходит\n";
}

Имя подходит для CSV-импорта

Первым аргументом передаётся проверяемая строка, вторым критерий. if выполняет первую ветку при true, else — при false. Суффикс должен находиться в самом конце; stock.csv.bak не подходит. Функция сама не выводит текст и не изменяет переменные.

<?php
$items = ['stock.csv', 'stock.csv.bak', 'prices.csv'];
$query = '.csv';
foreach ($items as $item) {
    if (str_ends_with($item, $query)) {
        echo $item, "\n";
    }
}

stock.csv
prices.csv

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

<?php
$query = '';
var_dump(str_ends_with('stock.csv', $query));
if ($query === '') {
    echo "Введите непустой критерий\n";
}
var_dump(str_ends_with('PAINT-42', 'paint'));

bool(true)
Введите непустой критерий
bool(false)

По правилам этих функций пустая строка подходит любой строке. Интерфейс поиска может выбрать иное поведение, например показать подсказку. Регистр значим: PAINT и paint разные. Проверка имени .csv не доказывает формат содержимого и не делает произвольный путь безопасным.

<?php
$record = 'stock=8';
$position = strpos($record, '=');
echo 'Позиция разделителя: ', $position, "\n";
echo 'Поле: ', substr($record, 0, $position), "\n";
echo 'Значение: ', substr($record, $position + 1), "\n";

Позиция разделителя: 5
Поле: stock
Значение: 8

Для этой заданной строки разделитель заведомо есть. $position + 1 пропускает сам знак =. Полученное значение "8" пока строка: проверка количества и превращение в число — следующий шаг. Для произвольного внешнего текста нужен следующий пример с проверками.

<?php
$records = ['stock=0', '=8', 'stock'];
foreach ($records as $record) {
    $position = strpos($record, '=');
    if ($position === false) {
        echo "Ошибка: нет разделителя =\n";
    } elseif ($position === 0) {
        echo "Ошибка: нет имени поля\n";
    } else {
        echo 'Принято значение: ', substr($record, $position + 1), "\n";
    }
}

Принято значение: 0
Ошибка: нет имени поля
Ошибка: нет разделителя =

=== сравнивает значение вместе с типом. false означает «не найдено», целое 0 — «найдено в начале». Проверка if (!$position) смешала бы эти случаи. Значение "0" после разделителя допустимо: оно не потеряно.

<?php
$record = 'A|B|C';
$first = strpos($record, '|');
$second = strpos($record, '|', $first + 1);
echo 'Первая граница: ', $first, "\n";
echo 'Следующая граница: ', $second, "\n";
echo 'Граница в русском тексте: ', strpos('Я=8', '='), "\n";
echo 'Поиск с конца: ', strpos('A|B|C', '|', -2), "\n";

Первая граница: 1
Следующая граница: 3
Граница в русском тексте: 2
Поиск с конца: 3

Третий аргумент задаёт, откуда искать, но ответ всё равно отсчитывается от начала строки. Я занимает два байта UTF-8, поэтому = имеет позицию 2. Пустая искомая строка допускается с PHP 8; смещение за допустимыми границами вызывает ValueError. Для простого «есть/нет» удобнее str_contains.

<?php
$text = 'Доставка: курьером';
$updated = str_replace('курьером', 'в пункт выдачи', $text);
echo $updated, "\n";
echo 'Исходная подпись: ', $text, "\n";

Доставка: в пункт выдачи
Исходная подпись: Доставка: курьером

Аргументы идут в порядке «что найти, на что заменить, где искать». Результат возвращается, а не выводится сам. В настоящем заказе способ доставки хранят отдельным значением; этот пример показывает изменение текста, а не замену данных в базе.

<?php
$imported = "Кисть\r\nВалик\rЛента\n";
$changes = 0;
$normalized = str_replace(["\r\n", "\r"], "\n", $imported, $changes);
echo $normalized;
echo 'Нормализовано переносов: ', $changes, "\n";

Кисть
Валик
Лента
Нормализовано переносов: 2

Массив первого аргумента перечисляет два вида переноса. Сначала CRLF заменяется на LF, затем одиночный CR — тоже на LF. Если поменять порядок, CRLF превратится в два перевода строки. $changes получает число замен: функция записывает в эту переменную, хотя & в месте вызова не пишется.

<?php
$template = 'Покупатель: {name}. Заказ: {order}';
$name = 'Мастерская {order}';
echo str_replace(['{name}', '{order}'], [$name, '42'], $template), "\n";
echo strtr($template, ['{name}' => $name, '{order}' => '42']), "\n";

Покупатель: Мастерская 42. Заказ: 42
Покупатель: Мастерская {order}. Заказ: 42

str_replace проходит поисковые строки последовательно и меняет {order}, появившуюся из имени покупателя. strtr с картой не ищет повторно внутри вставленного текста и сохраняет исходное имя. Это реальная причина выбрать иной инструмент, а не писать более сложный цикл.

<?php
$labels = ['old-photo', 'old-price', 'unused-note'];
$count = 0;
$updated = str_replace(['old-', 'unused-'], ['new-'], $labels, $count);
echo implode(', ', $updated), "\n";
echo 'Замен: ', $count, "\n";

new-photo, new-price, note
Замен: 3

Строки внутри массива обрабатываются отдельно, результат тоже массив. Список замен короче списка поиска: для unused- недостающая замена равна пустой строке. Не используйте эту особенность случайно — согласуйте таблицу замен заранее.

<?php
$template = 'Заказ {order}: {state}';
$values = ['{order}' => '42', '{state}' => 'готов к выдаче'];
$message = strtr($template, $values);
echo $message, "\n";

Заказ 42: готов к выдаче

Карта — массив пар «что найти => на что заменить». Фигурные скобки здесь обычные символы выбранного нами шаблона, у strtr нет специального языка шаблонов. Скобки помогают не заменить случайное слово order в остальном тексте.

<?php
$template = '{name}: ваш заказ {order} готов.';
$message = strtr($template, [
    '{name}' => 'Мастерская {order}',
    '{order}' => '42',
]);
echo $message, "\n";
echo strtr('{known} / {missing}', ['{known}' => 'Есть']), "\n";

Мастерская {order}: ваш заказ 42 готов.
Есть / {missing}

Вставленное имя остаётся буквальным. Неизвестная {missing} сохраняется: функция не проверяет полноту заполнения шаблона. В приложении список обязательных меток известен заранее; отсутствие значения обрабатывают до отправки. В HTML значения экранируют для места вывода, а в обычном тексте HTML-сущности не нужны.

<?php
echo strtr('AB A', ['A' => 'короткий', 'AB' => 'длинный']), "\n";
echo strtr('TOOL_42/BLUE', '_/', '--'), "\n";

длинный короткий
TOOL-42-BLUE

В карте более длинный ключ проверяется раньше короткого: AB не превращается в «короткийB». В трёхаргументной форме _ сопоставлен первому -, / — второму -. Здесь меняются отдельные байты, поэтому она подходит для выбранных ASCII-разделителей, но не для транслитерации русских букв.

<?php
$name = 'X-Request-Id';
$key = strtolower($name);
echo 'Ключ: ', $key, "\n";
echo 'Исходное имя: ', $name, "\n";

Ключ: x-request-id
Исходное имя: X-Request-Id

Меняются ASCII-буквы, исходная строка остаётся прежней. Функция не убирает пробелы и не проверяет, разрешён ли такой заголовок.

<?php
$headers = ['Content-Type' => 'application/json', 'X-Request-ID' => 'AbC42'];
$normalized = [];
foreach ($headers as $name => $value) {
    $normalized[strtolower($name)] = $value;
}
echo 'Идентификатор: ', $normalized['x-request-id'], "\n";
echo 'Русская строка: ', strtolower('КИСТЬ'), "\n";

Идентификатор: AbC42
Русская строка: КИСТЬ

Преобразуются ключи, а не значения: AbC42 сохранён. Это небольшой словарь без повторных заголовков, не полноценный HTTP-парсер. Если одно имя встречается многократно, требуется отдельное правило объединения. Для русского регистра есть mb_strtolower; обычный strtolower в PHP 8.2+ от локали не зависит.

<?php
$title = 'КИСТЬ';
echo mb_strtolower($title, 'UTF-8'), "\n";
echo 'Оригинал: ', $title, "\n";

кисть
Оригинал: КИСТЬ

Функция возвращает строку, не переписывает переменную. Явный UTF-8 сообщает кодировку входа. Числа и пунктуация не становятся буквами; регистр не зависит от setlocale.

<?php
$query = mb_strtolower('КИСТЬ', 'UTF-8');
$titles = ['Молоток', 'Кисть широкая', 'Валик'];
foreach ($titles as $title) {
    if (str_contains(mb_strtolower($title, 'UTF-8'), $query)) {
        echo 'Найдено: ', $title, "\n";
    }
}

Найдено: Кисть широкая

str_contains ищет точную последовательность уже подготовленных байтов; обе строки здесь корректный UTF-8. Поиск не требует вычисления позиции, поэтому этого достаточно. Это небольшой список: в большой базе используют её индекс и согласованные правила сравнения. Для общего Unicode-сопоставления рассмотрите MB_CASE_FOLD, а пустой запрос обработайте отдельно.

<?php
echo mb_strtolower('ΟΣ', 'UTF-8'), "\n";
echo mb_convert_case('ΟΣ', MB_CASE_LOWER_SIMPLE, 'UTF-8'), "\n";

ος
οσ

В современном полном lowercase конечная Σ получает форму ς; simple-режим не использует это контекстное правило. Такие различия важны для многоязычных ключей поиска. Не делайте вывод, что любое визуально похожее слово даст одинаковые байты.

<?php
$message = sprintf('Заказ № %04d: %s — %d шт.', 42, 'Кисть', 3);
echo $message, "\n";

Заказ № 0042: Кисть — 3 шт.

%d принимает целое, %s — строковое представление, %04d задаёт минимальную ширину четыре с заполнением нулями. Данные передаются по порядку после шаблона. Шаблон остаётся одним понятным предложением, а меняющиеся значения хранятся отдельно.

<?php
$template = 'Заказ %1$d готов. Назовите номер %1$d при получении. %2$s';
echo sprintf($template, 42, 'Пункт выдачи: Северный.'), "\n";
echo sprintf('Готовность: %d%%', 80), "\n";
echo sprintf('Измерение: %.2F', 12.5), "\n";

Заказ 42 готов. Назовите номер 42 при получении. Пункт выдачи: Северный.
Готовность: 80%
Измерение: 12.50

1$ и 2$ явно выбирают аргументы; шаблон в одинарных кавычках, чтобы PHP не интерпретировал $. %% выводит один знак процента. %.2F даёт две цифры после точки независимо от локали; %f может зависеть от LC_NUMERIC. Подробная грамматика ширины, точности и флагов находится в этой же книге.

<?php
try {
    echo sprintf('Товар: %s, количество: %d', 'Кисть');
} catch (ArgumentCountError) {
    echo "Для шаблона не передано количество\n";
}
echo sprintf('Комментарий: %s', 'Скидка 20%'), "\n";

Для шаблона не передано количество
Комментарий: Скидка 20%

Обработчик демонстрирует ошибку: в рабочем коде нужно исправить набор аргументов. Процент внутри отдельного значения безопасен для синтаксиса шаблона, потому что значение повторно не разбирается. Не принимайте произвольный пользовательский текст как формат; для буквального текста передавайте его через %s. Форматирование не экранирует HTML.

<?php
$title = 'Кабель <Pro> & крепёж';
$safeTitle = htmlspecialchars($title, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
echo '<p>', $safeTitle, "</p>\n";

<p>Кабель &lt;Pro&gt; &amp; крепёж</p>

Ожидаемый результат выше — HTML, который выдаёт PHP. Под ним показано, как его отображает браузер. <p> и </p> — разметка автора, а $title — текстовые данные. ENT_QUOTES обрабатывает оба вида кавычек; ENT_SUBSTITUTE заменяет повреждённый UTF-8 знаком замены. Знак | объединяет флаги, а UTF-8 явно задаёт кодировку.

<?php
$title = 'Кабель "Pro"';
$value = htmlspecialchars($title, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
echo '<label>Название <input readonly value="', $value, '"></label>', "\n";

<label>Название <input readonly value="Кабель &quot;Pro&quot;"></label>

Значение value заключено в двойные кавычки, а кавычки внутри названия превращены в &quot;. Поэтому Pro остаётся частью названия, а не новым атрибутом. Поле readonly добавлено только для просмотра этого результата. Для настоящей формы также нужны обработчик, проверка введённых данных и остальные шаги главы о формах.

<?php
$original = 'Кисть & валик';
$once = htmlspecialchars($original, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
$twice = htmlspecialchars($once, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
echo 'Один раз: ', $once, "\n";
echo 'Дважды: ', $twice, "\n";
echo 'Не кодировать готовые сущности: ', htmlspecialchars($once, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8', false), "\n";

Один раз: Кисть & валик
Дважды: Кисть & валик
Не кодировать готовые сущности: Кисть & валик

В браузере второй вариант покажет буквальное &amp; вместо одного &. Обычная схема — хранить исходный текст и экранировать один раз в нужном месте вывода. double_encode=false подходит осознанному формату, где уже разрешены сущности; он не исправляет неизвестную смесь слоёв. Если пользователь действительно написал буквальные символы &amp;, изменение этого параметра меняет его текст.

<?php
$broken = "Кисть \xC3(";
echo htmlspecialchars($broken, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'), "\n";
echo '[', htmlspecialchars($broken, ENT_QUOTES, 'UTF-8'), "]\n";

Кисть �(
[]

Байт C3 требует продолжения UTF-8, а вместо него пришла (. С ENT_SUBSTITUTE плохая последовательность видна как �; без него в этом примере возвращается пустая строка. Это защита вывода, а причину повреждения источника ещё нужно найти. Функция не готовит данные для SQL, JavaScript, CSS или shell: там другие правила.