verifier l'exitence d'une methode de classe ou d'un attribut de classe

**vidici** · 04/10/2014, 12h09

Bonjour,

je cherche à vérifier l'existence d'une methode ou d'un attribut dans une classe moose (mais ce n'est pas spécifique à moose ) avant de lui faire appel

j'ai essayé defined mais mais on me répond :Useless use of defined operator in void context
si vous avez une idée sur la manière de s'y prendre ..

**Lolo78** · 04/10/2014, 18h07

Bonjour,

je ne sais pas si ça marche avec Moose, mais la méthode UNIVERSAL::can permet en principe ce genre de vérification:

Code :

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

1
2
3
4
5
if ($objet->can($nom_methode)) {
    $objet->$nom_methode(@args);
} else {
    # ...
}

Attention, cependant, la méthode can peut rapporter un résultat erroné (enfin erroné, je ne sais pas, c'est discutable, mais, disons, un peu inattendu) si AUTOLOAD est activé.

Également veiller à n'utiliser can que sur des objets, pas sur des variables non objets, sinon le programme mourra (à moins de faire le test dans un bloc eval). Dans le doute, quelque chose de ce genre (non testé):

Code :

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

1
2
3
4
5
if (eval {$objet->can($nom_methode)}) {
    $objet->$nom_methode(@args);
} else {
    # ...
}

**vidici** · 04/10/2014, 19h15

je te remercie pour ta réponse, et je regarderais ce module avec attention. Finalement j'ai décidé de mettre dans la classe une fonction qui fait le boulot.
je met une copie du code simplifié , l'original me donne entière satisfaction.
tu pourras remarquer, si tu prends le temps de regarder un peu qu'a un moment je fait un eq dans une boucle, plutôt qu'un grep sur un tableau.
c'est tout simplement par ce que j'y arrive pas ... toujours ce problèmes de références.

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package Decode;
#moosebis/Decode.pm
use Moose;
 
 
##############################################################
has 'tab_fonction' => (
isa     => 'ArrayRef',
is  => 'ro',
#lazy    => 1,
#default => 'inconnu'
default => sub { my $self = shift; return ['nom', 'untruc', 'deuxtruc', 'troistruc', 'quatruc']; }
);
##############################################################
has 'untruc' => (
isa     => 'Str',
is  => 'rw',
lazy    => 1,
default => '0'
);
##############################################################
has 'nom' => (
isa     => 'Str',
is  => 'rw',
lazy    => 1,
default => '0'
);
##############################################################
has 'deuxtruc' => (
isa     => 'Str',
is  => 'rw',
lazy    => 1,
default => '0'
);
##############################################################
has 'troistruc' => (
isa     => 'Str',
is  => 'rw',
lazy    => 1,
default => '0'
);
##############################################################
has 'quatruc' => (
isa     => 'Str',
is  => 'rw',
lazy    => 1,
default => '0'
);
##############################################################
has 'strcode' => (
isa     => 'Str',
is  => 'ro',
);
##############################################################
sub affiche_at {
	my $self = shift;
	my @tab  = $self->tab_fonction; 
my $longtab = @{$tab[0]};
my $retour = 0;
for (my $var = 0; $var < $longtab; $var++) {
 
	print ${tab}[0][$var]."\n";
 
}
return $retour;
}
##############################################################
sub present {
	my $self = shift;
	my $code = shift;
	my @tab  = $self->tab_fonction; 
my $longtab = @{$tab[0]};
my $retour = 0;
for (my $var = 0; $var < $longtab; $var++) {
 
	if ( ($code eq ${tab}[0][$var]) ) {$retour = 1; last}
 
}
return $retour;
}
##############################################################
##############################################################
sub decode {
	my $self = shift;
	my $code = shift;
	my $str  = $self->strcode; 
	my $search = '\['."$code".'\%(.+?)\]';
	if ($str =~ m/$search/) {
		$self->$code($1);
	}
 
}
##############################################################
no Moose;
__PACKAGE__->meta->make_immutable;

et pour l'utiliser en test

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
#!/usr/bin/perl5.16
#decode.pl;
use strict;    # quote strings, declare variables
use warnings;  # on by default
use warnings  qw(FATAL utf8);    # fatalize encoding glitches
use open      qw(:std :utf8);    # undeclared streams in UTF-8
use feature qw(say);
use autodie;
#use Text::Unidecode qw(unidecode);
use Decode;
 
my $para = $ARGV[0];
chomp $para;
 
my $str = '[nom%chose][untruc%unevaleur][deuxtruc%une autre valeur][troistruc%][quatruc%055000][cinqtruc%une adresse]';
#on initie la classe en lui passant la chaine a décoder.
my $classe = Decode_course->new( strcode => $str);
my $nomfonction = "$para";
#on verifie si l'attribut et donc la fonction existe;
my $verif = $classe->present($nomfonction);
if ($verif) {
 
	$classe->decode($nomfonction);
	my $result = $classe->$nomfonction;
	say $result;
 
}else{
 
say "je peut pas";
}
#on affiche tous les attributs
$classe->affiche_at;
 
exit 0

**Lolo78** · 04/10/2014, 20h07

Euh, UNIVERSAL n'est pas vraiment un module (en fait c'en est un, mais, bon..., il est un peu à part), c'est surtout une classe dont héritent toutes les autres classes. A priori, tu n'as pas besoin de charger quoi que ce soit pour l'utiliser, il fonctionne sur toute référence "bénite" (blessed). A voir si ça marche avec Moose (je penserais que c'est plausible, mais je ne sais pas).

