Discussion :

[m_biaggi]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Pikooz]

Personnelement, j'aurais interdit les langages contenant un @ avant et apres le @ que tu as spécifié.

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
"prenom.nom@test.com"
"prenom-nom@test.com"
"prenom_nom@test.com"

a++

[bigben99]

une expression régulière assez simple pour vérifier que tu as :
xxxx@xxx.xxx :
"^.+@.+[.].+$"

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[edit] grilled [/edit]

[m_biaggi]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !