• 4 heures
  • Facile
Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Introduction du cours

Bonjour à tous !

  • Vous trouvez que valider toutes les données provenant de l'utilisateur est lourd ?

  • Vous ne savez pas toujours comment les valider ?

  • Vous pensez qu'il faut absolument utiliser une expression régulière pour valider une adresse de messagerie ?

Si vous avez répondu « oui » à une de ces questions, alors ce tutoriel est fait pour vous !

Les filtres en PHP nous permettront de nous assurer que les données reçues sont du bon type (entier, réel, ...) et éventuellement de la bonne forme (URL, adresse de messagerie, ...).
En effet, le PHP est un langage faiblement typé, de sorte qu'il est préférable de vérifier le type des données que l'utilisateur envoie pour ne pas avoir de surprise.

À propos des filtres

Comme dit précédemment, les filtres permettent de vérifier que les données reçues sont bien du type et de la forme requis.
Par exemple, si je demande l'âge du visiteur, je souhaite obtenir un nombre (exemple : 42) et non une chaîne de caractères (« quarante-deux »).

Nous pourrions transtyper la variable pour nous assurer que c'est un nombre, non ?

Oui, mais de cette façon, quelqu'un qui entre « quarante-deux » aura... 0 an.

Et si on utilise la fonction is_int() alors ?

C'est déjà mieux. ;)
De cette façon, on vérifie que la donnée reçue est un entier et, si ce n'est pas le cas, on lui redemande son âge.

Cependant, l'utilisateur pourrait entrer un nombre négatif.
Par conséquent, il faudrait utiliser une condition pour vérifier si c'est le cas ou non.

Et lorsqu'il y a plusieurs données à vérifier, le code devient vite très lourd.

Avec les filtres, c'est très simple : il suffit de renseigner la valeur minimale (par exemple 1) et le tour est joué. :D

Il est possible de valider plusieurs types de données grâce aux filtres :

  • les entiers ;

  • les booléens ;

  • les nombres réels.

De plus, il est aussi possible de valider :

  • les adresses de messagerie ;

  • les URL ;

  • les adresses IP.

Il n'est donc plus nécessaire d'utiliser des expressions régulières pour cela. :-°

Mais les filtres ne servent pas seulement à la validation de données, ils servent aussi au nettoyage de données.

Quel genre de nettoyage ?