Je suppose que tu parles de cette boucle:

Code :

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

1
2
3
4
5
for (my $var = 0; $var < $longtab; $var++) {
	if ( ($code eq ${tab}[0][$var]) ) {$retour = 1; last}
}
return $retour;
}

Déjà, je la réécrirais comme suit:

Code :

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

1
2
3
4
 
for my $var (0 .. $longtab - 1) {
	 return 1 if $code eq ${tab}[0][$var];
}

Sinon, pour utiliser grep, essaie quelque chose comme ça (programme tapé directement à la ligne de commande du shell):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
$ perl -MData::Dumper -e '
my @tab;
$tab[0][$_] = $_*2 for (1..10);
$tab[1][$_] = $_*2 for (0..10);
print Dumper \@tab;
my $success = grep { $tab[0][$_] == 10 } 1..10;
print "Avec 10: success = $success \n";
$success = grep { $tab[0][$_] == 11 } 1..10;
print "Avec 11: sucess = $success\n";
'

Ce qui affiche:

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
$VAR1 = [
          [
            undef,
            2,
            4,
            6,
            8,
            10,
            12,
            14,
            16,
            18,
            20
          ],
          [
            0,
            2,
            4,
            6,
            8,
            10,
            12,
            14,
            16,
            18,
            20
          ]
        ];
Avec 10: success = 1
Avec 11: sucess = 0

J'espère que ça répond à tes interrogations.

**vidici** · 04/10/2014, 20h26

Envoyé par Lolo78

Déjà, je la réécrirais comme suit:

Code :

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

1
2
3
4
 
for my $var (0 .. $longtab - 1) {
	 return 1 if $code eq ${tab}[0][$var];
}

c'est sur que ça change de style

Sinon, pour utiliser grep, essaie quelque chose comme ça (programme tapé directement à la ligne de commande du shell):

Code :

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

1
2
3
4
5
 
 
$success = grep { $tab[0][$_] == 11 } 1..10;
 
'

oui mais si je comprend bien, le grep est appliqué à une valeur, alors que je pensais que le grep pouvait être appliqué à un tableau
Je cherchais à faire quelque chose de ce genre "if (grep(/$f/, @fruits) {print 'fruit connu';}"

J'espère que ça répond à tes interrogations.

Oui, merci beaucoup

**Lolo78** · 04/10/2014, 21h00

oui mais si je comprend bien, le grep est appliqué à une valeur, alors que je pensais que le grep pouvait être appliqué à un tableau
Je cherchais à faire quelque chose de ce genre "if (grep(/$f/, @fruits) {print 'fruit connu';}"

Non, quand j'écris:

Code :

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

1
2
 
$success = grep { $tab[0][$_] == 10 } 1..10;

le grep s'applique successivement à toutes les valeurs de $tab[0][x] avec x compris entre 1 et 10.

Comme $tab[0] est une référence vers un tableau contenant les nombres pairs entre 1 et 20, le grep retourne une liste de valeurs contenant un seul élément, celui égal à 10. Mais cette liste est évaluée en contexte scalaire du fait de son affectation à la variable scalaire $success, ce qui fait que l'on obtient le nombre d'éléments satisfaisant la condition du bloc du grep, en l'occurrence 1.

Si je modifie mon programme comme suit:

Code :

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

1
2
3
4
5
6
7
$ perl -e '
my @tab;
$tab[0][$_] = $_*2 for (1..10);
$tab[1][$_] = $_*2 for (0..10);
print grep { $tab[0][$_] == 10 } 1..10;
'
5

