PHP filter_var(): validare email, interi, URL e altro

filter_var($value, FILTER_VALIDATE_EMAIL) restituisce il valore quando è un indirizzo email valido e false quando non lo è. Cambia il filtro per verificare altri formati: FILTER_VALIDATE_INT, FILTER_VALIDATE_FLOAT, FILTER_VALIDATE_URL, FILTER_VALIDATE_BOOL, FILTER_VALIDATE_IP. Confronta sempre il risultato con === false.

<?php
$emails = ['ada@example.com', 'ada.lovelace+news@example.co.uk', 'ada@', 'ada@example', 'ada..x@example.com', ' ada@example.com'];

foreach ($emails as $email) {
    $ok = filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
    printf("%-34s %s\n", "'$email'", $ok ? 'valid' : 'invalid');
}

Due risultati sorprendono. ada@example viene rifiutato perché il dominio non ha un punto, e ' ada@example.com' viene rifiutato per lo spazio iniziale, quindi applica trim() all'input prima di validarlo.

Validare un'email da un form

Lo stesso controllo dietro un form. Eseguilo, scrivi un indirizzo e premi Check; il blocco viene eseguito di nuovo con il tuo input in $_POST.

<?php
$email = trim((string) ($_POST['email'] ?? ''));
$result = '';

if ($email !== '') {
    $result = filter_var($email, FILTER_VALIDATE_EMAIL) !== false
        ? '<b style="color:#2e7d32">valid</b>'
        : '<b style="color:#c62828">invalid</b>';
}
?>
<form method="post">
  <input name="email" size="30" value="<?= htmlspecialchars($email) ?>" placeholder="you@example.com">
  <button>Check</button>
</form>
<?php if ($result): ?><p><?= htmlspecialchars($email) ?> is <?= $result ?></p><?php endif; ?>

FILTER_VALIDATE_EMAIL controlla solo il formato. nobody@example.com passa, e passerebbe anche un indirizzo con un errore di battitura nel dominio. I caratteri non ASCII vengono rifiutati: adä@example.com passa solo con FILTER_FLAG_EMAIL_UNICODE, che li consente prima della @, e un dominio come exämple.com fallisce anche con il flag a meno che tu non lo converta prima nella sua forma xn--. L'unico modo per sapere se un indirizzo funziona è inviargli un link di conferma.

Validare un intero con min_range e max_range

FILTER_VALIDATE_INT trasforma una stringa valida in un int e rifiuta tutto il resto. L'array di opzioni aggiunge un intervallo e un default:

<?php
$inputs = ['42', '-7', ' 42 ', '+42', '4.2', '042', '42abc', '', '0'];

foreach ($inputs as $in) {
    echo str_pad("'$in'", 8), ' => ';
    var_dump(filter_var($in, FILTER_VALIDATE_INT));
}

$age = filter_var('150', FILTER_VALIDATE_INT, [
    'options' => ['min_range' => 0, 'max_range' => 120],
]);
var_dump($age);

$page = filter_var('abc', FILTER_VALIDATE_INT, ['options' => ['default' => 1]]);
var_dump($page);

Gli spazi intorno e un + iniziale sono accettati, uno zero iniziale ('042') no, e il risultato per '42' è l'intero 42, non la stringa. Fuori intervallo dà false; con un'opzione default ottieni il default invece di false, comodo per cose come ?page= (vedi $_GET e$_POST). Aggiungi FILTER_FLAG_ALLOW_HEX o FILTER_FLAG_ALLOW_OCTAL per accettare 0x1A o 0755.

La trappola di 0 e false

Un '0' valido restituisce l'intero 0, e 0 è falsy. Un semplice if lo tratta come un fallimento:

<?php
$quantity = '0';

if (filter_var($quantity, FILTER_VALIDATE_INT)) {
    echo "if (...): valid\n";
} else {
    echo "if (...): rejected, wrongly\n";
}

if (filter_var($quantity, FILTER_VALIDATE_INT) !== false) {
    echo "!== false: valid\n";
}

// Or get null instead of false on failure, and check for null
$n = filter_var('abc', FILTER_VALIDATE_INT, FILTER_NULL_ON_FAILURE);
var_dump($n);

Lo stesso vale per FILTER_VALIDATE_FLOAT ('0.0') e per FILTER_VALIDATE_BOOL, dove false è una risposta valida. È a questo che serve FILTER_NULL_ON_FAILURE.

Booleani, float, URL e indirizzi IP

<?php
// Booleans: "1", "true", "on", "yes" are true; "0", "false", "off", "no", "" are false
foreach (['yes', 'off', 'TRUE', 'maybe'] as $v) {
    echo str_pad($v, 6), ' => ', var_export(filter_var($v, FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE), true), "\n";
}