Il existe des filtres pour nettoyer une chaîne de caractères (ça enlève les balises (x)HTML), pour nettoyer une adresse de messagerie, une URL et même un nombre.
En effet, certains caractères ne sont pas acceptés dans les adresses de messagerie ; le nettoyage les enlève à notre place. (Nous sommes chanceux, nous n'avons plus besoin de faire nos propres fonctions pour cela. ^^ )

Passons à la pratique.

Valider une variable

Nous allons commencer par vérifier le type de variable, puis la forme.
Ensuite, nous verrons comment ajouter des options et comment valider les données provenant de l'utilisateur.

Vérifier le type de la variable

Il est très important de s'assurer que le type de la donnée reçue est bien celui voulu pour éviter d'avoir des problèmes à ce niveau.

Pour valider une variable, il faut utiliser la fonction filter_var().
La plupart du temps, nous appellerons cette fonction avec 2 paramètres : la variable à valider et le type de filtre.
Il est possible d'envoyer un troisième paramètre : un tableau d'options.
Nous verrons comment utiliser ces options un peu plus tard.

Les entiers

Voyons tout de suite un exemple :

<?php

$a = 123;

if(filter_var($a, FILTER_VALIDATE_INT) !== false) { //Si la variable est bien un entier.
    echo 'La variable est un entier valide !';
}

Si vous testez ce code, vous pouvez constater que le texte s'affiche.

Donnez une autre valeur à la variable pour voir :

<?php

$a = '123';

Ça fonctionne aussi !

Maintenant, essayons des valeurs qui ne fonctionnent pas :

<?php

$a = 'allo';

Le texte ne s'affiche plus ; c'est parfait !

Allez, un autre test :

<?php

$a = '123abc';

Là non plus le texte ne s'affiche pas.
C'est tout à fait normal, car cette chaîne de caractères ne contient pas que des chiffres, mais aussi des lettres.

Faisons un dernier test pour nous assurer que tout fonctionne :

<?php

$a = 12.4;

Le texte ne s'affiche toujours pas : la validation fonctionne !

Revenons à la ligne qui nous intéresse dans le code :

<?php

if(filter_var($a, FILTER_VALIDATE_INT) !== false) {

Que renvoie la fonction filter_var() ?

Elle renvoie la donnée filtrée (dans ce cas, c'est la valeur de la variable) ou false si elle n'est pas valide.

Pourquoi ne pas faire tout simplement ceci :
if(filter_var($a, FILTER_VALIDATE_INT)) { ?
Si le nombre est valide, la condition est vraie, non ?

Pas toujours. :p

Voici un exemple où il ne fonctionne pas :

<?php

$a = 0;

if(filter_var($a, FILTER_VALIDATE_INT)) { //Ne jamais valider comme ceci !
    echo 'La variable est un entier valide !';
}

En effet, le texte ne s'affichera pas, car la valeur testée est 0.

Donc, utilisez toujours cette condition :

<?php

if(filter_var($a, FILTER_VALIDATE_INT) !== false) {

Il a été dit que la fonction filter_var() retourne la valeur si elle est valide.

À quoi ça sert, puisque nous avons déjà cette valeur ?

En fait, ça retourne la valeur transtypée si elle n'est pas du bon type.

Voici un exemple :

<?php

$b = '24';

if($b = filter_var($b, FILTER_VALIDATE_INT)) {
    var_dump($b); //Affiche int(24).
}

Passons aux autres types de données ; ça ira plus vite maintenant que nous avons vu un exemple. :)

Les nombres réels

Pour un nombre réel, il faut utiliser la constante FILTER_VALIDATE_FLOAT :

<?php

$a = 12.4;

if(filter_var($a, FILTER_VALIDATE_FLOAT) !== false) { //Validation d'un nombre réel.
    echo 'La variable est un nombre réel valide !';
}

C'est simple, non ? ;)

Vérifier la forme de la variable

Il est possible de valider les adresses de messagerie, les liens et les adresses IP grâce aux filtres, et ce, sans utiliser d'expressions régulières ! :D

Les adresses de messagerie

Encore une fois, il suffit de modifier la constante utilisée :

<?php

$a = 'petitzero@siteduzero.com';

if(filter_var($a, FILTER_VALIDATE_EMAIL) !== false) { //Validation d'une adresse de messagerie.
    echo 'La variable est une adresse de messagerie valide !';
}

Essayez d'enlever le point (.) ou le @ et vous verrez que le message ne s'affiche plus.

Les liens

Encore une fois, on ne fait que modifier la constante :

<?php

$a = 'http://www.siteduzero.com/';

if(filter_var($a, FILTER_VALIDATE_URL) !== false) { //Validation d'un lien.
    echo 'La variable est un lien valide !';
}

Les adresses IP

Cette fois, la constante est FILTER_VALIDATE_IP :

<?php

$a = '127.0.0.1';

if(filter_var($a, FILTER_VALIDATE_IP) !== false) { //Validation d'une adresse IP.
    echo 'La variable est une adresse IP valide !';
}

Les adresses IPv6 valident aussi. Vous pouvez essayer avec cette valeur :

<?php

$a = '2001:0db8:0000:85a3:0000:0000:ac1f:8001';

Validation avec options

Passons maintenant à quelque chose de plus intéressant : les options.

Avec les options, il est possible d'ajouter des contraintes supplémentaires.

Options à utiliser avec les entiers

Il existe deux options pour les entiers :

  • min_range ;

  • max_range.

Ces options permettent de préciser une limite minimale et maximale.
Par exemple, si min_range vaut 0, le nombre -5 sera invalide.

C'est maintenant que nous allons nous servir du troisième paramètre de la fonction filter_var().
Ce paramètre est un tableau ayant l'index 'options' qui contient, lui aussi, un tableau.
C'est dans ce dernier que nous mettrons les index min_range et/ou max_range.

Voici un exemple où nous voulons un entier de 0 à 100 :

<?php

$a = '64';

$options = array(
    'options' => array(
        'min_range' => 0,
        'max_range' => 100
    )
);

if(filter_var($a, FILTER_VALIDATE_INT, $options) !== false) { //Validation d'un entier.
    echo 'La variable est un nombre entier valide (compris entre 0 et 100) !';
}

Nous créons un tableau avec les index voulus, puis nous passons ce tableau à la fonction filter_var().
Rien de bien difficile.

Les options des autres types sont moins utilisées.

Les drapeaux

Ce sont des options (ne prenant aucun paramètre) que nous pouvons ajouter.

Par exemple, si je veux que les nombres octaux et hexadécimaux soient valides, je dois ajouter les drapeaux correspondants :

<?php

$a = '0x64';

$options = array(
    'flags' => FILTER_FLAG_ALLOW_HEX | FILTER_FLAG_ALLOW_OCTAL
);

if(filter_var($a, FILTER_VALIDATE_INT, $options)) {
    echo 'L\'entier est valide.';
}

Dans le tableau options, nous n'utilisons plus l'index 'options', mais plutôt l'index 'flags' (drapeaux, en anglais).

Vous pouvez également essayer avec une valeur en base 8 :

<?php

$a = '064';

Les cas des données utilisateur

(Après tout, c'est l'objet de ce tutoriel. :lol: )

Nous allons maintenant utiliser une nouvelle fonction. Eh oui, il était temps, non ? :p

Il s'agit de filter_input() : elle fonctionne comme filter_var(), mais est adaptée aux données envoyées par l'utilisateur.

Elle prend quatre paramètres, dont les deux premiers sont obligatoires :

  • le type (INPUT_GET, INPUT_POST, INPUT_COOKIE, INPUT_SERVER ou INPUT_ENV) ;

  • l'index du tableau du prédécent paramètre ;

  • le filtre à appliquer (exemple : FILTER_VALIDATE_INT) ;

  • le tableau d'options.

Cette fois, la valeur de retour est différente.
La fonction retourne :

  • la valeur si la donnée est valide ;

  • false si elle n'est pas valide ;

  • null si elle n'existe pas.

Pourquoi ne pas utiliser simplement filter_var() comme ceci :
filter_var($_GET['variable'], FILTER_VALIDATE_INT) ?

Parce que si $_GET['variable'] n'existe pas, il s'affichera une erreur.

Regardons ensemble un exemple :

<?php

$resultat = filter_input(INPUT_GET, 'age', FILTER_VALIDATE_INT);

if($resultat === null) { //Si la variable $_GET['age'] n'existe pas.
    echo 'La variable $_GET[\'age\'] n\'existe pas.';
}
elseif($resultat !== false) { //Si elle est valide.
    echo 'La variable $_GET[\'age\'] est un entier valide !';
}
else {
    echo 'La variable $_GET[\'age\'] n\'est pas valide.';
}

Premièrement, nous stockons la valeur de retour de la fonction filter_input() dans une variable.

Ici, nous nous attendons à obtenir un paramètre dans l'URL nommé « age » et nous vérifions qu'il s'agit bien d'un entier.

La première condition sert à vérifier l'existence de la variable : si elle n'existe pas, $resultat vaudra null.

La deuxième condition vérifie la validité de la donnée. Si $resultat est différent de null et de false, elle est nécessairement un nombre entier.

Le else (équivalent de $resultat === false) affiche un message pour dire que la variable n'est pas valide (par exemple, si l'utilisateur a entré « abc »).

Vérifier l'existence d'une donnée utilisateur

Si nous ne voulons vérifier l'existence d'une donnée utilisateur, nous pouvons utiliser la fonction filter_has_var().

Elle prend deux paramètres :

  • le type (INPUT_GET, INPUT_POST, ?) ;

  • l'index.

Cette fonction retourne true si l'index est dans le tableau, false sinon.

Voici un exemple simple :

<?php

if(filter_has_var(INPUT_GET, 'age')) {
    echo '$_GET[\'age\'] existe';
}

Pourquoi utiliser cette fonction si on peut faire la même chose avec filter_input() ?

Parce qu'elle fait moins de tests.
En effet, elle ne vérifie que l'existence d'un index, elle ne valide pas sa valeur.

C'est donc utile dans les cas où nous n'avons pas à vérifier la valeur.
En voyez-vous un ?

Il y en a bien un :
... pour les cases à cocher !
En effet, il n'est pas nécessaire de vérifier ce type de valeur, car il suffit de savoir si l'index existe ou non pour effectuer les traitements adéquats.

Nous avons vu bien des notions sur la validation des données, passons maintenant au grand nettoyage. :euh:
Quoi ? Ne partez pas ! :-°

Nettoyer une variable

Le nettoyage d'une variable consiste à enlever des caractères interdits, tels les espaces dans un lien.

Les chaînes de caractères

Nous devons toujours nettoyer les chaînes de caractères provenant de l'utilisateur que nous afficherons à l'écran.
Un exemple : un message dans un forum.

En quoi consiste ce nettoyage ? Et pourquoi faut-il les nettoyer ?

Il consiste en la suppression des balises (x)HTML et en l'encodage de certains caractères spéciaux (par exemple, l'apostrophe devient &#39;).
Il importe de nettoyer les chaînes de caractères envoyées par l'utilisateur, car certaines personnes sont très méchantes. :colere2:

Si vous ne nettoyez pas les données utilisateur et que vous les affichez, elles pourront contenir des balises (x)HTML et, pire encore, du JavaScript (et là, c'est le drame :'( ).

Si je nettoie une chaîne de caractères, puis-je l'insérer sans risque dans une base de données ?

Comme les apostrophes et les guillemets sont encodés, cela réduit les risques d'injections SQL.
Par contre, si l'utilisateur entre certains caractères spéciaux comme un \, une erreur sera causée si la chaîne n'est pas protégée pour la base de données.

Donc, ce nettoyage ne concerne que l'affichage à l'écran.

Pour valider une donnée, nous utilisions un filtre du genre FILTER_VALIDATE_*.
Maintenant, nous en utiliserons un du genre FILTER_SANITIZE_*.

Voici un exemple très simple :

<?php

$valeur = '<strong>Texte en gras</strong>';

$valeurNettoyee = filter_var($valeur, FILTER_SANITIZE_STRING); //Supprimer les balises.

echo $valeurNettoyee;

La variable, au départ, contient une balise <strong>.

Par contre, quand nous affichons la variable nettoyée, le texte n'est pas en gras (contrairement à ce qui est écrit :p ).

Cette fois, nous avons utilisé filter_var(), mais sachez que nous pouvons toujours utiliser filter_input() :

<?php

echo filter_input(INPUT_GET, 'texte', FILTER_SANITIZE_STRING);

Il existe une variante de FILTER_SANITIZE_STRING qui affiche les balises telles quelles (c'est-à-dire qu'elle remplace les <, > et & en leur entité XML correspondante).

Voici un exemple :

<?php

echo filter_input(INPUT_GET, 'texte', FILTER_SANITIZE_SPECIAL_CHARS);

Cette fois, si le texte est '<strong>gras</strong>', alors c'est ce qui sera affiché.

Si on regarde le code source (x)HTML, nous voyons ceci :

&#60;strong&#62;gras&#60;/strong&#62;

Nous pouvons constater que le (x)HTML ne nous fera plus de mal. ^^

Filtrer plusieurs variables

Avec ce que vous avez vu jusqu'à présent, vous vous dites peut-être que c'est tout de même lourd de valider plusieurs variables à la fois.
Vous vous dites peut-être qu'il faut utiliser une boucle pour valider toutes les variables reçues.
Eh bien détrompez-vous. :)

Ici, nous allons voir comment filtrer plusieurs variables à l'aide d'un tableau et d'une nouvelle fonction.

Maintenant, nous pouvons nous amuser (après le travail, la récompense ^^ ).

Nous allons travailler avec le formulaire suivant :

<form action="cible.php" method="post">
    Prénom : <input type="text" name="prenom"/><br/>
    Adresse de messagerie : <input type="text" name="email"/><br/>
    Âge : <input type="text" name="age"/><br/>
    <input type="submit" value="Envoyer"/>
</form>

Pour simplifier le problème, nous allons insérer le formulaire et la validation sur des pages différentes, bien que ce ne soit pas obligatoire.

En outre, nous allons seulement afficher les données postées à l'écran (si elles sont valides, bien sûr).

Pour valider plusieurs variables à la fois, nous allons utiliser une nouvelle fonction : filter_input_array().

Ce qui nous aide un peu, ici, c'est que $_POST est un tableau !

Cette fonction prend deux paramètres :

  • le type (INPUT_POST, INPUT_GET, ?) ;

  • un tableau établissant la correspondance entre le nom des champs et leurs options.

Donc, la seule chose à faire est de construire ce tableau.

Allons-y de ce pas !

Premièrement, construisons le tableau sans les options.
Ça nous donne :

<?php

$options = array(
    'prenom' => (?),
    'email' => (?),
    'age' => (?)
);

Que faut-il mettre comme valeur à la place des (?) ?

Nous pouvons mettre une constante comme FILTER_SANITIZE_STRING ou FILTER_VALIDATE_EMAIL, ce qui nous donne ceci :

<?php

$options = array(
    'prenom' => FILTER_SANITIZE_STRING,
    'email' => FILTER_VALIDATE_EMAIL,
    'age' => (?)
);

Nous pouvons également mettre un tableau avec les clés 'options' comme nous avons vu plus haut.
Dans ce tableau, nous pouvons insérer une nouvelle clé : 'filter'. C'est également une constante du type FILTER_*_*.

Voici donc comment valider plusieurs données :

<?php

$options = array(
    'prenom' => FILTER_SANITIZE_STRING, //Enlever les balises.
    'email' => FILTER_VALIDATE_EMAIL, //Valider l'adresse de messagerie.
    'age' => array(
        'filter' => FILTER_VALIDATE_INT, //Valider l'entier.
        'options' => array(
            'min_range' => 0 //Minimum 0.
        )
    )
);

$resultat = filter_input_array(INPUT_POST, $options);

Avant de connaître les filtres, vous auriez fait un truc du genre :

<?php

$prenom = htmlspecialchars($_POST['prenom']);
$email = htmlspecialchars($_POST['email']);

if(!preg_match('`#^[a-z0-9._-]+@[a-z0-9._-]{2,}\.[a-z]{2,4}$#`', $email)) {
    [?]
}

if(!is_int($_POST['age'])) {
    [?]
}
else {
    if($age < 0) {
        [?]
    }
}

Je trouve cela beaucoup plus lourd.
Ce code utilise beaucoup de conditions tandis que l'autre n'en a aucune.
Et imaginez avec un plus gros formulaire (nous n'avons que trois champs présentement o_O ).

Revenons à notre code.
La dernière ligne est celle-ci :

<?php

$resultat = filter_input_array(INPUT_POST, $options);

Qu'est-ce qui est envoyé à la variable $resultat ?

Un tableau contenant au maximum trois types de données :

  • la valeur validée ;

  • false si la valeur n'est pas valide ;

  • null si la valeur n'existe pas.

Par conséquent, nous pourrions tester les données comme ceci :

<?php

if($resultat != null) { //Si le formulaire a bien été posté.
    //Enregistrer des messages d'erreur perso.
    $messageErreur = array(
        'email' => 'L\'adresse de messagerie n\'est pas valide.',
        'age' => 'Veuillez entrer un nombre entier positif pour votre âge.'
    );
    
    $nbrErreurs = 0;

    foreach($options as $cle => $valeur) { //Parcourir tous les champs voulus.
        if(empty($_POST[$cle])) { //Si le champ est vide.
            echo 'Veuillez remplir le champ ' . $cle . '.<br/>';
            $nbrErreurs++;
        }
        elseif($resultat[$cle] === false) { //S'il n'est pas valide.
            echo $messageErreur[$cle] . '<br/>';
            $nbrErreurs++;
        }
    }

    if($nbrErreurs == 0) {
        echo 'Bonjour ' . $resultat['prenom'] . ' !<br/>Ton adresse de messagerie est bien ' . $resultat['email'] . ' ?<br/>';
        echo 'Tu as ' . $resultat['age'] . ' ans ? Tu as bien grandi !';
    }
}
else {
    echo 'Vous n\'avez rien posté.';
}

Premièrement, il faut savoir que la valeur retournée par filter_input_array() est null si aucune des données voulues (du tableau d'options) n'est présente.
Si c'est le cas, ce ne sera donc pas un tableau contenant que des valeurs null.

C'est cela que nous vérifions en premier.

Ensuite, nous créons un tableau de messages d'erreur et une variable qui contiendra le nombre d'erreurs.

Puis nous parcourons tous les champs et vérifions qu'ils sont valides et non vides.

Enfin, s'il n'y a pas d'erreurs, nous affichons les données postées par l'utilisateur.

Voilà : nous avons un système dans lequel il est très facile d'ajouter et d'enlever de nouveaux champs.

Nous aurions pu faire plus court sans boucle, mais, dans ce cas, nous devrions ajouter une condition à chaque nouveau champ, de telle sorte que ça deviendrait très lourd de valider un gros formulaire.

Et si le filtre que je veux n'est pas là ?

Vous n'avez qu'à le créer ! :lol:
Et c'est ce que nous allons voir ici.

Nous allons reprendre l'exemple du numéro de téléphone du tutoriel PHP/MySQL.

Nous allons créer deux filtres : un pour valider le numéro, l'autre pour le nettoyer.

Création d'un filtre de validation

Pour créer un filtre, nous devons créer une fonction qui renverra la même chose que filter_var() (la chaîne ou false).
Ensuite, nous devrons appeler filter_var() avec la constante FILTER_CALLBACK et lui indiquer le nom de la fonction :

<?php

filter_var($variable, FILTER_CALLBACK, array('options' => 'nomFonction'));

Pour valider le numéro, nous allons utiliser cette expression régulière :

`^0[1-9]([-. ]?[0-9]{2}){4}$`

Donc, notre fonction pour valider le numéro est très simple :

<?php

function validerNumero($telATester) {
    //Retourne le numéro s'il est valide, sinon false.
    return preg_match('`^0[1-9]([-. ]?[0-9]{2}){4}$`', $telATester) ? $telATester : false;
}

Vérifions que ça fonctionne bien :

<?php

$numero = '0153789999';
var_dump(filter_var($numero, FILTER_CALLBACK, array('options' => 'validerNumero')));

C'est super, nous voyons le numéro s'afficher !

Vérifions une donnée invalide :

<?php

$numero = '153789999'; //Il manque le zéro au début.
var_dump(filter_var($numero, FILTER_CALLBACK, array('options' => 'validerNumero')));

Nous voyons « bool(false) », ce qui signifie que le numéro n'est pas valide.
Et c'est bien le cas.

Le filtre de validation fonctionne bien.

Mais à quoi ça sert de faire un filtre puisque nous créons déjà la fonction qui valide le numéro ?
Pourquoi ne pas utiliser seulement cette fonction ?

Créer un filtre personnalisé, comme nous venons de faire, est utile lorsque nous voulons valider plusieurs données venant de l'utilisateur (voir la sous-partie précédente).
Ainsi, nous pouvons utiliser notre filtre dans le tableau d'options :

<?php

$filtres = array(
    'numero' => array(
        'filter' => FILTER_CALLBACK,
        'options' => 'validerNumero'
    )
);

$resultats = filter_input_array(INPUT_GET, $filtres);

if($resultats['numero'] !== false) {
    echo 'Le numéro est valide.';
}

Passons aux filtres de nettoyage.

Création d'un filtre de nettoyage

Nous allons créer un filtre pour nettoyer le numéro de téléphone.

Il enlèvera tous les caractères non numériques et ajoutera autant de zéros que nécessaire au début de la chaîne pour qu'elle contienne dix caractères.

La fonction que nous devons créer doit effectuer ces traitements et renvoyer la chaîne nettoyée.

Je vous propose cette fonction :

<?php

function nettoyerNumero($telANettoyer) {
    //Enlever tous les caractères non numériques.
    $telANettoyer = preg_replace('`[^0-9]`', '', $telANettoyer);
    
    //Ajout de zéros si besoin.
    $telANettoyer = str_pad($telANettoyer, 10, '0', STR_PAD_LEFT);
    
    return $telANettoyer;
}

Premièrement, nous utilisons une expression régulière pour enlever tous les caractères autres que les chiffres de 0 à 9.

Ensuite, si la chaîne contient moins de 10 caractères, nous ajoutons le nombre de zéros requis avec str_pad().

Nous pouvons maintenant nettoyer les numéros de téléphone.

Procédons à quelques essais :

<?php

$numero = '01 53 78 99 99';
var_dump(filter_var($numero, FILTER_CALLBACK, array('options' => 'nettoyerNumero')));

À l'écran, nous voyons :

string(10) "0153789999"

Les espaces ont bien été enlevés.

Un autre essai :

<?php

$numero = '153789999';
var_dump(filter_var($numero, FILTER_CALLBACK, array('options' => 'nettoyerNumero')));

Résultat :

string(10) "0153789999"

Le zéro a bien été ajouté.

Nos deux filtres fonctionnent !

Voilà : maintenant, vous savez tout sur les filtres (ou presque :-° ).

Donc, les filtres servent à valider et à nettoyer les données provenant de l'utilisateur.
Ils vous permettent non seulement d'éviter de mauvaises surprises si ce dernier entre une chaîne de caractères avec des balises (x)HTML, mais aussi lorsqu'il n'entre pas le bon type de données.

Pour avoir plus d'informations sur les filtres, vous pouvez consulter la documentation de PHP sur les filtres.

Exemple de certificat de réussite
Exemple de certificat de réussite