Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
nioubi
Jean-Philippe Caruana wrote:
Pattern p = Pattern.compile("aaabbc"); Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher("."); boolean b = m.matches(); System.out.println("b = " + b); Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
Jean-Philippe Caruana wrote:
Pattern p = Pattern.compile("aaabbc");
Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher(".");
boolean b = m.matches();
System.out.println("b = " + b);
Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
Pattern p = Pattern.compile("aaabbc"); Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher("."); boolean b = m.matches(); System.out.println("b = " + b); Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
Xavier MOGHRABI
nioubi wrote:
Jean-Philippe Caruana wrote:
Pattern p = Pattern.compile("aaabbc"); Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher("."); boolean b = m.matches(); System.out.println("b = " + b); Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
pas mieux.tu as inversé le pattern et la chaîne sur laquelle on applique le pattern.
un petit exemple sur : http://javaalmanac.com/egs/java.util.regex/BasicMatch.html
il y en a d'autres : http://javaalmanac.com/egs/java.util.regex/pkg.html
Pattern p = Pattern.compile("aaabbc");
Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher(".");
boolean b = m.matches();
System.out.println("b = " + b);
Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
pas mieux.tu as inversé le pattern et la chaîne sur laquelle on applique le
pattern.
un petit exemple sur :
http://javaalmanac.com/egs/java.util.regex/BasicMatch.html
il y en a d'autres :
http://javaalmanac.com/egs/java.util.regex/pkg.html
Pattern p = Pattern.compile("aaabbc"); Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher("."); boolean b = m.matches(); System.out.println("b = " + b); Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
pas mieux.tu as inversé le pattern et la chaîne sur laquelle on applique le pattern.
un petit exemple sur : http://javaalmanac.com/egs/java.util.regex/BasicMatch.html
il y en a d'autres : http://javaalmanac.com/egs/java.util.regex/pkg.html
Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher("."); boolean b = m.matches(); System.out.println("b = " + b);
Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
ok merci, j'avais inversé Pattern et chaine en revanche, je suis surpris du comportement de matcher :
boolean c = Pattern.matches(".", "aaabbc"); ==> false boolean c = Pattern.matches(".*", "aaabbc"); ==> true boolean c = Pattern.matches("a*b", "aaaab"); ==> true boolean c = Pattern.matches("a*b", "aaaabc"); ==> false
comment faire pour avoir un équivalent aux regex unix (comme avec les maginifiques sed, awk ou perl) ?
je m'explique : en perl (par ex), un match trouve tjs vrai pour mes 4 exemple. Ca s'assimile à "si tu trouves dans la chaine qqch qui correspond à ma regexp, alors VRAI". Tou Tandis que java.util.regex.*, ca donne plutot "si toute ma chaine correspond à ma regexp, alors VRAI"
-- jpc http://www.enstimac.fr/~caruana/
Jean-Philippe Caruana wrote:
Pattern p = Pattern.compile("aaabbc");
Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher(".");
boolean b = m.matches();
System.out.println("b = " + b);
Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
ok merci, j'avais inversé Pattern et chaine
en revanche, je suis surpris du comportement de matcher :
boolean c = Pattern.matches(".", "aaabbc"); ==> false
boolean c = Pattern.matches(".*", "aaabbc"); ==> true
boolean c = Pattern.matches("a*b", "aaaab"); ==> true
boolean c = Pattern.matches("a*b", "aaaabc"); ==> false
comment faire pour avoir un équivalent aux regex unix (comme avec les
maginifiques sed, awk ou perl) ?
je m'explique :
en perl (par ex), un match trouve tjs vrai pour mes 4 exemple. Ca
s'assimile à "si tu trouves dans la chaine qqch qui correspond à ma
regexp, alors VRAI". Tou
Tandis que java.util.regex.*, ca donne plutot "si toute ma chaine
correspond à ma regexp, alors VRAI"
Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher("."); boolean b = m.matches(); System.out.println("b = " + b);
Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
ok merci, j'avais inversé Pattern et chaine en revanche, je suis surpris du comportement de matcher :
boolean c = Pattern.matches(".", "aaabbc"); ==> false boolean c = Pattern.matches(".*", "aaabbc"); ==> true boolean c = Pattern.matches("a*b", "aaaab"); ==> true boolean c = Pattern.matches("a*b", "aaaabc"); ==> false
comment faire pour avoir un équivalent aux regex unix (comme avec les maginifiques sed, awk ou perl) ?
je m'explique : en perl (par ex), un match trouve tjs vrai pour mes 4 exemple. Ca s'assimile à "si tu trouves dans la chaine qqch qui correspond à ma regexp, alors VRAI". Tou Tandis que java.util.regex.*, ca donne plutot "si toute ma chaine correspond à ma regexp, alors VRAI"
-- jpc http://www.enstimac.fr/~caruana/
nioubi
Jean-Philippe Caruana wrote:
je suis surpris du comportement de matcher :
boolean c = Pattern.matches(".", "aaabbc"); ==> false boolean c = Pattern.matches(".*", "aaabbc"); ==> true boolean c = Pattern.matches("a*b", "aaaab"); ==> true boolean c = Pattern.matches("a*b", "aaaabc"); ==> false En effet matches() répond vrai si la chaine /entiere/ matche le
pattern alors que sed (et al) cherche la premiere occurence concordante.
comment faire pour avoir un équivalent aux regex unix (comme avec les maginifiques sed, awk ou perl) ? Je n'ai pas de réponse immédiate.
Il faudrait peut-être voir http://www.cacas.org/java/gnu/regexp/
Jean-Philippe Caruana wrote:
je suis surpris du comportement de matcher :
boolean c = Pattern.matches(".", "aaabbc"); ==> false
boolean c = Pattern.matches(".*", "aaabbc"); ==> true
boolean c = Pattern.matches("a*b", "aaaab"); ==> true
boolean c = Pattern.matches("a*b", "aaaabc"); ==> false
En effet matches() répond vrai si la chaine /entiere/ matche le
pattern alors que sed (et al) cherche la premiere occurence concordante.
comment faire pour avoir un équivalent aux regex unix (comme avec les
maginifiques sed, awk ou perl) ?
Je n'ai pas de réponse immédiate.
Il faudrait peut-être voir http://www.cacas.org/java/gnu/regexp/
boolean c = Pattern.matches(".", "aaabbc"); ==> false boolean c = Pattern.matches(".*", "aaabbc"); ==> true boolean c = Pattern.matches("a*b", "aaaab"); ==> true boolean c = Pattern.matches("a*b", "aaaabc"); ==> false En effet matches() répond vrai si la chaine /entiere/ matche le
pattern alors que sed (et al) cherche la premiere occurence concordante.
comment faire pour avoir un équivalent aux regex unix (comme avec les maginifiques sed, awk ou perl) ? Je n'ai pas de réponse immédiate.
Il faudrait peut-être voir http://www.cacas.org/java/gnu/regexp/
Xavier MOGHRABI
nioubi wrote:
Jean-Philippe Caruana wrote:
je suis surpris du comportement de matcher :
boolean c = Pattern.matches(".", "aaabbc"); ==> false boolean c = Pattern.matches(".*", "aaabbc"); ==> true boolean c = Pattern.matches("a*b", "aaaab"); ==> true boolean c = Pattern.matches("a*b", "aaaabc"); ==> false En effet matches() répond vrai si la chaine /entiere/ matche le
pattern alors que sed (et al) cherche la premiere occurence concordante.
comment faire pour avoir un équivalent aux regex unix (comme avec les maginifiques sed, awk ou perl) ? Je n'ai pas de réponse immédiate.
Il faudrait peut-être voir http://www.cacas.org/java/gnu/regexp/
boolean c = Pattern.matches(".", "aaabbc"); ==> false
boolean c = Pattern.matches(".*", "aaabbc"); ==> true
boolean c = Pattern.matches("a*b", "aaaab"); ==> true
boolean c = Pattern.matches("a*b", "aaaabc"); ==> false
En effet matches() répond vrai si la chaine /entiere/ matche le
pattern alors que sed (et al) cherche la premiere occurence concordante.
comment faire pour avoir un équivalent aux regex unix (comme avec les
maginifiques sed, awk ou perl) ?
Je n'ai pas de réponse immédiate.
Il faudrait peut-être voir http://www.cacas.org/java/gnu/regexp/
boolean c = Pattern.matches(".", "aaabbc"); ==> false boolean c = Pattern.matches(".*", "aaabbc"); ==> true boolean c = Pattern.matches("a*b", "aaaab"); ==> true boolean c = Pattern.matches("a*b", "aaaabc"); ==> false En effet matches() répond vrai si la chaine /entiere/ matche le
pattern alors que sed (et al) cherche la premiere occurence concordante.
comment faire pour avoir un équivalent aux regex unix (comme avec les maginifiques sed, awk ou perl) ? Je n'ai pas de réponse immédiate.
Il faudrait peut-être voir http://www.cacas.org/java/gnu/regexp/
boolean c = Pattern.matches("a*b", "aaaabc"); ==> false là c'est "normal", pour matcher toute la string, il faudrait plutôt:
boolean c = Pattern.matches("a*b.*", "aaaabc"); par ex non ?
-- yt
Alain Laroche
Jean-Philippe Caruana wrote:
Jean-Philippe Caruana wrote:
Pattern p = Pattern.compile("aaabbc");
Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher("."); boolean b = m.matches(); System.out.println("b = " + b);
Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
ok merci, j'avais inversé Pattern et chaine en revanche, je suis surpris du comportement de matcher :
boolean c = Pattern.matches(".", "aaabbc"); ==> false boolean c = Pattern.matches(".*", "aaabbc"); ==> true boolean c = Pattern.matches("a*b", "aaaab"); ==> true boolean c = Pattern.matches("a*b", "aaaabc"); ==> false
comment faire pour avoir un équivalent aux regex unix (comme avec les maginifiques sed, awk ou perl) ?
je m'explique : en perl (par ex), un match trouve tjs vrai pour mes 4 exemple. Ca s'assimile à "si tu trouves dans la chaine qqch qui correspond à ma regexp, alors VRAI". Tou Tandis que java.util.regex.*, ca donne plutot "si toute ma chaine correspond à ma regexp, alors VRAI"
Essaie le package oro d'Apache. Là tu as le choix entre plusieurs syntaxes d'exrpessions régulières, et le choix entre les méthodes "matches" et "contains", qui correspond plus au comportement de grep par exemple.
Jean-Philippe Caruana wrote:
Jean-Philippe Caruana wrote:
Pattern p = Pattern.compile("aaabbc");
Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher(".");
boolean b = m.matches();
System.out.println("b = " + b);
Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de
Pattern.
ok merci, j'avais inversé Pattern et chaine
en revanche, je suis surpris du comportement de matcher :
boolean c = Pattern.matches(".", "aaabbc"); ==> false
boolean c = Pattern.matches(".*", "aaabbc"); ==> true
boolean c = Pattern.matches("a*b", "aaaab"); ==> true
boolean c = Pattern.matches("a*b", "aaaabc"); ==> false
comment faire pour avoir un équivalent aux regex unix (comme avec les
maginifiques sed, awk ou perl) ?
je m'explique :
en perl (par ex), un match trouve tjs vrai pour mes 4 exemple. Ca
s'assimile à "si tu trouves dans la chaine qqch qui correspond à ma
regexp, alors VRAI". Tou
Tandis que java.util.regex.*, ca donne plutot "si toute ma chaine
correspond à ma regexp, alors VRAI"
Essaie le package oro d'Apache.
Là tu as le choix entre plusieurs syntaxes d'exrpessions régulières, et le
choix entre les méthodes "matches" et "contains", qui correspond plus au
comportement de grep par exemple.
Attention ici il faut un pattern et non une chaine à chercher
Matcher m = p.matcher("."); boolean b = m.matches(); System.out.println("b = " + b);
Tel que c'est écrit tu cherches "aaabbc" dans ".". Voir la doc de Pattern.
ok merci, j'avais inversé Pattern et chaine en revanche, je suis surpris du comportement de matcher :
boolean c = Pattern.matches(".", "aaabbc"); ==> false boolean c = Pattern.matches(".*", "aaabbc"); ==> true boolean c = Pattern.matches("a*b", "aaaab"); ==> true boolean c = Pattern.matches("a*b", "aaaabc"); ==> false
comment faire pour avoir un équivalent aux regex unix (comme avec les maginifiques sed, awk ou perl) ?
je m'explique : en perl (par ex), un match trouve tjs vrai pour mes 4 exemple. Ca s'assimile à "si tu trouves dans la chaine qqch qui correspond à ma regexp, alors VRAI". Tou Tandis que java.util.regex.*, ca donne plutot "si toute ma chaine correspond à ma regexp, alors VRAI"
Essaie le package oro d'Apache. Là tu as le choix entre plusieurs syntaxes d'exrpessions régulières, et le choix entre les méthodes "matches" et "contains", qui correspond plus au comportement de grep par exemple.
nioubi
Xavier MOGHRABI wrote:
essaye la méthode find au lien du matches Oups exact. Merci !
Xavier MOGHRABI wrote:
essaye la méthode find au lien du matches
Oups exact. Merci !
j'ai esayé avec des regexp qui matchent pas, c'est tjs faux (normal donc)
Pour reellement comprendre comment fonctionne les regexes, je recommande le livre Mastering Regular Expression, seconde edition. Une lecture attentive de ce livre m'a permis d'accelerer grandement mes regexes. (notre application execute plus de 200 millions de regexes par jour - on compte les nanosecondes...)
-- Marc Petit-Huguenin Home: Work:
Jean-Philippe Caruana wrote:
bonjour,
je tente de me servir des classes regex pour pouvoir me servir des
expressions régulières.
d'après un tuto de cyberzoid.developpez.com, j'essaye :
--------------------------------------
Pattern p = Pattern.compile("aaabbc");
Matcher m = p.matcher(".");
boolean b = m.matches();
System.out.println("b = " + b);
--------------------------------------
normalement, le '.' doit tjs retourner vrai, ca veut dire 'n'importe
quoi'. Mais la réponse est invariablement False. Comment cela se fait-il ?
J'ai également essayé une syntaxe du type plus rapide :
j'ai esayé avec des regexp qui matchent pas, c'est tjs faux (normal donc)
Pour reellement comprendre comment fonctionne les regexes, je recommande
le livre Mastering Regular Expression, seconde edition. Une lecture
attentive de ce livre m'a permis d'accelerer grandement mes regexes.
(notre application execute plus de 200 millions de regexes par jour - on
compte les nanosecondes...)
--
Marc Petit-Huguenin
Home: marc@petit-huguenin.org
Work: marc@8x8.com
j'ai esayé avec des regexp qui matchent pas, c'est tjs faux (normal donc)
Pour reellement comprendre comment fonctionne les regexes, je recommande le livre Mastering Regular Expression, seconde edition. Une lecture attentive de ce livre m'a permis d'accelerer grandement mes regexes. (notre application execute plus de 200 millions de regexes par jour - on compte les nanosecondes...)
-- Marc Petit-Huguenin Home: Work:
Thibal
Marc Petit-Huguenin wrote:
Jean-Philippe Caruana wrote:
bonjour,
je tente de me servir des classes regex pour pouvoir me servir des expressions régulières.
d'après un tuto de cyberzoid.developpez.com, j'essaye :
-------------------------------------- Pattern p = Pattern.compile("aaabbc"); Matcher m = p.matcher("."); boolean b = m.matches(); System.out.println("b = " + b); --------------------------------------
normalement, le '.' doit tjs retourner vrai, ca veut dire 'n'importe quoi'. Mais la réponse est invariablement False. Comment cela se fait-il ?
J'ai également essayé une syntaxe du type plus rapide :
j'ai esayé avec des regexp qui matchent pas, c'est tjs faux (normal donc)
Pour reellement comprendre comment fonctionne les regexes, je recommande le livre Mastering Regular Expression, seconde edition. Une lecture attentive de ce livre m'a permis d'accelerer grandement mes regexes. (notre application execute plus de 200 millions de regexes par jour - on compte les nanosecondes...)
Moi je suis pas sûr d'avoir bien compris votre problème, car il m'arrive assez régulièrement d'utiliser la méthode matches() de la classe String, et je n'ai jamais eu de problème avec mes expressions régulières, ç'est toujours bien passé comme prévu...
Marc Petit-Huguenin wrote:
Jean-Philippe Caruana wrote:
bonjour,
je tente de me servir des classes regex pour pouvoir me servir des
expressions régulières.
d'après un tuto de cyberzoid.developpez.com, j'essaye :
--------------------------------------
Pattern p = Pattern.compile("aaabbc");
Matcher m = p.matcher(".");
boolean b = m.matches();
System.out.println("b = " + b);
--------------------------------------
normalement, le '.' doit tjs retourner vrai, ca veut dire 'n'importe
quoi'. Mais la réponse est invariablement False. Comment cela se
fait-il ?
J'ai également essayé une syntaxe du type plus rapide :
j'ai esayé avec des regexp qui matchent pas, c'est tjs faux (normal
donc)
Pour reellement comprendre comment fonctionne les regexes, je recommande
le livre Mastering Regular Expression, seconde edition. Une lecture
attentive de ce livre m'a permis d'accelerer grandement mes regexes.
(notre application execute plus de 200 millions de regexes par jour - on
compte les nanosecondes...)
Moi je suis pas sûr d'avoir bien compris votre problème, car il m'arrive
assez régulièrement d'utiliser la méthode matches() de la classe String,
et je n'ai jamais eu de problème avec mes expressions régulières, ç'est
toujours bien passé comme prévu...
j'ai esayé avec des regexp qui matchent pas, c'est tjs faux (normal donc)
Pour reellement comprendre comment fonctionne les regexes, je recommande le livre Mastering Regular Expression, seconde edition. Une lecture attentive de ce livre m'a permis d'accelerer grandement mes regexes. (notre application execute plus de 200 millions de regexes par jour - on compte les nanosecondes...)
Moi je suis pas sûr d'avoir bien compris votre problème, car il m'arrive assez régulièrement d'utiliser la méthode matches() de la classe String, et je n'ai jamais eu de problème avec mes expressions régulières, ç'est toujours bien passé comme prévu...
