Récupération d'un nombre variable de champs à l'aide d'une regex

Bonjour,

je recevais d'un prestataire des fichiers plats avec des champs pouvant contenir un nom de variable à traiter dans la suite du programme, exemple

Code:

---

LISTE_REGLEMENT_${XXXX}.csv

---

Avec le code suivant, je pouvais récupérer "XXXX" dans $var :

Code:

---

1 2 3

if ( $str =~ /^(.*)\$\{(.+)\}(.*)$/ ) { ( $prf, $var, $suf ) = ( $1, $2, $3); }

---

Maintenant ces champs peuvent contenir n variables, dela forme :

Code:

---

'LISTE_REGLEMENT_${AA}${MM}.csv

---

pour récupérer AA et MM, ou

Code:

---

'LISTE_REGLEMENT_${AA}${MM}-phase1-${XXXX}.csv

---

pour récupérer AA, MM et XXXX

Est-il possible de résoudre cette demande en utilisant toujours les regex ?

Il me semble plus prudent de faire du split simple...
En premier sur $
Qui te donnera :

Code:

---

{"LISTE_REGLEMENT_","{AA}","{MM}-phase1-","{XXXX}.csv"}

---

Tu ne prends pas le premier, car non précédé d'un $.
Et tu fais de nouveau un split sur les autres avec les caractères de séparation "-" et "." en ne conservant que le début.

Sauf si tes variable dispose de caractère de séparation du devrait être tranquille.

Lien vers la doc split Perl:
http://www.comp.leeds.ac.uk/Perl/split.html

Cordialement,
Patrick Kolodziejczyk.

Merci pour ce 1er axe de recherche.

Je dois préciser que le contenu des champs est variable, ils peuvent du texte libre et de 1 à n variables :

Code:

---

{"LISTE_REGLEMENT_","{AA}","{MM}-phase1-","{XXXX}.csv"}

---

ou

Code:

---

ARRETE ${YYYY} du traitement ${ZZ} integré dans archive${RR}${ZZ}

---

Je dois pouvoir identifier toutes les chaînes intégrées dans les motifs ${} pour la suite du traitement

A ce moment là faut poser des règles simple :
Pas de $ dans une variable.
Ainsi qu'une liste de délimiteur donnée : Espace, point...

Il faut que tu ai un moyen simple de déterminer si tu prend en compte "-phase1" ou " integré dans archive"

Si l'espace est un délimiteur, alors non. Sinon, c'est à prendre en compte de manière systématique.

Les règles à appliquées doivent être simple systématique et réalisable avec un papier et un stylo.

Cordialement,
Patrick Kolodziejczyk.

J'ai pris le papier et le stylo :)
La règle est : identifier dans un champ variable toutes les valeurs matchant le motif ${.+}, quelles que soient leur position.

J'ai trouvé une solution (de contournement ? ) qui fonctionne.
Je me demande maintenant s'il n'y a pas une solution plus simple avec une regex et sans la structure while.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#!/usr/bin/perl -w use strict;   my $str = 'LISTE_REGLEMENT_${AA}${MM}-phase1-${XXXX}.csvr'; my @vars;   while ( $str =~ /\$\{(.+?)\}/ ) { my $var = $1; $str =~ s/\$\{$var\}//; push(@vars, $var); }   print join ("-", @vars); print "\n";

---

Résultat :

Code:

---

1 2 3

$ ./test_regex2.pl AA-MM-XXXX

---

Bonjour,

Cette expression régulière en contexte de liste devrait le faire:

Code:

---

1 2	/\$\{([^}]+)\}/g

---

Un exemple illustré sous le debugger:

Code:

---

1 2 3 4 5 6 7 8 9 10

DB<1> $str = 'LISTE_REGLEMENT_${AA}${MM}-phase1-${XXXX}.csvr';   DB<2> @vars = $str =~ /\$\{([^}]+)\}/g;   DB<3> x \@vars 0 ARRAY(0x600500d38) 0 'AA' 1 'MM' 2 'XXXX'

---