il affiche l'indice de la la valeur du tableau d'origine pour laquelle la condition du bloc grep est vraie (à savoir 5).

Mais grep renvoie habituellement une liste. Si je cherche tous les nombres pairs, je vais obtenir tous les indices du tableau, puisqu'il est construit en multipliant par 2 les nombres entre 1 et 10:

Code :

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

1
2
3
4
5
6
7
$ perl -e '
my @tab;
$tab[0][$_] = $_*2 for (1..10);
$tab[1][$_] = $_*2 for (0..10);
print join " ", grep { $tab[0][$_] %2 == 0 } 1..10;
'
1 2 3 4 5 6 7 8 9 10

Je te conseille de lire la première partie de mon tutoriel sur la programmation fonctionnelle en Perl, il est dédié justement aux opérateurs de liste comme grep, map, for, foreach et sort (voir ma ligne de signature).

**vidici** · 04/10/2014, 21h19

Envoyé par Lolo78

Non, quand j'écris:

Code :

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

1
2
 
$success = grep { $tab[0][$_] == 10 } 1..10;

le grep s'applique successivement à toutes les valeurs de $tab[0][x] avec x compris entre 1 et 10.

oui d'accord mais sans vouloir insister lourdement, successivement à une valeur et ce que tu fais est en fait une boucle, écrite autrement, mais une boucle .

Comme $tab[0] est une référence vers un tableau contenant les nombres pairs entre 1 et 20, le grep retourne une liste de valeurs contenant un seul élément, celui égal à 10. Mais cette liste est évaluée en contexte scalaire du fait de son affectation à la variable scalaire $success, ce qui fait que l'on obtient le nombre d'éléments satisfaisant la condition du bloc du grep, en l'occurrence 1.

là, il va falloir que je cogite une peu ...

Je te conseille de lire la première partie de mon tutoriel sur la programmation fonctionnelle en Perl, il est dédié justement aux opérateurs de liste comme grep, map, for, foreach et sort (voir ma ligne de signature).

j'en ai déja fait une première lecture. Non pas que j'ai pour l'instant assimilé grand chose, mais juste subjugué par le potentiel qu'y s'en dégage.
Je m'étonne pourtant , comme ça, que lorsque tu parles des "pipelines" tu n'évoques à aucun moment les similitudes avec le bash, que j'ai pourtant trouvé criant.

**Lolo78** · 04/10/2014, 23h13

Code :

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

1
2
 
oui d'accord mais sans vouloir insister lourdement, successivement à une valeur et ce que tu fais est en fait une boucle, écrite autrement, mais une boucle .

Oui, absolument, c'est une boucle, rien d'autre, avec juste une syntaxe particulière donnant des moyens expressifs nouveaux. Avec un grep ou un map, tu itères implicitement sur chaque valeur du tableau (ou de la liste) reçu(e) en paramètre et renvoies un autre tableau obéissant aux règles définies dans le bloc de code du map ou du grep.

Je dirais même que la syntaxe:

Code :

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

1
2
3
4
 
for my $var (0 .. $longtab - 1) {
	 return 1 if $code eq ${tab}[0][$var];
}

est plus souvent efficace que la syntaxe équivalente avec un grep s'il s'agit de trouver si au moins un seul élément satisfait la condition parce que la boucle for peut s'arrêter dès qu'elle a trouvé une correspondance, alors qu'une "boucle" grep doit visiter la totalité des données. Cela fait une différence si la liste en paramètre est très longue (de très nombreux éléments) et si une reconnaissance est obtenue rapidement. Mais dans un usage courant, le grep et le map offrent une grande expressivité qui contrebalance au moins en partie l'efficacité de la boucle for s'arrêtant dès qu'elle a trouvé une reconnaissance.

Bref, tout dépend de ce que l'on veut obtenir. J'aime enchaîner des grep, des map, des join, des for, des print, des sort, des split, etc. dans un pipeline parce que je peux arriver à faire un truc super-efficace (du point de vue du codage) en une seule ligne de code. Mais ce n'est pas toujours la meilleure solution du point de vue performance. Il faut rester vigilant sur cet aspect.

**vidici** · 05/10/2014, 08h49

je vais relire la partie 1 de tes articles sur la programmation fonctionnelle sous un autre angle et certainement en tirer un meilleur profit.
je te remercie pour tes réponses.

**Philou67430** · 06/10/2014, 09h53

Envoyé par Lolo78

Je dirais même que la syntaxe:

Code :

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

1
2
3
4
 
for my $var (0 .. $longtab - 1) {
	 return 1 if $code eq ${tab}[0][$var];
}

