Validare e filtrare i dati con le superglobali in PHP

by theArchitect
Add as preferred source on Google
SHARE
Validare e filtrare i dati con le superglobali in PHP
© Guida-HTML5.it

Introduzione

Le superglobali in PHP sono uno strumento fondamentale per leggere dati provenienti dall’esterno: richieste HTTP, parametri di query, dati di form, cookie, sessioni e molto altro. Quando si lavora con input utente, il problema non è solo leggere i dati, ma soprattutto verificarne la forma e il contenuto prima di usarli.

In questo tutorial ci concentriamo su un sotto-argomento molto pratico: la validazione e il filtraggio dei dati raccolti da $_GET e $_POST usando filter_input() e filter_var(). È un tema essenziale perché permette di scrivere codice più sicuro, leggibile e robusto rispetto al classico controllo manuale fatto con confronti sparsi nel codice.

Questo approccio è utile in scenari reali come:

  • validare un’email inviata da un modulo di registrazione;
  • controllare che un ID passato in URL sia un intero valido;
  • filtrare un URL prima di salvarlo nel database;
  • gestire campi opzionali senza generare warning o errori.

Codice completo

<?php
declare(strict_types=1);

// Simulazione di input: in un caso reale questi valori arrivano da $_GET e $_POST
// Esempio URL: /profilo.php?id=12
// Esempio form: name=Mario&[email protected]&website=https://example.com

// 1) Lettura e validazione di un parametro GET: id
$id = filter_input(INPUT_GET, ´id´, FILTER_VALIDATE_INT);

// 2) Lettura e validazione di campi POST
$name = filter_input(INPUT_POST, ´name´, FILTER_UNSAFE_RAW, FILTER_FLAG_NO_ENCODE_QUOTES);
$email = filter_input(INPUT_POST, ´email´, FILTER_VALIDATE_EMAIL);
$website = filter_input(INPUT_POST, ´website´, FILTER_VALIDATE_URL);

// 3) Pulizia di un testo libero
$comment = filter_input(INPUT_POST, ´comment´, FILTER_UNSAFE_RAW);

$errors = [];

// Validazione ID
if ($id === null || $id === false) {
    $errors[] = ´Il parametro id non è valido.´;
}

// Validazione nome
$name = trim((string)$name);
if ($name === ´´) {
    $errors[] = ´Il nome è obbligatorio.´;
} elseif (mb_strlen($name) < 3) {
    $errors[] = ´Il nome deve contenere almeno 3 caratteri.´;
}

// Validazione email
if ($email === null || $email === false) {
    $errors[] = ´L’email non è valida.´;
}

// Validazione website: campo opzionale
if ($website !== null && $website !== false && $website !== ´´) {
    // OK, URL valido
} else {
    $website = null; // normalizziamo il valore opzionale
}

// Pulizia commento
$comment = trim((string)$comment);
if ($comment !== ´´) {
    // Esempio di normalizzazione: rimuove spazi multipli e controlla la lunghezza
    $comment = preg_replace(´/s+/´, ´ ´, $comment);
    if (mb_strlen($comment) > 500) {
        $errors[] = ´Il commento non può superare i 500 caratteri.´;
    }
}

// Output finale
if (!empty($errors)) {
    echo "<h2>Errori di validazione</h2>";
    echo "<ul>";
    foreach ($errors as $error) {
        echo "<li>" . htmlspecialchars($error, ENT_QUOTES, ´UTF-8´) . "</li>";
    }
    echo "</ul>";
    exit;
}

// Se arriviamo qui, i dati sono considerati validi
echo "<h2>Dati validi</h2>";
echo "<p>ID: " . (int)$id . "</p>";
echo "<p>Nome: " . htmlspecialchars($name, ENT_QUOTES, ´UTF-8´) . "</p>";
echo "<p>Email: " . htmlspecialchars((string)$email, ENT_QUOTES, ´UTF-8´) . "</p>";

if ($website !== null) {
    echo "<p>Website: " . htmlspecialchars((string)$website, ENT_QUOTES, ´UTF-8´) . "</p>";
}

