Discussion :

[Charly910]

Bonjour,

@Cirec : j'ai essayé sans succès d'ajouter à ta chaine l'interdiction du point en fin de chaine.
le Pb c'est que j'ai beaucoup de mal à déchiffrer !
au début : ^[a-zA-Z]:\\ là je suis : c'est une lettre+:+\
ensuite mystère : que veut dire (((?![<>:"/\\|?*]).)+((?<![ .])\\)?)*$ ? dur dur, mes notions de PCRE sont trop récentes et faibles !
en particulier je ne comprends pas ?! : normalement ? = lettre facultative, mais c'est après une lettre ou une série
et ! : je ne trouve pas ce caractère spécial dans la littérature
Sinon ça marche bien sauf le point en fin de chaine.

@Roland Chastain : ta chaine marche bien, cependant, pour mes exemples :

C:\Caractere ^ ==> False mais est correct
C:\Caractere ¨ ==> False mais est correct (car les caractères ^ et ¨ sont valides)

et
C:\Program Files (x86)\AdwCleaner\\ ==> True mais est incorrect (une création de répertoire sous windows ne l'accepte pas)
C:\Program Files (x86)\AdwCleaner\ ==> True mais est incorrect (la cela dépend si on prend l'\ de fin ou non dans le nom du chemin)

là encore mes notions sont trop faibles pour corriger ta chaine !

je vais continuer à me documenter.

A+
Charly

[Roland Chastain]

C:\Program Files (x86)\AdwCleaner\\ ==> True mais est incorrect (une création de répertoire sous windows ne l'accepte pas)

En effet, entre temps je me suis aperçu de ce problème. Je proposerai une version corrigée (là je n'ai pas Delphi sous la main).

C:\Program Files (x86)\AdwCleaner\ ==> True mais est incorrect (la cela dépend si on prend l'\ de fin ou non dans le nom du chemin)

Dans le doute, j'ai supposé que cette forme était acceptable. Si tu ne souhaites pas l'accepter, je vais modifier mon expression en conséquence.

Pour les caractères '^' et '¨', je pense qu'il suffit de les rajouter (avec un "échappement" pour le premier) dans l'ensemble des caractères autorisés (entre les crochets).

À bientôt pour la suite !

[Cirec]

@Charly910: je suis, tout comme toi, au début de l'apprentissage des expressions régulières ... mes connaissances ne sont donc pas assez suffisantes pour pouvoir te donner une explication digne de ce nom !!! sorry

par-contre pour moi "?!" représente les caractères interdits : (?![<>:"/\\|?*])
rajoute n'importe quel caractère entre ces crochets et il sera considéré comme invalide

voilà ce que je peux ajouter ... pour l'instant

Edit:
je crois avoir trouvé

en ajoutant ceci: "[^.<>:"/\\|?*]" à l'expression ça a l'air de fonctionner

Code :

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

  aREGEX = '^[a-zA-Z]:\\(((?![<>:"/\\|?*]).)+((?<![ .])\\)?[^.<>:"/\\|?*])*$';

information trouvé ici

[Papy214]

Some people, when confronted with a problem, think "I know, I'll use regular expressions." Now they have two problems.

(la phrase date de 1997, par un certain hacker du nom de Jamie Zawinski )

[Charly910]

Merci Roland, merci Cirec (et merci Papy pour ce clin d’œil !!)

la nouvelle expression de Cirec fonctionne bien : elle invalide le point et le \ en fin de chaine. ainsi que le \\ en milieu de chaine.

Par contre, je ne sais pas pourquoi, mais :

C:\Program Files (x86)\HP ==> False

alors que c'est un répertoire valide sur mon PC !

A+
Charly

[SergioMaster]

Avec le code de Roland et l'expression de Sergio tout est "False" !!!

Celle de mon Post #16 ? pourtant je l'ai testée ! bon, il faut dire pas avec le programme de Roland et surtout pas avec PerlRegEx (<< c'est peut être là le hic) puisque mon Delphi 7 n'est là que pour faire tapisserie , plus sérieusement uniquement de la maintenance et j'ai pas installé les expressions régulières dessus

[Cirec]

@Charly910:

oui je viens de constater cela !!!
C:\Program Files (x86)\HP ==> False
C:\A ==> False

j'ai donc modifié, à nouveau, la REGEX et maintenant les deux exemples ci-dessus sont "True"

Code :

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

aREGEX = '^[a-zA-Z]:\\(((?![<>:"/\\|?*]).)?((?<![ .])\\)?+([^.<>:"/\\|?*]))*$';

les modifications entre l'ancienne et la nouvelle sont:
REGEX = '^[a-zA-Z]:\\(((?![<>:"/\\|?*]).)+((?<![ .])\\)?[^.<>:"/\\|?*])*$';
REGEX = '^[a-zA-Z]:\\(((?![<>:"/\\|?*]).)?((?<![ .])\\)?+[^.<>:"/\\|?*])*$';

Avec le code de Roland et l'expression de Sergio tout est "False" !!!

Celle de mon Post #16 ? pourtant je l'ai testée ! bon, il faut dire pas avec le programme de Roland et surtout pas avec PerlRegEx (<< c'est peut être là le hic)

oui c'est bien ce message.
et oui, c'est certainement à cause de la version utilisée PCRE (Perl Compatible Regular Expressions) et Expresso qui semble être .net compatible

on peut voir sur cette page les principales différences entre les versions
@+

[Charly910]

Merci Cirec,

quoique tu en dises, tu maitrises bien le Regex !

j'ai fait pas mal de tests qui sont tous concluants.

Peut être que cette chaine mériterait d'être mise dans la FAQ, car à part cela il y a peu de moyens de tester la validiter d'un nom de dossier ?

Je pense que cette fois ci c'est bien résolu

Merci à tous

Charly

[Roland Chastain]

Aux amis des expressions régulières compatibles Perl, salut.

Je vois que la discussion est résolue. Cependant, comme j'ai encore travaillé de mon côté, je souhaiterais vous proposer ce que j'ai trouvé.

Ma proposition serait la suivante :

Code :

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

1
2
3
4
const
  INTERDITS = '\\/:*?"<>|';
...
    RegEx := Format('^[A-Za-z]:(\\%s)+$', ['[^' + INTERDITS + ']+']);

Où '(\\%s)+' (c'est-à-dire '(\\[^' + INTERDITS + ']+)+') signifie "un certain nombre de fois une barre oblique inversée suivie d'un certain nombre de caractères appartenant à la classe définie par l'exclusion des caractères interdits".

Sauf qu'il y a encore le problème du point, qui est autorisé, mais pas à la fin ni deux fois de suite (si je ne me trompe). La proposition devient donc :

Code :

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

    RegEx := Format('^[A-Za-z]:(\\%s)+$', ['(\.?[^' + INTERDITS + '.]+)+']);

C'est-à-dire qu'on ajoute le point dans la classe des caractères interdits mais qu'on l'autorise à la position précédente.

Enfin, pour compliquer encore un peu les choses, il y a le cas particulier d'un chemin du type C:\, qu'il faut accepter aussi. Pour ce faire je ne vois pas d'autre moyen que d'introduire une alternative :

Code :

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

    RegEx := Format('^[A-Za-z]:(\\|(\\%s)+)$', ['(\.?[^' + INTERDITS + '.]+)+']);

Ce qui peut s'écrire aussi de la façon suivante :

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
    RegEx := Format(
      '^[A-Za-z]:(%s|%s)$',
      [
        '\\',
        Format(
          '(\\%s)+',
          [
            Format(
              '(\.?%s+)+',
              [
                Format(
                  '[^%s.]',
                  [
                    INTERDITS
                  ]
                )
              ]
            )
          ]
        )
      ]
    );

Ou encore :

Code :

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

    RegEx := '^[A-Za-z]:(\\|(\\(\.?[^' + INTERDITS + '.]+)+)+)$';

[Cirec]

je viens de tester l'expression de Roland et elle fonctionne parfaitement

pour ceux qui voudrait tester je vous la donne en claire

Code :

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

RegEx = '^[A-Za-z]:(\\|(\\(\.?[^<>:"/\\|?*.]+)+)+)$';

parce que tu n'as pas choisi la méthode la plus simple pour nous la présenter

@Charly:
merci pour ton soutien mais je pense plutôt avoir une bonne maitrise de Google et une bonne dose de chance du débutant (en RegEx hein ^^)
en ce qui concerne la FAQ ... à choisir je prendrai celle de Roland elle est plus simple à comprendre et tout aussi efficace

[Charly910]

Merci Roland de m'avoir consacré du temps.

Maintenant, avec ta chaine on atteint la perfection !

J'ai fait pas mal de tests sans mettre en défaut ta chaine.

A+
Charly

PS : toutefois .. est accepté en milieu de chaine : Sous Windows, dans l'explorateur de fichier, j'ai testé la création du répertoire FF..FF avec succès (mais Windosw refuse FFF. et FFF.. naturellement)

[Roland Chastain]

je viens de tester l'expression de Roland et elle fonctionne parfaitement

Merci pour le test.

parce que tu n'as pas choisi la méthode la plus simple pour nous la présenter

Oui, j'ai cherché un moyen de rendre l'expression plus intelligible en la décomposant, mais peut-être me suis-je donné du mal pour rien.

Merci Roland de m'avoir consacré du temps.

Maintenant, avec ta chaine on atteint la perfection !

J'ai fait pas mal de tests sans mettre en défaut ta chaine.

Pas de quoi, merci pour le test.

PS : toutefois .. est accepté en milieu de chaine : Sous Windows, dans l'explorateur de fichier, j'ai testé la création du répertoire FF..FF avec succès (mais Windosw refuse FFF. et FFF.. naturellement)

Je pense qu'il suffit de remplacer '\.?' par '\.*' pour autoriser plusieurs points consécutifs tout en continuant de les interdire en fin de chaîne. Et cette fois nous dirons que l'expression est vraiment parfaite.

Je m'en vais de ce pas créer une entrée dans la FAQ.

[Roland Chastain]

Je m'en vais de ce pas créer une entrée dans la FAQ.

Fait.

http://delphi.developpez.com/faq/?pa...dossier-valide

[Charly910]

Merci Roland (et merci aussi à tous),
cette fois ci c'est parfait

je suis content non pas d'avoir contribué, mais d'avoir suggéré l'idée pour la FAQ !

Cette fois-ci c'est super résolu.

A+ Charly

[SergioMaster]

Bonjour,

si pour D7 j'ai indiqué que passer par les expressions régulières pouvaient être une solution (comme prouvé par la suite)
Il n'empêche que les nouvelles versions ont quand même quelques fonctions utiles fourrées dans System.IOUtils et toutes "portables"
je pense par exemple à :

HasValidPathChars(const Path: string; const UseWildcards: Boolean)

et les

IsDriveRooted(const Path: string): Boolean; static;
IsExtendedPrefixed(const Path: string): Boolean; inline; static;
IsRelativePath(const Path: string): Boolean; static;
IsUNCPath(const Path: string): Boolean; inline; static;
IsUNCRooted(const Path: string): Boolean; static;

et pour windows

HasPathValidColon(const Path: string): Boolean;

Certaines de ces fonctions sont mêmes apparues dès D2010

étrangement une fonction comme IsValidPath n'existe pas, à moins que je n'ai pas assez cherché

Il serait assez "amusant" de comparer les temps et efficacité de ces différentes options (ah si j'avais un stagiaire ou un étudiant sous la main quel bel exercice cela ferait )