shade.ca
Games
Art
Coding
Beauty Contest
Reviews
Spoofs
Corporate site
Webcams
Links




Tell Me the Truth

Hacky the raccoon
Shade.ca Web Design

3D Molecule representation (C++)

SouthPark Slot Machine

Random Review
Random Review



Join our mailing list!   Tell a friend about this site!

Validité d'une adresse de courriel

Introduction

Ce qui suit est une brève description de l'utilisation des " regular expressions " pour réaliser la tâche de la vérification de la validité d'une adresse de courriel. En effet, tout programmeur web risquera à un moment ou un autre de tomber sur un projet où il voudra vérifier l'information qui a été envoyée au serveur par le client. Cet article vous aidera à vérifier les adresses électroniques qui vous sont envoyés par un algorithme simple. Malheureusement, je suis loin d'être un expert des " regular expressions ". Par contre, je crois que cet article vous informera et risque fortement de vous intriguer pour en apprendre plus.

Débutons par une brève explication de ce qu'est une " regular expression ". Si vous avez déjà utilisé Dos ou des systèmes d'exploitation Unix, vous savez qu'il est très utile d'utiliser des caractères tels que ? et * lorsque vous recherchez des fichiers. Une recherche pour un fichier avec l'expression " test?.asp " trouverait des fichiers tels que test1.asp, test2.asp, testx.asp, etc. Par ailleurs, l'expression " test*.asp " trouverait des fichiers tels que test1.asp, test2.asp, testx.asp, testxyz.asp, etc. Vous pouvez ainsi trouver plusieurs fichiers avec une seule commande. Ces expressions sont des versions simplifiées des " regular expressions "

Ces dernières peuvent être utilisées sur des chaînes de caractères pour vérifier leur validité, pour en sélectionner des portions spécifiques qui seront extraites ou remplacées. Quelques langages utilisent les " regular expressions ". (Je ne les citerai pas puisque je ne les connais pas tous.) Elles sont particulièrement utiles dans les langages qui ne possèdent pas une panoplie de fonctions de traitement de chaînes de caractères comme le JavaScript mais sont toutefois très intéressantes pour regrouper plusieurs opérations dans des langages comme VBScript (le langage que j'utilise pour créer des pages ASP).



La problématique

Vous désirez analyser certaines chaînes de caractères pour vérifier si elles sont des adresses de courriel valides.



Les solutions

a) solution traditionnelle

Une adresse de courriel valide ressemble à ceci :
[email protected]
[email protected]
[email protected]
[email protected]


Pour qu'elle soit valide, une adresse doit contenir un seul arobas (@) et au moins un point. Précédant ce arobas, il ne peut qu'y avoir que des lettres, des chiffres et certains autres caractères : le point (.), le caractère de soulignement (_) et le tiret (-). Ensuite, tout ce qui suit l'arobas et précède le dernier point suit les mêmes règles que ce qui précédait l'arobas. Finalement, seules des lettres peuvent suivre le dernier point. De plus, il ne peut y en avoir que deux (si c'est un nom de pays comme .ca, .fr, etc.) ou trois (.com, .net, .org, etc.). Je suis conscient que dans le futur, il y aura des noms de domaines qui se terminent par .bizz, .church et autres mais pour le moment, ce n'est pas la réalité. Par ailleurs, les caractères français (et même chinois) le seront dans le futur. Cependant, cet article tiens compte des faits actuels.

Selon la méthode traditionnelle, plusieurs lignes de codes seraient nécessaires. Veuillez noter que ce qui suit a ét&ecaute; écrit en VBScript et non en Visual Basic. La chaîne proviendrait du web et devra être enregistrée dans une base de donnée.

<%@ Language=VBScript %>
<%
Option Explicit
Dim iInvalid, sString
iInvalid=0
sString="[email protected]"


function isValidChar(c)
isValidChar=1
end function


function isValidLetter(c)
isValidLetter=1
end function


'vérification des caractères précédant l'arobas
For i=1 to inStr(1,sString, "@")
If isValidChar(mid(sString,i,1)) <> 1 then
iInvalid=1
end if
next


'vérification des caractères suivant l'arobas
for i=inStr(1,sString,"@") to len(sString)
if isValidChar(mid(sString,i,1)) <> 1 then
iInvalid=1
end if
next


'vérification des caractères suivant le dernier point
if inStrRev(sString,".") = 0 then
iInvalid=0
else
for i=len(sString) to inStrRev(sString,".") step -1
if isValidLetter(mid(sString,i,1)) <> 1 then
iInvalid=1
end if
next
end if


'on ne peut avoir deux points qui se suivent
for i=inStr(1,sString,"@") to len(sString)-1
if mid(sString,i,1) = "." And mid(sString,i+1,1)="." Then
iInvalid=1
end if
next


if iInvalid=1 then
response.write("adresse invalide")
else
response.write("adresse valide")
end if


%>


Ce qui précède n'a pas été vérifié et son exactitude est douteuse. Une chose est certaine, il vous faudrait programmer deux fonctions supplémentaires isValidLetter et isValidChar pour vérifier si un caractère est une lettre (majuscule ou minuscule), un chiffre ou les caractères spéciaux valides ou s'il n'est qu'une lettre. Je ne l'ai pas fait puisque je crois bien vous avoir démontré que cette méthode est longue.


b) solution avec les " regular expressions "