if ($comment !== ´´) {
    echo "<p>Commento: " . htmlspecialchars($comment, ENT_QUOTES, ´UTF-8´) . "</p>";
}
?>

Spiegazione

Il cuore dell’esempio è l’uso di filter_input(), una funzione pensata per leggere direttamente i dati da una superglobale e applicare un filtro nello stesso passaggio. Questo riduce il rischio di dimenticare controlli importanti e rende il codice più esplicito.

1. Validare un intero con $_GET

Nel codice abbiamo letto id con:

$id = filter_input(INPUT_GET, ´id´, FILTER_VALIDATE_INT);

Questo significa che PHP prova a interpretare il valore come intero. Se il dato non è valido, la funzione restituisce false. Se il parametro non esiste, può restituire null. Distinguere questi casi è utile quando vuoi capire se un campo è stato omesso oppure se è presente ma errato.

2. Validare email e URL con $_POST

Per email e website usiamo filtri specifici:

  • FILTER_VALIDATE_EMAIL per controllare il formato dell’indirizzo email;
  • FILTER_VALIDATE_URL per verificare che il valore sia un URL valido.

Questi filtri non fanno “sanificazione magica”: verificano solo se il dato rispetta una forma attesa. È un punto importante. Validare e sanificare non sono la stessa cosa.

3. Gestire testi liberi

Per il campo comment abbiamo usato FILTER_UNSAFE_RAW, che in pratica restituisce il valore senza trasformazioni. Questo è corretto quando vuoi decidere tu come trattare il contenuto. Dopo la lettura, abbiamo applicato alcune operazioni manuali:

  • trim() per rimuovere spazi iniziali e finali;
  • preg_replace() per normalizzare gli spazi multipli;
  • controllo della lunghezza con mb_strlen().

Questo approccio è molto comune nei form moderni: prima validi la struttura, poi normalizzi il contenuto.

4. Perché usare htmlspecialchars in output

Anche se il dato è stato validato, quando lo mostri in HTML devi sempre usare htmlspecialchars(). Questo evita problemi di XSS e rende sicuro l’output nel browser. La validazione non sostituisce la protezione in fase di visualizzazione.

5. Differenza tra null e false

Nel nostro esempio abbiamo controllato sia null sia false. È una buona pratica perché alcuni filtri indicano un valore assente con null e un valore presente ma non valido con false. Questo piccolo dettaglio aiuta a scrivere logiche più precise.

Best practice

  • Valida appena leggi il dato: non rimandare i controlli a fine script.
  • Usa filtri specifici per il tipo di dato: interi, email, URL, booleani.
  • Non fidarti mai dell’input utente, nemmeno se arriva da un form interno alla tua applicazione.
  • Separa validazione e output: prima controlli, poi stampi con htmlspecialchars().
  • Normalizza i dati dopo la validazione: trim, conversioni di tipo, formattazioni.
  • Gestisci i campi opzionali in modo esplicito, evitando confronti ambigui.
  • Preferisci errori chiari e aggregati in un array, così l’utente vede tutti i problemi in una sola volta.
  • Usa declare(strict_types=1) nei progetti moderni per ridurre comportamenti inattesi.

Riepilogo

Le superglobali come $_GET e $_POST sono il punto di ingresso di molti dati nelle applicazioni PHP. Il modo più pulito e affidabile per gestirli è leggere i valori con filter_input(), validarli con filtri adatti al tipo di dato e poi normalizzarli solo se superano i controlli.

In pratica:

  • $_GET è spesso usato per parametri in URL, come ID o filtri di ricerca;
  • $_POST è usato per dati di form, come nome, email, commenti;
  • filter_input() aiuta a centralizzare la lettura e la validazione;
  • htmlspecialchars() resta indispensabile quando stampi i dati in HTML.

Se impari a usare bene questi strumenti, il tuo codice sarà più sicuro, più leggibile e più semplice da mantenere.

Approfondisci con risorse ufficiali

Add as preferred source on Google
SHARE