est plus souvent efficace que la syntaxe équivalente avec un grep s'il s'agit de trouver si au moins un seul élément satisfait la condition parce que la boucle for peut s'arrêter dès qu'elle a trouvé une correspondance, alors qu'une "boucle" grep doit visiter la totalité des données. Cela fait une différence si la liste en paramètre est très longue (de très nombreux éléments) et si une reconnaissance est obtenue rapidement. Mais dans un usage courant, le grep et le map offrent une grande expressivité qui contrebalance au moins en partie l'efficacité de la boucle for s'arrêtant dès qu'elle a trouvé une reconnaissance.

Pour compléter, un foreach est généralement aussi moins efficace qu'un while dans ce contexte, car il mène toujours à la production (en interne) de tous les éléments listés (ici, la liste 0 .. $longtab-1, soit $longtab éléments) même si le bloc de boucle ne s'exécute pas sur tous les éléments, là où un while/return ne consommera pas ces ressources. Dans le cas présent, la construction d'une simple liste ne présente peut-être pas de problème, mais lorsqu'il s'agit d'un pipeline avec de lourds traitements, il faudra reconsidérer la chose.

Sinon, j'aime aussi utiliser(abuser) des pipelines mêlant grep, sort et map

(avec rarement des contraintes de ressources, il est vrai).

**vidici** · 06/10/2014, 20h13

juste histoire de jeter une pierre dans une eau calme, et parce que je suis un peu fâché avec perl aujourd'hui.. Je trouves que bash du point de vue des enchainements des commandes est très bien.
par exemple j'ai pas trouvé mieux que ceci en perl.

Code :

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

system "LC_CTYPE=C sed '/^'_dn__idcc_02_12_03_'/d' /Users/mac/commentaires.txt > tmp && mv -f tmp /Users/mac/commentaires.txt";

**Lolo78** · 06/10/2014, 20h58

Bah, je n'utilise pas bash pour programmer, mais plutôt sh ou ksh, mais ça ne me dérange pas d'utiliser le shell quand il est efficace (mais j'utilise bash pour mes commandes manuelles au terminal, c'est nettement plus ergonomique). Il faut reconnaître que Unix est un système extraordinairement bien conçu, même s'il est fait plutôt pour des informaticiens que pour des utilisateurs lambda.

Cela dit, j'ai commencé tcl, puis Python et enfin Perl à cause des irritations et exaspérations que me suscitait le shell. Aujourd'hui, je fais le moins possible en shell et le plus possible en Perl, même si le lanceur de mon programme est souvent un ksh, ne serait-ce que pour définir des variables d'environnement, trier un très gros fichier en entrée ou copier des fichiers avant de commencer. Et mes shells contiennent souvent du code Perl ou éventuellement awk (voire sed) "inline"; en revanche, il est exceptionnel que je lance des commandes shell depuis Perl avec la commande system ou des backticks, je n'en ressens presque jamais le besoin (sauf s'il s'agit de lancer certains programmes très particuliers devant être lancés depuis le shell, comme un ETL, par exemple).

En bref, il n'y a aucune raison d'opposer bash et Perl, utilisons chacun de ces outils pour ce pour quoi ils sont meilleurs.

**vidici** · 06/10/2014, 22h20

Envoyé par Lolo78

En bref, il n'y a aucune raison d'opposer bash et Perl, utilisons chacun de ces outils pour ce pour quoi ils sont meilleurs.

c'est bien ma façon de faire aussi. Je suis venu à Perl car j'ai eu des problèmes d'Unicode en branchant des script php.cli sur le bash. Ensuite j'ai trouvé Perl Intéressant. Mais ce n'est quand j'ai trouvé Moose que j'ai été vraiment convaincu d'insister avec ce langage qui me parai(ssai)t un peu ésotérique.
C'est sympa de partager ton expérience car comme j'apprends tout seul dans mon coin et en plus lors de courte périodes, je ne connais pas les manières habituelles de procéder.
Bonne soirée.
ps : je n'ai pas encore testé la méthode can de Universal, mais j'ai lu un passage à ce sujet dans le livre Perl écrit par Larry Wall.. une bible je suppose.

**Philou67430** · 07/10/2014, 09h02

Envoyé par vidici

une bible je suppose.

The Camel book !

Sinon, ceci

Code :

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

system "LC_CTYPE=C sed '/^'_dn__idcc_02_12_03_'/d' /Users/mac/commentaires.txt > tmp && mv -f tmp /Users/mac/commentaires.txt";

n'est-il pas équivalent à cela :

Code :

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

