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

<?php
$quantity = filter_var('3', FILTER_VALIDATE_INT);
var_dump($quantity);
var_dump(filter_var('three', FILTER_VALIDATE_INT));

int(3)
bool(false)

Валидация не удаляла буквы, чтобы угадать число. Она вернула специальный результат отказа. $quantity содержит число; вывод — отдельное действие var_dump.

<?php
var_dump(filter_var('bad', FILTER_VALIDATE_INT));
var_dump(filter_var('bad', FILTER_VALIDATE_INT, FILTER_NULL_ON_FAILURE));
var_dump(filter_var('bad', FILTER_VALIDATE_INT, ['options' => ['default' => 5]]));
var_dump(filter_var('bad', FILTER_VALIDATE_INT, ['flags' => FILTER_NULL_ON_FAILURE, 'options' => ['default' => 5]]));

bool(false)
NULL
int(5)
int(5)

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

<?php
var_dump(filter_var(['2'], FILTER_VALIDATE_INT));
echo json_encode(filter_var(['2', 'bad'], FILTER_VALIDATE_INT, FILTER_REQUIRE_ARRAY)), "\n";
echo json_encode(filter_var('bad', FILTER_VALIDATE_INT, FILTER_FORCE_ARRAY)), "\n";
var_dump(filter_var('2', FILTER_VALIDATE_INT, FILTER_REQUIRE_ARRAY));

bool(false)
[2,false]
[false]
bool(false)

FILTER_REQUIRE_SCALAR — стандартное требование скаляра. REQUIRE_ARRAY требует массив. FORCE_ARRAY оборачивает скалярный результат; он не доказывает успех и не заменяет проверку всех элементов.

<?php
$_GET['qty'] = '8';
var_dump(filter_var($_GET['qty'], FILTER_VALIDATE_INT));
var_dump(filter_input(INPUT_GET, 'qty', FILTER_VALIDATE_INT));
var_dump(filter_has_var(INPUT_GET, 'qty'));

int(8)
NULL
bool(false)

Этот опыт намеренно CLI. Настоящий сценарий исходного GET с изменением $_GET находится в карточке filter_input и проверяется HTTP-запросом.

<?php
function readQuantity($data) {
    if (!array_key_exists('qty', $data)) { return null; }
    return filter_var($data['qty'], FILTER_VALIDATE_INT);
}
var_dump(readQuantity(['qty' => '8']));
var_dump(readQuantity([]));
var_dump(readQuantity(['qty' => 'bad']));

int(8)
NULL
bool(false)

Для тестов бизнес-правила удобен обычный массив. array_key_exists проверяет наличие ключа, return немедленно отдаёт результат. Внешний HTTP-адаптер отдельно передаст нужные данные.

<?php
$rule = ['options' => ['min_range' => 0, 'max_range' => 50]];
var_dump(filter_var(' 12 ', FILTER_VALIDATE_INT, $rule));
var_dump(filter_var('0', FILTER_VALIDATE_INT, $rule));
var_dump(filter_var('51', FILTER_VALIDATE_INT, $rule));
var_dump(filter_var('12.0', FILTER_VALIDATE_INT, $rule));

int(12)
int(0)
bool(false)
bool(false)

min_range и max_range включают границы. Десятичная дробная запись 12.0 не является допустимой записью целого для этого фильтра.

<?php
declare(strict_types=1);

$enteredPage = '3';
$page = filter_var($enteredPage, FILTER_VALIDATE_INT, [
    'options' => ['min_range' => 1, 'max_range' => 100],
]);
if ($page === false) {
    echo "Номер страницы должен быть от 1 до 100\n";
} else {
    $perPage = 20;
    $offset = ($page - 1) * $perPage;
    echo 'Страница ', $page, ': пропустить ', $offset, ', взять ', $perPage, " товаров\n";
}

Страница 3: пропустить 40, взять 20 товаров

После проверки $page — целое число, и его можно использовать в арифметике. Первые две страницы по 20 товаров занимают 40 позиций. В следующей SQL-ступени offset и perPage передают как целые параметры запроса, а не склеивают исходный пользовательский текст с SQL. Проверка диапазона одновременно защищает от отрицательного смещения и неограниченного размера пагинации; лимит выбирает приложение.