Seules quelques lignes de code sont nécessaires avec les " regular expression ".

<%@ Language=VBScript %>
<%
Option Explicit
Dim sString
sString="[email protected]"

dim objRegExpr
Set objRegExpr = New regexp

'avec quoi devrions nous comparer la chaîne de caractères ?
objRegExpr.Pattern = "^[a-zA-Z0-9\._-][email protected]([a-zA-Z0-9_-]+\.)+([a-zA-Z]{2,3})$"

'comparons la.
if objRegExpr.Test (sEmail) then
response.write("adresse valide")
else
response.write("adresse invalide")
end if

%>



Explication

Voici notre " regular expression " :
"^[a-zA-Z0-9\._-][email protected]([a-zA-Z0-9_-]+\.)+([a-zA-Z]{2,3})$"

C'est une chaîne de caractère, nous allons l'analyser :
Le ^ indique que ce qui suit doit être en début de chaîne.

[a-zA-Z0-9\._-] Indique les caractères valides. Comme vous voyez, trois intervalles sont utilisés et quelques autres caractères sont ajoutés. Notez que le \ n'est pas un caractère valide. Il est inséré devant le point puisque celui-ci est un caractère spécial. Si vous avez déjà programmé en C/C++, vous serez familiers avec cette notation.

Le plus (+) qui suit indique que ce qui était indiqué précédemment est répété une fois ou plus. (Doit exister au moins une fois.)

Notre arobas suit, indiquant ainsi qu'il est obligatoire dans la chaîne.

Des parenthèses suivies par un plus (+) regroupent une partie que nous analyserons séparément. Comme vu précédemment, le + indique que ce qui est entre les parenthèses est répété une fois au plus. Les parenthèses regroupent un ensemble d'expressions. Ici, ces expressions seront répétées.

[a-zA-Z0-9_-]+ signifie les caractères valides (notez que le point n'est plus là) qui sont répétés au moins une fois.

L'expression suivante est suivie d'un point. Ainsi, nous écrivons les sous domaines et le domaine, quelque soit leur longueur. En termes courants, nous enchaînons des chaînes de caractères qui se terminent par un point.

Ceci. Est. Un. Exemple. à Ceci.Est.Un.Exemple

Finalement, nous avons une autre parenthèse suivie du signe de dollar ($). Ceci signifie que le contenu de la parenthèse terminera la chaîne de caractères. Dans la parenthèse, nous voyons que seuls les lettres sont valides ([a-zA-Z]). Ce qui suit les crochet ({2,3}) est semblable au plus (+). Par contre, au lieu de dire au moins une répétition, nous spécifions deux ou trois répétitions.

En somme, ceci est un bref survol des possibilité des " regular expressions ". Je vous invite fortement à visiter le site ci-dessous pour en apprendre plus sur la syntaxe des " regular expressions ".



Conclusion

Voici une référence très intéressante chez Microsoft pouvant vous aider à explorer le monde des " regular expressions ".

http://msdn.microsoft.com/scripting/VBScript/

Jason: [email protected]




Jason  
( 2001-06-20 )  




Lisez cet article en anglais




Back



Français - English