perl -pi.bak -MPOSIX=setlocale,LC_CTYPE -E 'use locale; BEGIN { setlocale(LC_CTYPE, "C"); } next if /^_dn__idcc_02_12_03_/' /Users/mac/commentaires.txt

Si l'on avait pas besoin de définir la locale, ça se résumerait à :

Code :

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

perl -pi.bak -E 'next if /^_dn__idcc_02_12_03_/' /Users/mac/commentaires.txt

Je suppose qu'on doit aussi pouvoir écrire, avec prise en compte de la locale :

Code :

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

LC_CTYPE=C perl -pi.bak -Mlocale -E 'next if /^_dn__idcc_02_12_03_/' /Users/mac/commentaires.txt

**vidici** · 07/10/2014, 10h47

Envoyé par Philou67430

Je suppose qu'on doit aussi pouvoir écrire, avec prise en compte de la locale :

Code :

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

LC_CTYPE=C perl -pi.bak -Mlocale -E 'next if /^_dn__idcc_02_12_03_/' /Users/mac/commentaires.txt

et avec cette ligne là, j'aurais supprimé une ligne d'un fichier et réenregistré le dit fichier ?

**Philou67430** · 07/10/2014, 11h48

Tout dépend combien de lignes satisfont le motif /^_dn__idcc_02_12_03_/

Sinon, ton fichier commentaires.txt est d'abord sauvé en commentaires.bak puis ré-écrit sauf pour les lignes contenant le motif du if.

**vidici** · 07/10/2014, 13h08

ben j'y arrive pas.
Voilà par exemple une phrase qui fonctionne dans un script pl

Code :

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

system "LC_CTYPE=C sed '/^'_dn__idcc_'.*'_idcc_'.'_dn_'/d' /Users/mac/commentaires.txt > tmp && mv -f tmp /Users/mac/commentaires.txt";

j'ai essayé ton code en différentes manières, par exemple comme ça (mais plein d'autres)

Code :

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

system "LC_CTYPE=C perl -pi.bak -Mlocale -E 'next if /^'_dn__idcc_'.+?'_idcc_'.'_dn_'/' '/Users/mac/commentaires.txt'";

j'ai pas d'erreur, mais ça ne fonctionne pas.
Mais peut être que j'ai rien compris ?

**Philou67430** · 07/10/2014, 14h08

1- je ne vois pas l'intérêt d'utiliser la fonction perl "system" pour appeler l'interpréteur perl ...
2- si tu souhaites utiliser des guillemets dans une chaine littérale, il est préférable d'utiliser les opérateurs q() et qq() (q = quote simple, qq = quote double donc avec interpolation de variable).

1- dans le code perl principal, ajouter :
use locale;
use POSIX qw(setlocale LC_CTYPE);

setlocale(LC_CTYPE, "C");
...
my $f = "/Users/mac/commentaires.txt";
open my $F, "<", $f or die "Can't open $f for reading: $!";
open my $F_greped, ">", "$f.tmp" or die "Can't open $f.tmp for writting: $!";
print { $F_greped } grep !/^_dn__idcc_02_12_03_/, <$F>;
close $F;
close $F_greped;

2- l'utilisation de q() semble le plus approprié puisqu'il n'y a aucune interpolation de variable :

Code :

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

system q(LC_CTYPE=C perl -pi.bak -Mlocale -E 'next if /^_dn__idcc_.+?_idcc_._dn_/' /Users/mac/commentaires.txt);

Mais attention, l'usage des guillemets ' ou " pour le code "en ligne" de perl (option -E ou -e) dépend du système d'exploitation et de l'implémentation de perl : sous Unix ou Windows/cygwin, le code doit être inséré dans des guillemets simples, sous Windows avec Strawberry perl ou ActivePerl, ce sont des guillemets doubles.

Par ailleurs, j'ai un doute : quel est le motif (regexp) des lignes que tu souhaites supprimer (en dehors de toute considération sur les guillemets : simplement le motif tel que tu l'écrirais dans un test perl du style if (/.../) )

**vidici** · 07/10/2014, 14h31

Envoyé par Philou67430

...
my $f = "/Users/mac/commentaires.txt";
open my $F, "<", $f or die "Can't open $f for reading: $!";
open my $F_greped, ">", "$f.tmp" or die "Can't open $f.tmp for writting: $!";
print { $F_greped } grep !/^_dn__idcc_02_12_03_/, <$F>;
close $F;
close $F_greped;

merci pour ta patiente, mais
j'ai bien un fichier temporaire qui est tout bon qui se crée, mais ... , le fichier original reste intact. Ce doit être un détail mais je trouve pas.