Discussion :

[Lolo78]

C'est un point délicat et qui me semble-t-il demande beaucoup de tact quand on le généralise. Je crois avoir passé un seuil en Perl à partir du moment ou j'ai commencé à minimiser mon utilisation de variables nommées au profit de $_ et d'une lecture correcte des indexations et tranchages.

Personnellement, j'ai commencé à utiliser $_ dès que j'ai appris le Perl il y a plus de 10 ans (le tuto avec lequel j'ai commencé le faisait, cela ne me posait pas de problème) et je continue à le faire très largement, je trouve cela très pratique. Mais je trouve aussi que les arguments de Philou sont loin de manquer de pertinence, et j'hésite assez souvent entre les deux solutions. Souvent, par exemple quand je lis un fichier, j'utilise souvent $_ dans un premier temps, parce qu'il me permet de réaliser facilement toute une série d'actions "techniques" (chomp, s///g, m//, lc, uc, length, split, etc.), puis je passe à une variable nommée quand je rentre dans la complexité fonctionnelle ou algorithmique. Je ne dis pas que ma solution est la bonne, mais juste que je suis plus à l'aise avec des variables nommées quand le fonctionnel ou l'algo deviennent compliqués. Même chose avec @_, $1, $2, etc., et un certain nombre d'autres variables de ponctuation, mais, franchement, quand je trouve du code utilisant des variables comme $(, $^p ou $^F, je suis obligé d'ouvrir la doc pour savoir ce qu'elles signifient. Dans ce cas, je préfère souvent leur donner un nom intelligible avant de les utiliser (ou éventuellement utiliser le module English).

... Mais ce n'est pas facile de positionner correctement le curseur...

Alors, là, je suis bien d'accord. C'est toute la difficulté.

... je crois qu'il est possible d'écrire du code qui soit à la fois concis et intelligible.

C'est aussi mon avis, mais nous ne plaçons peut-être pas le curseur au même endroit...

Le problème est que celui qui lit ce code doit, pour être en mesure d'intervenir utilement dessus, avoir un minimum de connaissances des capacités de Perl, et donc un minimum de formation. Il sait probablement écrire du C ou équivalent, et donc la formation qu'il doit recevoir doit porter à mon avis dès le départ sur ce qui fait la magie (et la difficulté) de Perl quand on le maîtrise (resp. quand on ne le maîtrise pas...). D'où mes efforts en ce sens, que tu semble considérer mal placés

Non, non, pas mal placés, si tu as compris cela, je me suis sans doute mal exprimé. Il faut juste faire attention à qui on s'adresse. Sur un forum, par exemple, utiliser des concepts trop avancés face à un débutant risque de le faire fuir. Ou, dans ma boîte, quand j'utilise des concepts Perl relativement avancés, j'estime devoir au moins ne pas les compliquer avec des constructions syntaxiques plus ou moins mystérieuses ou magiques (même si elles peuvent être bien pratiques). Par exemple, si je décide de créer une fonction fabriquant dynamiquement d'autres fonctions parce que c'est vraiment utile pour mon programme, j'introduis un certain degré de complexité pour celui qui n'est pas habitué à ce genre de construction, je vais au moins essayer de simplifier l'environnement syntaxique pour éviter d'ajouter de la difficulté de compréhension. Mais là encore, toute la difficulté est de positionner le curseur.

[cmcmc]

@Lolo78, @Philou67430,

Nos derniers échanges dans cette discussion dérivant sur des problèmes de style, je me suis permis d'y répondre dans un nouveau fil afin de ne pas parasiter outre mesure celui-ci. Au plaisir de vous y voir

[JUSTIN Loïc]

Bonjour @cmcmc,@lolo78 et Philou67430
Je m'excuse de revenir vers vous 3 car là pour être franc suite à vos différents messages je suis complétement à la ramasse. Si quelqu'un pouvait m’éclaircir sur le sujet, j'en serais ravi ..;

[Philou67430]

Concernant le style de programmation, je t'invite à suivre le lien vers la discussion créée par cmcmc.

Si tu as en revanche des questions concernant ton problème initial, tu peux naturellement demander des précisions dans ce fil

[cmcmc]

@Justin LOÏC

pas de panique on va reprendre là où on en était (désolé pour les perturbations)

Je te demandais par exemple d'expliciter la ligne de code suivante

Code :

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

        print fic1_out +(join ';', map { @$_ } @h{@wanted}), "\n";

Avec les explications fournies là et là par Lolo78, et là par moi même, tu devrais pouvoir décoder @h{@wanted}. De quoi s'agit-il ?

Ensuite, pourquoi a-t-on besoin du map { @$_ } ? Qu'est-ce qui se passe si on l'enlève ? Que signifie @$_ (indice: on aurait pu l'écrire également @{$_}) ?

(incidemment, ce programme et les explications associées sont un peu plus avancés que ceux de l'autre discussion que nous avons en cours, aussi si tu préfères n'hésite pas à continuer sur l'autre et revenir plus tard sur celle ci)

[JUSTIN Loïc]

Je te demandais par exemple d'expliciter la ligne de code suivante

Code :

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

        print fic1_out +(join ';', map { @$_ } @h{@wanted}), "\n";

Concernant @h cela correspond à un tableau constitué des éléments du hachage dont les clefs sont dans le tableau @wanted à la place de @wanted on aurait put mettre qw(CLASS SCHED SCHEDPOOL INCLUDE)
Le + permet comme tu l'expliquais dans un précedent message, je te cite

le '+' sert à éviter que la ligne ci-dessus ne soit interprétée comme représentant deux expression séparées par une ',' : un appel fonctionnel à print, et la constante "\n":

Pour ce qui suis j'ai encore du mal

Ensuite, pourquoi a-t-on besoin du map { @$_ } ? Qu'est-ce qui se passe si on l'enlève ? Que signifie @$_ (indice: on aurait pu l'écrire également @{$_}) ?

(incidemment, ce programme et les explications associées sont un peu plus avancés que ceux de l'autre discussion que nous avons en cours, aussi si tu préfères n'hésite pas à continuer sur l'autre et revenir plus tard sur celle ci)

[Philou67430]

Oui, @$_ s'écrit aussi @{$_} et signifie : dé-référencer $_ en tableau.
On récupère donc une liste des éléments contenus dans chaque élément @g{wanted} (chaque élément devant être une référence vers un tableau).

J'espère avoir été clair.

[JUSTIN Loïc]

Si je décompose le traitement, si je met en mode trace de @h{@wanted}
j'ai ce type de resultat

$VAR1 = [
'SCH-01n-APPLI-R4'
];
$VAR2 = [
'VVP-TV03-R4'
];
$VAR3 = [
'CL-01n-APPLI'
];
$VAR1 = [
'SCH-01n-APPLI-R3'
];
$VAR2 = [
'VVP-TV03-R3'
];
$VAR3 = [
'CL-01n-APPLI'
];

Par contre, si je met en mode trace

Code :

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

map { @$_ } @h{@wanted}

, j'obtiens cela

$VAR1 = 'SCH-01n-APPLI-R4';
$VAR2 = 'VVP-TV03-R4';
$VAR3 = 'CL-01n-APPLI';
$VAR1 = 'SCH-01n-APPLI-R3';
$VAR2 = 'VVP-TV03-R3';
$VAR3 = 'CL-01n-APPLI';

le fichier de départ etant ceci

CLASS CL-01n-APPLI *NULL* 0 701000 0 *NULL*
NAMES
INFO 0 0 0 0 *NULL* 0 0 2147483647 1 0 0 0 0 0 0 0 0 0 1108637276 61E138FC1DD211B2ACD700E000C490F5 1 0 0 0 0 0 0 0 2 0 0 0 0 0 0 3 16
KEY 01N
BCMD *NULL*
RCMD *NULL*
RES STUG-TV03-10.64 *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL*
POOL VVP-TV03-R4 NetBackup NetBackup NetBackup NetBackup NetBackup NetBackup NetBackup NetBackup NetBackup
FOE 0 0 0 0 0 0 0 0 0 0
SHAREGROUP *ANY*
DATACLASSIFICATION *NULL*
CLIENT dr01nas2-s2 Linux RedHat2.4 0 0 0 0 *NULL*
SCHED SCH-01n-APPLI-R4 2 3 604800 4 0 0 0 *NULL* 0 0 0 0 0 0 -1 0
SCHEDWIN 0 604800 0 0 0 0 0 0 0 0 0 0 0 0
SCHEDRES *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL*
SCHEDPOOL *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL*
SCHEDRL 4 1 1 1 1 1 1 1 1 1
SCHEDFOE 0 0 0 0 0 0 0 0 0 0
SCHEDSG *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL*
SCHED SCH-01n-APPLI-R3 2 3 604800 3 0 0 0 *NULL* 0 0 0 0 0 0 -1 0
SCHEDWIN 0 604800 0 0 0 0 0 0 0 0 0 0 0 0
SCHEDRES *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL*
SCHEDPOOL VVP-TV03-R3 *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL*
SCHEDRL 3 1 1 1 1 1 1 1 1 1
SCHEDFOE 0 0 0 0 0 0 0 0 0 0
SCHEDSG *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL* *NULL*

cela donnera à la fin ce resultat

SCH-01n-APPLI-R4 VVP-TV03-R4 CL-01n-APPLI
SCH-01n-APPLI-R3 VVP-TV03-R3 CL-01n-APPLI

Le fait d'avoir voulu décomposé est-ce la bonne méthode pour appréhender ce type de syntaxe.

[Philou67430]

je ne comprends pas ta question, et notamment à quoi se réfère "la décomposition" dont tu parles ?!

Lorsque tu travailles directement avec @h{wanted} to dispose d'un tableau de tableau, c'est à dire que pour chaque élément de @h{wanted}, tu disposes d'une référence vers un tableau contenant un ou plusieurs scalaires (dans ton cas visiblement, il n'y a à chaque fois qu'un élément).
En travaillant directement avec ce tableau, tu peux donc identifier à quel indice du tableau @h{wanted} chaque élément appartient (dans ton exemple, l'élément 'CL-01n-APPLI' se trouve à l'indice 2 du tableau @h{wanted}).

Lorsque tu travailles avec map @$_, @h{wanted}, tu récupères un simple tableau, à plat, de tous les sous-tableaux. Bien sûr, dans ton cas de figure ou les sous-tableaux contiennent tous un seul élément, l'indice de 'CL-01n-APPLI' sera la même dans @h{wanted} que dans map @$_, @h{wanted}. Mais si l'on imaginait que (@h{wanted})[0] contienne 2 élements, son indice serait alors supérieur.

@h{wanted} = (['SCH-01n-APPLI-R4'], ['VVP-TV03-R4'], ['CL-01n-APPLI'], ['SCH-01n-APPLI-R3'], ['VVP-TV03-R3'], ['CL-01n-APPLI']);
alors que
map @$_, @h{wanted} = ('SCH-01n-APPLI-R4', 'VVP-TV03-R4', 'CL-01n-APPLI', 'SCH-01n-APPLI-R3', 'VVP-TV03-R3', 'CL-01n-APPLI')

Mais je ne suis pas sûr d'avoir répondu à ton interrogation.

[JUSTIN Loïc]

@philou67430. merci pour tes explications que je pense avoir compris.
Sinon, quand je parle "décomposition" c'est décomposition de la ligne

Code :

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

print fic1_out +(join ';', map { @$_ } @h{@wanted}), "\n";

pour arriver à mieux cerner ou appréhender ce quelle fait.
C'est d'ailleurs pour cela que je demandais si c’était la bonne méthode.

[Philou67430]

Cette "décomposition" (je parlerais plutôt d'un pipeline d'opérations) est correcte.