A ta disposition pour te fournir des explications supplémentaires si tu ne comprends pas tout.

J'ai remplace avec succès ma structure while par :

Code:

---

( @vars ) = ( $str =~ /\$\{([^}]+)\}/g );

---

C'est ce que je cherchais à construire.
Par contre, bien qu'entrevoyant (de manière nébuleuse) une interprétation de la construction, je lirais avec une très grande attention ton explication :mrgreen:

Alors,

Code:

---

1 2	/\$\{([^}]+)\}/g

---

reconnaît:

- \$ : un signe $, suivi de:
- \{ : une accolade ouvrante, suivie de:
- ( : une parenthèse ouvrante servant uniquement à la capture de ce qui suit jusqu'à la parenthèse fermante
- [^}]+ : un ou plusieurs caractères quelconques autres qu'une accolade fermante ( "[^}]" est une classe de caractère négative, à noter qu'il n'est pas nécessaire de précéder l'accolade d'un antislash dans une classe de caractère), suivi de
- ) : la parenthèse fermante de la capture, suivie de
- \} : une accolage fermante.

Le modificateur /g demande à la regex de faire la reconnaissance du motif autant de fois que possible et, en contexte de liste, la regex renvoie une liste de chaînes reconnues et capturées qu'il suffit d'affecter au tableau @vars.

A noter qu'il est inutile de mettre @vars entre parenthèses, c'est un tableau, il suffit à fournir le contexte de liste (mais ça ne gêne pas).

De même, l'opérateur d'affectation "=" ayant une précédence bien plus faible que l'opérateur de liaison "=~", les parenthèses ne sont pas nécessaires autour de l'expression "$str =~ /\$\{([^}]+)\}/g ", il est garanti que cette expression sera évaluée avant l'affectation, donc:

Code:

---

1 2	my @vars = $str =~ /\$\{([^}]+)\}/g;

---

sans ces parenthèses suffit, mais tu peux tout à fait mettre ces parenthèses si tu trouves que c'est plus clair ainsi.

Bonjour,

Cette expression régulière suffit amplement :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#!/usr/bin/perl use warnings; use strict; use Data::Dumper;   my $chaine = <<'TEST'; LISTE_REGLEMENT_${AA}${MM}-phase1-${XXXX}.csvr ARRETE ${YYYY} du traitement ${ZZ} integré dans archive${RR}${ZZ} $test et autre champ{} - ${AUTRE_VARIABLE} TEST my @variables = $chaine =~ m{ \$ # distinction de la variable \{ # délimitation de la variable (.+?) # Nom de la variable capturé \} # Fin délimitation de la variable }msgx;

---

On obtient bien

Code:

---

1 2 3 4 5 6 7 8 9 10

$VAR1 = [ 'AA', 'MM', 'XXXX', 'YYYY', 'ZZ', 'RR', 'ZZ', 'AUTRE_VARIABLE' ];

---

J'utilise déjà beaucoup les expressions rationnelles, mais je n'avais jamais été confronté à cette problématique.

Dans ma structure while j'utilise un quantificateur non gourmand et cela fonctionne, par contre je me doutais qu'il y avait plus simple à faire.
Je ne savais pas qu'on pouvait récupérer dans un tableau toutes les correspondances en une seule expression.

Un grand :merci:.

Citation:

---

Envoyé par ptonnerre

Je ne savais pas qu'on pouvait récupérer dans un tableau toutes les correspondances en une seule expression.

---

Tu peux même l'inclure dans une expression "booléenne" ou dans une boucle :

Code:

---

1 2 3 4 5 6 7 8 9 10

foreach my $file ($file_list =~ /file=(\w+);/g) { # ... } if (my ($file, $title) = $header =~ /file=(\w+);.*title=(\w+);/) { # ... } if (my @files = $file_list =~ /file=(\w+);/g) { # ... }

---

Certes, les affectations dans les conditions de if sont rarement recommandées dans les règles de codage, mais en ici, cela permet d'être à la fois concis tout en restant clair est peu ambiguë par rapport à un test ==.