Les filtres en PHP pour valider les données utilisateur

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 !

Avant de continuer la lecture de ce tutoriel, assurez-vous de posséder des bases en PHP.
La lecture du tutoriel sur PHP/MySQL est le minimum requis pour comprendre ce tutoriel.

En outre, assurez-vous que vous disposez au moins de la version 5.2.0 de PHP.

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. ^^ )

Le nettoyage ne valide pas les données. Il ne fait qu'enlever les caractères non permis même si la variable n'est pas valide.

Par exemple, il est possible de nettoyer la variable 'allô toi' comme si c'était un lien.
Dans un tel cas, la valeur retournée serait 'alltoi', car les caractères accentués et les espaces ne sont pas permis dans les liens.

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 y a bien deux signes égal (==) après le point d'exclamation parce que nous voulons vérifier le type de variable en plus.
Essayez avec un seul signe égal et vous verrez que ça ne fonctionne pas. :(

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.

Ce n'est pas parce que l'adresse de messagerie est valide qu'elle existe.
En effet, ici, on ne fait que vérifier la forme de l'adresse.

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 !'; }

Pour valider, il faut que la variable à tester contienne bien le protocole de communication (exemple : http, ftp, ...).
Le « www » est, bien entendu, facultatif.

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).

Pour combiner des drapeaux, il faut les séparer à l'aide d'un |.

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

<?php $a = '064';

Les nombres sont entre apostrophes, car sinon, ils seraient « convertis » en base 10 de telle sorte que l'ajout de ces drapeaux serait inutile.

En PHP, comme dans d'autres langages de programmation, le préfixe à écrire pour préciser qu'un nombre est écrit en hexadécimal est '0x' (un zéro, suivi d'un x) ; pour écrire un nombre octal (en base 8), c'est '0' (un zéro).

Les cas des données utilisateur

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

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...