// Floats: the decimal separator is "." unless you say otherwise
var_dump(filter_var('3.14', FILTER_VALIDATE_FLOAT));
var_dump(filter_var('3,14', FILTER_VALIDATE_FLOAT));
var_dump(filter_var('3,14', FILTER_VALIDATE_FLOAT, ['options' => ['decimal' => ',']]));
var_dump(filter_var('1,000.5', FILTER_VALIDATE_FLOAT, FILTER_FLAG_ALLOW_THOUSAND));

// URLs need a scheme
var_dump(filter_var('https://coddy.tech/docs?x=1', FILTER_VALIDATE_URL));
var_dump(filter_var('coddy.tech', FILTER_VALIDATE_URL));

// IP addresses, optionally excluding private ranges
var_dump(filter_var('192.168.1.10', FILTER_VALIDATE_IP));
var_dump(filter_var('192.168.1.10', FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE));

FILTER_VALIDATE_BOOL è il nome di PHP 8; FILTER_VALIDATE_BOOLEAN è lo stesso filtro. Senza FILTER_NULL_ON_FAILURE, 'maybe' restituirebbe false, indistinguibile da 'off'.

Un URL valido non è un link sicuro

FILTER_VALIDATE_URL verifica che la stringa abbia la forma di un URL, con qualsiasi schema. Questo include schemi che non vuoi mai in un href:

<?php
function isSafeLink(string $url): bool
{
    if (filter_var($url, FILTER_VALIDATE_URL) === false) {
        return false;
    }
    $scheme = strtolower((string) parse_url($url, PHP_URL_SCHEME));
    return in_array($scheme, ['http', 'https'], true);
}

foreach (['https://example.com', 'javascript://comment%0Aalert(1)', 'ftp://files.example.com', 'example.com'] as $url) {
    printf("%-36s filter_var: %-5s  safe link: %s\n",
        $url,
        filter_var($url, FILTER_VALIDATE_URL) !== false ? 'yes' : 'no',
        isSafeLink($url) ? 'yes' : 'no');
}

javascript://comment%0Aalert(1) supera FILTER_VALIDATE_URL, e un browser lo esegue come JavaScript quando il link viene cliccato, perché %0A chiude il //comment. Verifica lo schema con parse_url() prima di stampare in una pagina l'URL di un utente. Puoi anche richiedere delle parti con FILTER_FLAG_PATH_REQUIRED e FILTER_FLAG_QUERY_REQUIRED.

Filtri di sanitizzazione

I filtri di sanitizzazione rimuovono caratteri invece di dire sì o no. Sono utili per normalizzare l'input, non per renderlo sicuro da stampare:

<?php
var_dump(filter_var('Order #12-345 (x2)', FILTER_SANITIZE_NUMBER_INT));
var_dump(filter_var('$1,299.99', FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
var_dump(filter_var('ada (at) example.com', FILTER_SANITIZE_EMAIL));
var_dump(filter_var('<b>Tom</b> & "Jerry"', FILTER_SANITIZE_FULL_SPECIAL_CHARS));

Guarda la prima riga: Order #12-345 (x2) diventa 12-3452, un numero che non c'è mai stato nell'input, e la terza riga è un indirizzo che nessuno ha scritto. Se sanitizzi, valida poi il risultato. Per tutto ciò che stampi nell'HTML, lo strumento giusto è htmlspecialchars() al momento dell'output (FILTER_SANITIZE_FULL_SPECIAL_CHARS applica lo stesso escape). FILTER_SANITIZE_STRING è deprecato da PHP 8.1; vedi htmlspecialchars per cosa usare al suo posto.

Validare un intero form con filter_var_array

filter_var_array() applica un filtro per chiave e restituisce un array con ogni chiave che hai chiesto: il valore filtrato, false quando la validazione è fallita, oppure null quando la chiave mancava.

<?php
$input = ['age' => '31', 'email' => 'not-an-email', 'newsletter' => 'on', 'role' => 'admin'];

$clean = filter_var_array($input, [
    'age'        => ['filter' => FILTER_VALIDATE_INT, 'options' => ['min_range' => 13]],
    'email'      => FILTER_VALIDATE_EMAIL,
    'newsletter' => ['filter' => FILTER_VALIDATE_BOOL, 'flags' => FILTER_NULL_ON_FAILURE],
    'country'    => FILTER_DEFAULT,
]);

var_dump($clean);

role è sparito: le chiavi che non hai elencato vengono scartate, il che impedisce a un visitatore di aggiungere role=admin a un form e farlo salvare. country è null perché non è stato inviato. Su un server web, filter_input_array(INPUT_POST, $rules) fa la stessa cosa leggendo direttamente dalla richiesta.