[RegEx] Valider une date

Version imprimable

Heps tout le monde !

Ca va faire maintenant quelques heures que je coince avec un pattern regex en Java... Le but est de valider des adresses email. J'ai déjà cherché sur le web et consulté cet api (http://java.sun.com/j2se/1.4.2/docs/...x/Pattern.html) mais tout ce que j'ai trouvés et compilés jusqu'ici ne donne pas le bon résultat dans un les deux cas suivant :

"test@test@test.com" est validé ! (j'aimerai interdire 2x @)
"test@test.com test@test.com" est validé aussi !

Voici mon code :
Code:

1 2 3 4 5 6 7 8 Pattern p = Pattern.compile("(\\w+)@(\\w+\\.)(\\w+)(\\.\\w+)*"); Matcher m = p.matcher(input); if (!m.find()){ System.out.println("Email address has wrong format ! Expected : xxx@xxx.xx(.xx)>"); }else{ System.out.println("OK"); }
merci d'avance pour votre aide ;)

15/02/2007, 17h09
Pikooz

Personnelement, j'aurais interdit les langages contenant un @ avant et apres le @ que tu as spécifié.
15/02/2007, 17h37
adiGuba
Salut,

Tu utilises mal la classe Matcher : la méthode find() recherche la première sous-chaine qui correspondent à ton pattern.

Pour vérifier que l'intégralité de la chaine corresponde au pattern il faut utiliser la méthode matches()...

Ensuite il faudrait peut-être revoir ton pattern... les emails acceptent les underscore et tiret, tout comme les points...

Les emails suivants sont valides mais pas avec ton expressions :
Code:

1 2 3 "prenom.nom@test.com" "prenom-nom@test.com" "prenom_nom@test.com"
a++
15/02/2007, 17h38
bigben99

une expression régulière assez simple pour vérifier que tu as :
xxxx@xxx.xxx :
"^.+@.+[.].+$"
15/02/2007, 17h41
le y@m's
Il ne faut pas utiliser la méthode find() qui cherche une occurrence de l'expression régulière mais la méthode matches() qui elle vérifie la concordance exact.
Tu peux même utiliser directement la méthode matches() de la classe String (cette méthode n'est pas celle de la classe Matcher mais donne le même résultat).
Code:

1 2 3 4 5 6 7 8 Pattern p = Pattern.compile("\\w+@\\w+\\.\\w+(\\.\\w+)*"); Matcher m = p.matcher(input); if(m.matches() { // OK } else { // Invalid Email }
ou
Code:

1 2 3 4 5 if(input.matches("\\w+@\\w+\\.\\w+(\\.\\w+)*")) { // OK } else { // Invalid Email }
[edit] grilled [/edit]

ah oui en effet ! Ca fonctionne bien mieux avec la méthode matches() ! J'ai encore un peu travaillé les tests et j'arrive maintenant à quelque chose de suffisant pour mon projet.

Pour ceux que ca pourrait intéresser ou aider :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
public static boolean isEmailWellFormed(String email){
  String input = email;
 
  if (input == null){
    System.out.println("Email address cannot be null !");
    return false;
  }
 
  //regex pattern info : http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html
  //checks for email right format
  Pattern p = Pattern.compile("(\\w+)((\\.|\\-)\\w+)*@((\\w+\\.)|(\\w+\\-))(\\w+)(\\.\\w+)*");
 
  Matcher m = p.matcher(input);
  if (!m.matches()) {
    System.out.println("Email address has wrong format !");
    return false;
  }
 
  return true;
}

Et voici la classe de test JUnit

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
	@Test
	public void emailIsNull(){
		assertFalse(Validator.isEmailWellFormed(null));
	}
 
	@Test
	public void emailIsEmpty(){
		assertFalse(Validator.isEmailWellFormed(""));
	}
 
	@Test
	public void emailStartsWithDot(){
		assertFalse(Validator.isEmailWellFormed(".@test.com"));
	}
 
	@Test
	public void emailStartsWithArobase(){
		assertFalse(Validator.isEmailWellFormed("@test.com"));
	}
 
	@Test
	public void emailWithoutArobase(){
		assertFalse(Validator.isEmailWellFormed("test.com"));
	}
 
	@Test
	public void emailContains2Arobases(){
		assertFalse(Validator.isEmailWellFormed("test@test@test.com"));
	}
 
	@Test
	public void emailContainsIllegalChar(){
		char c = ']';
		assertFalse(Validator.isEmailWellFormed("test" + c + "test@test."));
	}
 
	@Test
	public void emailBadFormat1(){
		assertFalse(Validator.isEmailWellFormed("test@test"));
	}
 
	@Test
	public void emailBadFormat2(){
		assertFalse(Validator.isEmailWellFormed("test@test.com test@test.com"));
	}
 
	@Test
	public void emailRightFormat1(){
		assertTrue(Validator.isEmailWellFormed("test@test.com"));
	}
 
	@Test
	public void emailRightFormat2(){
		assertTrue(Validator.isEmailWellFormed("test_test@test.com"));
	}
 
	@Test
	public void emailRightFormat3(){
		assertTrue(Validator.isEmailWellFormed("test.test@test.com"));
	}
 
	@Test
	public void emailRightFormat4(){
		assertTrue(Validator.isEmailWellFormed("test-test@test.com"));
	}
 
	@Test
	public void emailRightFormat5(){
		assertTrue(Validator.isEmailWellFormed("test@test_test.ch"));
	}
 
	@Test
	public void emailRightFormat6(){
		assertTrue(Validator.isEmailWellFormed("test@test.test.ch"));
	}
 
	@Test
	public void emailRightFormat7(){
		assertTrue(Validator.isEmailWellFormed("test@test-test.ch"));
	}

Merci à tous pour votre aide !