<?php
var_dump(filter_var('010', FILTER_VALIDATE_INT));
var_dump(filter_var('010', FILTER_VALIDATE_INT, FILTER_FLAG_ALLOW_OCTAL));
var_dump(filter_var('0x10', FILTER_VALIDATE_INT, FILTER_FLAG_ALLOW_HEX));
var_dump(filter_var('bad', FILTER_VALIDATE_INT, ['options' => ['default' => 1]]));

bool(false)
int(8)
int(16)
int(1)

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

<?php
var_dump(filter_var('off', FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE));
var_dump(filter_var('YES', FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE));
var_dump(filter_var('maybe', FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE));

bool(false)
bool(true)
NULL

Сравнение === null выявляет неверную настройку. if (!$value) ошибочно объединило бы выключение и ошибку.

<?php
declare(strict_types=1);

foreach (['off', 'YES', 'maybe'] as $raw) {
    $enabled = filter_var($raw, FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE);
    if ($enabled === null) {
        echo $raw, ": ошибка настройки, уведомления не запускаем\n";
    } elseif ($enabled) {
        echo $raw, ": уведомления включены\n";
    } else {
        echo $raw, ": уведомления выключены\n";
    }
}

off: уведомления выключены
YES: уведомления включены
maybe: ошибка настройки, уведомления не запускаем

Такую строку можно получить из переменной окружения или файла конфигурации. Сначала проверяется null — неизвестное слово, затем истинность уже проверенного bool. Прямое (bool) 'off' дало бы true, потому что это непустая строка. Здесь текст «off» имеет согласованный смысл выключения. Пример печатает решение; самих уведомлений он не отправляет.

<?php
function parseTwoWords($text) {
    if ($text === 'true') { return true; }
    if ($text === 'false') { return false; }
    return null;
}
var_dump(parseTwoWords('false'), parseTwoWords('yes'));
var_dump(filter_var('yes', FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE));

bool(false)
NULL
bool(true)

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

<?php
var_dump(filter_var(0x1, FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE));
var_dump(filter_var('0x1', FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE));
var_dump(filter_var(1e0, FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE));
var_dump(filter_var('1e0', FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE));

bool(true)
NULL
bool(true)
NULL

0x1 без кавычек — числовая запись единицы в PHP; 1e0 — float 1.0. В фильтр входят уже числа, которые превращаются в "1". Строки "0x1"/"1e0" не входят в разрешённый словарь BOOL. То же различие относится к двоичной/восьмеричной записи чисел 0 и 1.

<?php
var_dump(filter_var('12,75', FILTER_VALIDATE_FLOAT));
var_dump(filter_var('12,75', FILTER_VALIDATE_FLOAT, ['options' => ['decimal' => ',']]));
var_dump(filter_var('1.5e2', FILTER_VALIDATE_FLOAT));

bool(false)
float(12.75)
float(150)

Научная запись разрешена самим валидатором FLOAT. FILTER_FLAG_ALLOW_SCIENTIFIC относится к числовому санитайзеру, не нужен здесь.

<?php
declare(strict_types=1);

$readings = ['22,5', '-3,2', 'warm'];
$options = ['options' => ['decimal' => ',', 'min_range' => -40, 'max_range' => 85]];
foreach ($readings as $raw) {
    $temperature = filter_var($raw, FILTER_VALIDATE_FLOAT, $options);
    if ($temperature === false) {
        echo $raw, ": измерение отклонено\n";
        continue;
    }
    echo $raw, ' -> ', $temperature, " °C; записать в отчёт\n";
}

22,5 -> 22.5 °C; записать в отчёт
-3,2 -> -3.2 °C; записать в отчёт
warm: измерение отклонено

Договор источника явно использует запятую. Фильтр превращает допустимую запись в число, а не просто заменяет запятую точкой. Метка «записать» показывает дальнейшее действие, сам файл пока не создаётся. Для датчика ещё важны время измерения, единицы и разумный диапазон. Поведение float не даёт точной десятичной арифметики для денег; здесь измерения имеют ограниченную точность изначально.

<?php
$options = [
    'flags' => FILTER_FLAG_ALLOW_THOUSAND,
    'options' => ['min_range' => 0, 'max_range' => 2000],
];
var_dump(filter_var('1,234.5', FILTER_VALIDATE_FLOAT, $options));
var_dump(filter_var('2,500.0', FILTER_VALIDATE_FLOAT, $options));
try {
    filter_var('1.2', FILTER_VALIDATE_FLOAT, ['options' => ['decimal' => '..']]);
} catch (ValueError $error) {
    echo "Разделитель должен быть одним символом\n";
}

float(1234.5)
bool(false)
Разделитель должен быть одним символом

min_range/max_range у FLOAT доступны с PHP 7.4. try/catch здесь показывает ошибку настроек программы, а не допустимую реакцию на любую сумму.

<?php
$options = ['options' => ['regexp' => '/\AWH-[0-9]{2}\z/']];
var_dump(filter_var('WH-42', FILTER_VALIDATE_REGEXP, $options));
var_dump(filter_var('prefix-WH-42', FILTER_VALIDATE_REGEXP, $options));

string(5) "WH-42"
bool(false)

/…/ ограничивает шаблон; \A и \z задают начало и конец всей строки, [0-9]{2} — ровно две ASCII-цифры. Это объяснение формата, не замена главе о регулярных выражениях.

<?php
declare(strict_types=1);

$warehouses = ['WH-42' => 'Склад инструментов'];
$options = ['options' => ['regexp' => '/\AWH-[0-9]{2}\z/']];
foreach (['WH-42', 'WH-99', '42'] as $entered) {
    $code = filter_var($entered, FILTER_VALIDATE_REGEXP, $options);
    if ($code === false) {
        echo $entered, ": нужен формат WH-42\n";
    } elseif (!array_key_exists($code, $warehouses)) {
        echo $code, ": такого склада в справочнике нет\n";
    } else {
        echo $code, ': ', $warehouses[$code], "\n";
    }
}

WH-42: Склад инструментов
WH-99: такого склада в справочнике нет
42: нужен формат WH-42

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

<?php
$text = 'ticket: WH-42';
var_dump(filter_var($text, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => '/WH-[0-9]{2}/']]));
var_dump(filter_var($text, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => '/\AWH-[0-9]{2}\z/']]));

string(13) "ticket: WH-42"
bool(false)

Фильтр возвращает весь вход, а не найденный фрагмент. Для извлечения групп нужен preg_match с массивом matches.

<?php
var_dump(filter_var('https://example.org/report', FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED));
var_dump(filter_var('https://example.org', FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED));
var_dump(filter_var('https://example.org/?page=2', FILTER_VALIDATE_URL, FILTER_FLAG_QUERY_REQUIRED));

string(26) "https://example.org/report"
bool(false)
string(27) "https://example.org/?page=2"

PATH_REQUIRED требует путь, QUERY_REQUIRED — query-часть. Это не проверка существования страницы.

<?php
declare(strict_types=1);

$entered = 'https://example.test/about?lang=ru&view=full';
$url = filter_var($entered, FILTER_VALIDATE_URL);
if ($url === false || parse_url($url, PHP_URL_SCHEME) !== 'https') {
    echo '<p>Укажите полный HTTPS-адрес.</p>';
} else {
    echo '<a href="', htmlspecialchars($url, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'), '">Сайт автора</a>';
}

<a href="https://example.test/about?lang=ru&amp;view=full">Сайт автора</a>

Здесь URL нужен как ссылка в HTML, сервер сам по нему не обращается. Валидатор проверяет запись, parse_url выделяет схему, а htmlspecialchars защищает границы кавычечного HTML-атрибута. Амперсанд из query записан как & в исходнике страницы; браузер передаст обычный & при переходе. Домен example.test учебный, его существование не проверялось. Если по пользовательскому адресу должен обращаться сам сервер, нужен отдельный сетевой договор и защита от SSRF.

<?php
function supplierUrl($text) {
    $url = filter_var($text, FILTER_VALIDATE_URL);
    if ($url === false || parse_url($url, PHP_URL_SCHEME) !== 'https') {
        return null;
    }
    return $url;
}
var_dump(supplierUrl('https://example.org/api'));
var_dump(supplierUrl('ftp://example.org/file'));

string(23) "https://example.org/api"
NULL

parse_url выделяет компонент, сам по себе не является полноценным валидатором. Это правило формы, а не завершённая защита сетевого клиента от SSRF: запросы здесь не выполняются.

<?php
var_dump(filter_var('unknown-app://example', FILTER_VALIDATE_URL) !== false);
var_dump(filter_var('http://127.0.0.1', FILTER_VALIDATE_URL) !== false);
var_dump(filter_var('mailto:team@example.org', FILTER_VALIDATE_URL) !== false);

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

Это только проверки строк. Не выполняется ни запрос на localhost, ни отправка письма, ни запуск неизвестной схемы.

<?php
var_dump(filter_var('smtp.example.org', FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME));
var_dump(filter_var('bad host', FILTER_VALIDATE_DOMAIN));
var_dump(filter_var('bad host', FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME));

string(16) "smtp.example.org"
string(8) "bad host"
bool(false)

Мягкое DOMAIN не является способом запретить опасные символы в произвольном контексте. HOSTNAME нужно выбирать по назначению поля.

<?php
declare(strict_types=1);

foreach (['smtp.example.test', 'https://smtp.example.test', 'bad host'] as $raw) {
    $host = filter_var($raw, FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME);
    if ($host === false) {
        echo $raw, ": требуется имя хоста без протокола и пробелов\n";
    } else {
        echo 'Хост: ', $host, "; порт задаётся отдельным полем\n";
    }
}

Хост: smtp.example.test; порт задаётся отдельным полем
https://smtp.example.test: требуется имя хоста без протокола и пробелов
bad host: требуется имя хоста без протокола и пробелов

Форма настройки почтового клиента часто просит host, а человек вставляет полный адрес из браузера. Сообщение объясняет различие: smtp.example.test — имя, https://... — URL. Флаг HOSTNAME нужен для строгого набора символов меток. Пример не устанавливает SMTP-соединение: DNS, доступность порта, TLS и учётные данные проверяются на следующей ступени.

<?php
$tooLong = str_repeat('a', 64) . '.example';
var_dump(filter_var($tooLong, FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME));
var_dump(filter_var('localhost', FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME));
var_dump(filter_var('-mail.example', FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME));

bool(false)
string(9) "localhost"
bool(false)

str_repeat создаёт тестовую метку. Отсутствие точки само по себе не запрещено этим фильтром; требование публичного домена — отдельная политика.

<?php
var_dump(filter_var('team+orders@example.org', FILTER_VALIDATE_EMAIL));
var_dump(filter_var('Team <team@example.org>', FILTER_VALIDATE_EMAIL));
var_dump(filter_var('team@localhost', FILTER_VALIDATE_EMAIL));

string(23) "team+orders@example.org"
bool(false)
bool(false)

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

<?php
declare(strict_types=1);

foreach (['buyer@example.test', 'buyer at example.test', 'Buyer <buyer@example.test>'] as $raw) {
    $email = filter_var($raw, FILTER_VALIDATE_EMAIL);
    if ($email === false) {
        echo 'Не принято: ', $raw, ". Введите один адрес без имени и скобок.\n";
    } else {
        echo 'Формат адреса принят: ', $email, "; владение ещё не подтверждено\n";
    }
}

Формат адреса принят: buyer@example.test; владение ещё не подтверждено
Не принято: buyer at example.test. Введите один адрес без имени и скобок.
Не принято: Buyer <buyer@example.test>. Введите один адрес без имени и скобок.

Проверка возвращает адрес, пригодный для следующего шага приложения, или false. Формат поля заранее определён как один адрес, а не строка заголовка письма с именем. Этот CLI-пример показывает исходный ввод как текст; на HTML-странице его обязательно кодируют через htmlspecialchars. Не удаляем случайные символы и не отправляем письмо «исправленному» получателю. Подтверждение адреса требует отдельного ограниченного по времени кода или ссылки.

<?php
var_dump(filter_var('почта@example.org', FILTER_VALIDATE_EMAIL) !== false);
var_dump(filter_var('почта@example.org', FILTER_VALIDATE_EMAIL, FILTER_FLAG_EMAIL_UNICODE) !== false);
var_dump(filter_var('mail@пример.рф', FILTER_VALIDATE_EMAIL, FILTER_FLAG_EMAIL_UNICODE) !== false);

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

EMAIL_UNICODE с PHP 7.1 разрешает Unicode только в части перед @. Возможности отправляющей системы и принимающего сервера нужно учитывать отдельно.

<?php
var_dump(filter_var('192.168.1.5', FILTER_VALIDATE_IP, FILTER_FLAG_IPV4));
var_dump(filter_var('192.168.1.5', FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE));
var_dump(filter_var('2001:db8::1', FILTER_VALIDATE_IP, FILTER_FLAG_IPV6));
var_dump(filter_var('192.168.1.5:80', FILTER_VALIDATE_IP));

string(11) "192.168.1.5"
bool(false)
string(11) "2001:db8::1"
bool(false)

Документационный IPv6 используется только как текстовый пример, сетевых запросов нет. IPV4/IPV6 ограничивают семейство, не доступность.

<?php
declare(strict_types=1);

$enteredAddresses = ['192.168.10.15', '192.168.10.15:8080', '999.1.2.3'];
foreach ($enteredAddresses as $raw) {
    $address = filter_var($raw, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4);
    if ($address === false) {
        echo $raw, ": неверная запись IPv4; порт укажите отдельно\n";
    } else {
        echo 'Карточка датчика: IP ', $address, "\n";
    }
}

Карточка датчика: IP 192.168.10.15
192.168.10.15:8080: неверная запись IPv4; порт укажите отдельно
999.1.2.3: неверная запись IPv4; порт укажите отдельно

Частный адрес здесь уместен: приложение ведёт оборудование внутренней сети. Добавление NO_PRIV_RANGE сломало бы задачу, поэтому набор флагов выбирают по назначению. Проверка не ищет датчик и не соединяется с ним. Для журнала запросов адрес клиента обычно берут из REMOTE_ADDR; произвольному X-Forwarded-For доверять нельзя без настройки известных прокси.

<?php
$shared = '100.64.0.1';
$twoFlags = FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE;
var_dump(filter_var($shared, FILTER_VALIDATE_IP, $twoFlags));
var_dump(filter_var($shared, FILTER_VALIDATE_IP, FILTER_FLAG_GLOBAL_RANGE));

string(10) "100.64.0.1"
bool(false)

GLOBAL_RANGE доступен с PHP 8.2 и следует global-атрибуту специальных диапазонов. Нельзя описывать его как простую замену двух предыдущих флагов.

<?php
var_dump(filter_var('02:11:22:33:44:55', FILTER_VALIDATE_MAC));
var_dump(filter_var('device-42', FILTER_VALIDATE_MAC));

string(17) "02:11:22:33:44:55"
bool(false)

Фильтр отвечает на вопрос формы строки, а не проводит опрос сети.

<?php
$value = filter_var('02-AA-BB-CC-DD-EE', FILTER_VALIDATE_MAC);
if ($value === false) {
    echo "Неверный MAC\n";
} else {
    echo strtolower(str_replace('-', ':', $value)), "\n";
}

02:aa:bb:cc:dd:ee

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

<?php
$text = "A\nB";
echo json_encode(filter_var($text)), "\n";
echo json_encode(filter_var($text, FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_LOW)), "\n";
var_dump(FILTER_DEFAULT === FILTER_UNSAFE_RAW);

"A\nB"
"AB"
bool(true)

json_encode делает невидимый перевод строки видимым как \n. По умолчанию RAW ничего не удалил.

<?php
var_dump(filter_var('', FILTER_UNSAFE_RAW, FILTER_FLAG_EMPTY_STRING_NULL));
var_dump(filter_var('0', FILTER_UNSAFE_RAW, FILTER_FLAG_EMPTY_STRING_NULL));
echo filter_var('A&B', FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP), "\n";
echo filter_var('`name`', FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_BACKTICK), "\n";

NULL
string(1) "0"
A&B
name

EMPTY_STRING_NULL относится к пустой строке после санитайзера, не к любому falsey-значению. ENCODE_AMP создаёт числовую сущность, это не общее экранирование HTML.

<?php
$text = '"<b>"';
echo filter_var($text, FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_NO_ENCODE_QUOTES), "\n";
echo filter_var($text, FILTER_SANITIZE_FULL_SPECIAL_CHARS), "\n";
echo filter_var($text, FILTER_SANITIZE_FULL_SPECIAL_CHARS, FILTER_FLAG_NO_ENCODE_QUOTES), "\n";

"<b>"
"<b>"
"<b>"

SPECIAL_CHARS игнорирует NO_ENCODE_QUOTES. Для значения HTML-атрибута отключение кодирования кавычек может нарушить границы атрибута.

<?php
declare(strict_types=1);

$comment = '<b>Кисть</b> & валик';
$safeText = filter_var($comment, FILTER_SANITIZE_FULL_SPECIAL_CHARS);
echo '<p>', $safeText, '</p>';

<p>&lt;b&gt;Кисть&lt;/b&gt; &amp; валик</p>

В PHP-выводе появились сущности &lt; и &amp;. Браузер прочитает их как видимые символы < и &, а не начнёт выполнять теги из комментария. Ниже показан именно такой результат. default_charset должен соответствовать входной строке, здесь UTF-8. Исходный $comment сохраняется; кодирование применено только при выводе. Для явно выбранной политики обработки повреждённых байтов удобнее htmlspecialchars с ENT_SUBSTITUTE.

<?php
ini_set('default_charset', 'UTF-8');
$broken = "A\xFFB";
var_dump(filter_var($broken, FILTER_SANITIZE_FULL_SPECIAL_CHARS));
echo bin2hex(htmlspecialchars($broken, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8')), "\n";

string(0) ""
41efbfbd42

При неверной UTF-8-последовательности FULL_SPECIAL_CHARS отвергает всю строку в пустую. У htmlspecialchars с явно заданным ENT_SUBSTITUTE другая политика: некорректный байт заменён U+FFFD (ef bf bd в UTF-8). bin2hex показывает байты; настройка меняется только внутри этого процесса.

<?php
$entered = 'a b@example.org';
echo filter_var($entered, FILTER_SANITIZE_EMAIL), "\n";
var_dump(filter_var($entered, FILTER_VALIDATE_EMAIL));

ab@example.org
bool(false)

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

<?php
$cleaned = filter_var('@@example.org', FILTER_SANITIZE_EMAIL);
echo $cleaned, "\n";
var_dump(filter_var($cleaned, FILTER_VALIDATE_EMAIL));

@@example.org
bool(false)

Два @ остаются, потому что каждый символ разрешён. Санитайзер не проверяет взаимное положение символов.

<?php
$term = 'red shoes';
echo '/search?q=', filter_var($term, FILTER_SANITIZE_ENCODED), "\n";
echo filter_var('https://example.org/?q=x', FILTER_SANITIZE_ENCODED), "\n";

/search?q=red%20shoes
https%3A%2F%2Fexample.org%2F%3Fq%3Dx

Во второй строке пропали служебные разделители адреса: они закодированы как обычные данные. Для нескольких параметров удобнее http_build_query с явно выбранной политикой кодирования.

<?php
echo filter_var('https://example.org/a b', FILTER_SANITIZE_URL), "\n";
echo filter_var('javascript:alert(1)', FILTER_SANITIZE_URL), "\n";
var_dump(filter_var('javascript:alert(1)', FILTER_VALIDATE_URL));

https://example.org/ab
javascript:alert(1)
bool(false)

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

<?php
var_dump(filter_var('12.50', FILTER_SANITIZE_NUMBER_FLOAT));
var_dump(filter_var('12.50', FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
var_dump(filter_var('++12 kg', FILTER_SANITIZE_NUMBER_INT));
var_dump(filter_var('++12', FILTER_VALIDATE_INT));

string(4) "1250"
string(5) "12.50"
string(4) "++12"
bool(false)

Ни FLOAT в имени, ни сохранённые цифры не превращают результат в число. Если неправильный ввод должен стать ошибкой, сразу используйте VALIDATE.

<?php
$flags = FILTER_FLAG_ALLOW_FRACTION | FILTER_FLAG_ALLOW_THOUSAND | FILTER_FLAG_ALLOW_SCIENTIFIC;
$text = filter_var('value=1,250.5e2 units', FILTER_SANITIZE_NUMBER_FLOAT, $flags);
echo $text, "\n";
var_dump(filter_var($text, FILTER_VALIDATE_FLOAT, FILTER_FLAG_ALLOW_THOUSAND));

e1,250.5e2
bool(false)

Буква e из слова value тоже сохранена. Даже очистка с правильными флагами не умеет извлекать число из произвольного предложения: нужен известный формат, парсер или регулярное выражение.

<?php
$name = "O'Neil";
echo filter_var($name, FILTER_SANITIZE_ADD_SLASHES), "\n";
var_dump(filter_var($name, FILTER_SANITIZE_ADD_SLASHES) === addslashes($name));

O\'Neil
bool(true)

При чтении legacy-кода это помогает узнать источник добавленных слешей. В форме имя O'Neil само по себе допустимо и не нуждается в изменении для хранения.

<?php
$text = "\0\\\"'";
echo bin2hex(filter_var($text, FILTER_SANITIZE_ADD_SLASHES)), "\n";

5c305c5c5c225c27

bin2hex показывает точные байты: \0, \\, \" и \'. Это не проверка кодировки, длины или допустимости содержимого.

<?php
$original = '<b>New</b>';
echo htmlspecialchars($original, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'), "\n";
echo $original, "\n";

<b>New</b>
<b>New</b>

CLI печатает строки. На странице первый результат покажет скобки, а второй без кодирования будет HTML-разметкой. Исходник не изменился.

<?php
$description = '<p>New <strong>box</strong></p>';
$plain = strip_tags($description);
echo $plain, "\n";
echo htmlspecialchars($plain, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'), "\n";

New box
New box

strip_tags уместен только если удаление разметки — согласованное правило. Это не полноценный HTML-парсер/санитайзер и не точный эмулятор старого фильтра.

filter_var($input, FILTER_SANITIZE_STRING);
filter_var($input, FILTER_SANITIZE_STRIPPED, FILTER_FLAG_NO_ENCODE_QUOTES);

Исторический фрагмент. PHP 8.1+ сообщает deprecation для обеих констант. Он не исполняется как рекомендуемое решение; нет скрытого подавления диагностики через @.

<?php
function normalizeSku($value) {
    $sku = strtoupper(trim($value));
    return in_array($sku, ['BOX', 'BAG'], true) ? $sku : null;
}
$options = ['options' => 'normalizeSku'];
var_dump(filter_var(' box ', FILTER_CALLBACK, $options));
var_dump(filter_var('other', FILTER_CALLBACK, $options));

string(3) "BOX"
NULL

Имя функции в строке — callable. trim убирает краевые пробелы, strtoupper меняет ASCII-регистр, условие ? A : B выбирает результат. null здесь вернула сама функция, не флаг фильтра.

<?php
declare(strict_types=1);

function normalizeCatalogSku($raw) {
    return strtoupper(trim($raw));
}
$catalog = ['BR-41' => 'Кисть широкая', 'HM-10' => 'Молоток'];
$rule = ['options' => 'normalizeCatalogSku'];
foreach ([' br-41 ', ' hm-10 ', 'xx-99'] as $raw) {
    $sku = filter_var($raw, FILTER_CALLBACK, $rule);
    echo $sku, ': ', $catalog[$sku] ?? 'товар не найден', "\n";
}

BR-41: Кисть широкая
HM-10: Молоток
XX-99: товар не найден

FILTER_CALLBACK вызывает названную функцию, а её return становится $sku. trim убирает краевые пробелы, strtoupper приводит ASCII-код к договорённому регистру. Проверка существования товара идёт после нормализации: вызов callback сам не знает каталога. ?? выбирает запасное сообщение, если ключ отсутствует. Для одной такой операции прямой normalizeCatalogSku($raw) проще; callback полезен, когда то же правило включено в общую карту фильтров.

<?php
$options = ['options' => 'strtoupper', 'flags' => FILTER_REQUIRE_ARRAY];
echo json_encode(filter_var(['box', 'bag'], FILTER_CALLBACK, $options)), "\n";
var_dump(filter_var('box', FILTER_CALLBACK, $options));

["BOX","BAG"]
bool(false)

Структурные флаги действуют с PHP 8.1.25 / 8.2.12; во всех прежних версиях они игнорировались для CALLBACK. Верхний скаляр отклонён до вызова strtoupper.

<?php
function rejectedValue($value) { return false; }
var_dump(filter_var('x', FILTER_CALLBACK, ['options' => 'rejectedValue', 'flags' => FILTER_NULL_ON_FAILURE]));
var_dump(filter_var('x', FILTER_CALLBACK, ['options' => 'rejectedValue', 'flags' => FILTER_THROW_ON_FAILURE]));

bool(false)
bool(false)

Вторая строка требует PHP 8.5. Флаги не интерпретируют false, возвращённый callback. Его собственное исключение, напротив, распространяется обычным способом.

<?php
var_dump(extension_loaded('filter'));
var_dump(function_exists('filter_var'));
var_dump(defined('FILTER_THROW_ON_FAILURE'));

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

Последняя строка true для проверенного PHP 8.5.11, false для PHP 8.2–8.4. Эти результаты не являются обещанием того же окружения у читателя.

<?php
$value = '<mark>New</mark>';
echo filter_var($value, FILTER_UNSAFE_RAW), "\n";
echo htmlspecialchars($value, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'), "\n";

<mark>New</mark>
&lt;mark&gt;New&lt;/mark&gt;

Сохранение исходных данных и вывод в HTML заданы раздельно. Не нужно добиваться такой последовательности через filter.default для всех суперглобальных массивов.

<?php
function validateOrder($input) {
    $errors = [];
    $values = [];
    if (!isset($input['qty']) || !is_string($input['qty'])) {
        $errors['qty'] = 'Введите количество';
    } else {
        $qty = filter_var($input['qty'], FILTER_VALIDATE_INT, ['options' => ['min_range' => 1, 'max_range' => 10]]);
        if ($qty === false) { $errors['qty'] = 'Нужно целое от 1 до 10'; }
        else { $values['qty'] = $qty; }
    }
    if (!isset($input['email']) || !is_string($input['email']) || filter_var($input['email'], FILTER_VALIDATE_EMAIL) === false) {
        $errors['email'] = 'Введите email';
    } else {
        $values['email'] = $input['email'];
    }
    return ['errors' => $errors, 'values' => $values];
}
$result = validateOrder(['qty' => '2', 'email' => 'bad']);
echo json_encode(array_keys($result['errors'])), "\n";
echo json_encode($result['values']), "\n";

["email"]
{"qty":2}

isset отсекает отсутствие/null, is_string — массив вместо поля; || прекращает проверку при первом true. В результате есть частично проверенные values, но они ещё не дают разрешение сохранять заказ: вызывающий код обязан проверить пустоту errors.

<?php
function parseOptionalLimit($text) {
    if ($text === '') { return null; }
    return filter_var($text, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0, 'max_range' => 100]]);
}
var_dump(parseOptionalLimit(''), parseOptionalLimit('0'), parseOptionalLimit('101'));

NULL
int(0)
bool(false)

Попробуйте сначала написать правило сами: пусто означает «лимит не задан», ноль допустим, диапазон до 100. Решение отдельно обрабатывает пустую строку до валидатора; NULL_ON_FAILURE здесь не нужен, потому что null уже имеет другой смысл.