Voilà, c'est une réflexion à deux balles : J'ai un programme avec
de nombreuses fonctions, qui elles-même prennent de nombreux paramètres.
Cependant beaucoup de ces paramètres sont toujours les mêmes.
Pour éviter de passer ces paramètres systématiquement et d'alourdir mes
appels de fonctions, je mets ces données dans des variables globales...
C'est pas propre et puis ça ne fonctionnera pas si je mets mes
fonctions dans des modules ... Comment faire autrement? Peut-être est-il
possible de passer des paramètres de façon implicite?
Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales...
Moi j'aime bien Class::Singleton pour ce genre de choses.
-- Patrick Mevzek . . . . . . Dot and Co (Paris, France) <http://www.dotandco.net/> <http://www.dotandco.com/>
Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour
éviter de passer ces paramètres systématiquement et d'alourdir mes
appels de fonctions, je mets ces données dans des variables globales...
Moi j'aime bien Class::Singleton pour ce genre de choses.
--
Patrick Mevzek . . . . . . Dot and Co (Paris, France)
<http://www.dotandco.net/> <http://www.dotandco.com/>
Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales...
Moi j'aime bien Class::Singleton pour ce genre de choses.
-- Patrick Mevzek . . . . . . Dot and Co (Paris, France) <http://www.dotandco.net/> <http://www.dotandco.com/>
GERBIER Eric
Emmanuel Florac wrote:
Voilà, c'est une réflexion à deux balles : J'ai un programme avec de nombreuses fonctions, qui elles-même prennent de nombreux paramètres. Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales... C'est pas propre et puis ça ne fonctionnera pas si je mets mes fonctions dans des modules ... Comment faire autrement? Peut-être est-il possible de passer des paramètres de façon implicite?
et avec une approche "objet" ?
tu passes un seul objet en parametre, qui encapsule toutes tes donnees communes ?
Emmanuel Florac wrote:
Voilà, c'est une réflexion à deux balles : J'ai un programme avec
de nombreuses fonctions, qui elles-même prennent de nombreux paramètres.
Cependant beaucoup de ces paramètres sont toujours les mêmes.
Pour éviter de passer ces paramètres systématiquement et d'alourdir mes
appels de fonctions, je mets ces données dans des variables globales...
C'est pas propre et puis ça ne fonctionnera pas si je mets mes
fonctions dans des modules ... Comment faire autrement? Peut-être est-il
possible de passer des paramètres de façon implicite?
et avec une approche "objet" ?
tu passes un seul objet en parametre, qui encapsule toutes tes donnees communes ?
Voilà, c'est une réflexion à deux balles : J'ai un programme avec de nombreuses fonctions, qui elles-même prennent de nombreux paramètres. Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales... C'est pas propre et puis ça ne fonctionnera pas si je mets mes fonctions dans des modules ... Comment faire autrement? Peut-être est-il possible de passer des paramètres de façon implicite?
et avec une approche "objet" ?
tu passes un seul objet en parametre, qui encapsule toutes tes donnees communes ?
Paul Gaborit
À (at) Mon, 18 Oct 2004 16:53:19 +0200, Emmanuel Florac écrivait (wrote):
Voilà, c'est une réflexion à deux balles : J'ai un programme avec de nombreuses fonctions, qui elles-même prennent de nombreux paramètres. Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales... C'est pas propre et puis ça ne fonctionnera pas si je mets mes fonctions dans des modules ... Comment faire autrement? Peut-être est-il possible de passer des paramètres de façon implicite?
Une méthode qui donne de bons résultats consiste à englober toutes ces variables dans une structure globale. Plutôt que $p1, $p2, $p3... on utilise $p qui est une référence vers une table de hachage contenant $p->{p1}, $p->{p2}, $p->{p3}... Un tableau serait plus efficace mais on perd alors la possibilité de nommer les paramètres.
Ainsi, l'appel de la fonction :
f($p1, $p2, $p3....);
devient :
f($p);
On n'utilise donc pas de variables globales ($p est toujours passé explicitement) mais on n'a qu'un seul paramètre. À charge de chaque fonction d'aller piocher les paramètres qui l'intéresse dans $p.
PS: en fait, c'est comme ça qu'on implémente les attributs des objets... sauf qu'on ajoute une étape supplémentaire de bénédiction de la référence $p pour aller plus loin en permettant la suppression du passage du dernier paramètre ($p).
-- Paul Gaborit - <http://www.enstimac.fr/~gaborit/> Perl en français - <http://www.enstimac.fr/Perl/>
À (at) Mon, 18 Oct 2004 16:53:19 +0200,
Emmanuel Florac <eflorac@imaginet.fr> écrivait (wrote):
Voilà, c'est une réflexion à deux balles : J'ai un programme avec
de nombreuses fonctions, qui elles-même prennent de nombreux paramètres.
Cependant beaucoup de ces paramètres sont toujours les mêmes.
Pour éviter de passer ces paramètres systématiquement et d'alourdir mes
appels de fonctions, je mets ces données dans des variables globales...
C'est pas propre et puis ça ne fonctionnera pas si je mets mes
fonctions dans des modules ... Comment faire autrement? Peut-être est-il
possible de passer des paramètres de façon implicite?
Une méthode qui donne de bons résultats consiste à englober toutes ces
variables dans une structure globale. Plutôt que $p1, $p2, $p3... on utilise
$p qui est une référence vers une table de hachage contenant $p->{p1},
$p->{p2}, $p->{p3}... Un tableau serait plus efficace mais on perd alors la
possibilité de nommer les paramètres.
Ainsi, l'appel de la fonction :
f($p1, $p2, $p3....);
devient :
f($p);
On n'utilise donc pas de variables globales ($p est toujours passé
explicitement) mais on n'a qu'un seul paramètre. À charge de chaque fonction
d'aller piocher les paramètres qui l'intéresse dans $p.
PS: en fait, c'est comme ça qu'on implémente les attributs des objets... sauf
qu'on ajoute une étape supplémentaire de bénédiction de la référence $p pour
aller plus loin en permettant la suppression du passage du dernier paramètre
($p).
--
Paul Gaborit - <http://www.enstimac.fr/~gaborit/>
Perl en français - <http://www.enstimac.fr/Perl/>
À (at) Mon, 18 Oct 2004 16:53:19 +0200, Emmanuel Florac écrivait (wrote):
Voilà, c'est une réflexion à deux balles : J'ai un programme avec de nombreuses fonctions, qui elles-même prennent de nombreux paramètres. Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales... C'est pas propre et puis ça ne fonctionnera pas si je mets mes fonctions dans des modules ... Comment faire autrement? Peut-être est-il possible de passer des paramètres de façon implicite?
Une méthode qui donne de bons résultats consiste à englober toutes ces variables dans une structure globale. Plutôt que $p1, $p2, $p3... on utilise $p qui est une référence vers une table de hachage contenant $p->{p1}, $p->{p2}, $p->{p3}... Un tableau serait plus efficace mais on perd alors la possibilité de nommer les paramètres.
Ainsi, l'appel de la fonction :
f($p1, $p2, $p3....);
devient :
f($p);
On n'utilise donc pas de variables globales ($p est toujours passé explicitement) mais on n'a qu'un seul paramètre. À charge de chaque fonction d'aller piocher les paramètres qui l'intéresse dans $p.
PS: en fait, c'est comme ça qu'on implémente les attributs des objets... sauf qu'on ajoute une étape supplémentaire de bénédiction de la référence $p pour aller plus loin en permettant la suppression du passage du dernier paramètre ($p).
-- Paul Gaborit - <http://www.enstimac.fr/~gaborit/> Perl en français - <http://www.enstimac.fr/Perl/>
Aurelien
Emmanuel Florac wrote:
Voilà, c'est une réflexion à deux balles : J'ai un programme avec de nombreuses fonctions, qui elles-même prennent de nombreux paramètres. Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales... C'est pas propre et puis ça ne fonctionnera pas si je mets mes fonctions dans des modules ... Comment faire autrement? Peut-être est-il possible de passer des paramètres de façon implicite?
J'utilise le hash comme vecteur de passage de paramètres, mais c'est vrai qu'il est souvent lourd de devoir toujours gérer tous un tas de paramètres qui sont présent à chaque fois. Une solution, qui n'est pas la plus propre, mais si on fait bien attention, et on documente, ca passe pas mal, c'est les variables du packages main, mais qui peuvent être redéfinies, ex:
__CODE__
# Variable globale my $bar = 'Oui';
# Appel classique foo({param1=>3, param2=>56}); # Appel avec redéfinition local du paramètre 'bar' foo({bar => 'Non', param1=>3, param2=>56});
sub foo { my $p = shift; # Recuperation du parametre my $bar = $p->{'bar'} || $main::bar; ...
}
__END__
Ainsi, si tu peux l'encapsuler dans des modules et quand même utiliser les variables globales. Ca permet quelque chose de sympa sans trop se compliquer la vie. Si tu as besoin de ne pas polluer l'espace de nommage du package main, que tu veux quelque chose de vraiment propre, il faut prendre une solution plus "lourde", comme celles proposées.
Aurélien
Emmanuel Florac wrote:
Voilà, c'est une réflexion à deux balles : J'ai un programme avec
de nombreuses fonctions, qui elles-même prennent de nombreux paramètres.
Cependant beaucoup de ces paramètres sont toujours les mêmes.
Pour éviter de passer ces paramètres systématiquement et d'alourdir mes
appels de fonctions, je mets ces données dans des variables globales...
C'est pas propre et puis ça ne fonctionnera pas si je mets mes
fonctions dans des modules ... Comment faire autrement? Peut-être est-il
possible de passer des paramètres de façon implicite?
J'utilise le hash comme vecteur de passage de paramètres, mais c'est
vrai qu'il est souvent lourd de devoir toujours gérer tous un tas de
paramètres qui sont présent à chaque fois.
Une solution, qui n'est pas la plus propre, mais si on fait bien
attention, et on documente, ca passe pas mal, c'est les variables du
packages main, mais qui peuvent être redéfinies, ex:
__CODE__
# Variable globale
my $bar = 'Oui';
# Appel classique
foo({param1=>3, param2=>56});
# Appel avec redéfinition local du paramètre 'bar'
foo({bar => 'Non', param1=>3, param2=>56});
sub foo {
my $p = shift;
# Recuperation du parametre
my $bar = $p->{'bar'} || $main::bar;
...
}
__END__
Ainsi, si tu peux l'encapsuler dans des modules et quand même utiliser
les variables globales. Ca permet quelque chose de sympa sans trop se
compliquer la vie.
Si tu as besoin de ne pas polluer l'espace de nommage du package main,
que tu veux quelque chose de vraiment propre, il faut prendre une
solution plus "lourde", comme celles proposées.
Voilà, c'est une réflexion à deux balles : J'ai un programme avec de nombreuses fonctions, qui elles-même prennent de nombreux paramètres. Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales... C'est pas propre et puis ça ne fonctionnera pas si je mets mes fonctions dans des modules ... Comment faire autrement? Peut-être est-il possible de passer des paramètres de façon implicite?
J'utilise le hash comme vecteur de passage de paramètres, mais c'est vrai qu'il est souvent lourd de devoir toujours gérer tous un tas de paramètres qui sont présent à chaque fois. Une solution, qui n'est pas la plus propre, mais si on fait bien attention, et on documente, ca passe pas mal, c'est les variables du packages main, mais qui peuvent être redéfinies, ex:
__CODE__
# Variable globale my $bar = 'Oui';
# Appel classique foo({param1=>3, param2=>56}); # Appel avec redéfinition local du paramètre 'bar' foo({bar => 'Non', param1=>3, param2=>56});
sub foo { my $p = shift; # Recuperation du parametre my $bar = $p->{'bar'} || $main::bar; ...
}
__END__
Ainsi, si tu peux l'encapsuler dans des modules et quand même utiliser les variables globales. Ca permet quelque chose de sympa sans trop se compliquer la vie. Si tu as besoin de ne pas polluer l'espace de nommage du package main, que tu veux quelque chose de vraiment propre, il faut prendre une solution plus "lourde", comme celles proposées.
Aurélien
Paul Gaborit
À (at) Mon, 18 Oct 2004 17:10:20 +0200, GERBIER Eric écrivait (wrote):
et avec une approche "objet" ?
tu passes un seul objet en parametre, qui encapsule toutes tes donnees communes ?
En fait, avec une approche objet, on puet ne plus passer de paramètre du tout. En fait, il y en a un qui est implicite : l'objet lui-même.
-- Paul Gaborit - <http://www.enstimac.fr/~gaborit/> Perl en français - <http://www.enstimac.fr/Perl/>
À (at) Mon, 18 Oct 2004 17:10:20 +0200,
GERBIER Eric <eric_nospam_gerbier@meteo.fr> écrivait (wrote):
et avec une approche "objet" ?
tu passes un seul objet en parametre, qui encapsule toutes tes donnees
communes ?
En fait, avec une approche objet, on puet ne plus passer de paramètre du
tout. En fait, il y en a un qui est implicite : l'objet lui-même.
--
Paul Gaborit - <http://www.enstimac.fr/~gaborit/>
Perl en français - <http://www.enstimac.fr/Perl/>
À (at) Mon, 18 Oct 2004 17:10:20 +0200, GERBIER Eric écrivait (wrote):
et avec une approche "objet" ?
tu passes un seul objet en parametre, qui encapsule toutes tes donnees communes ?
En fait, avec une approche objet, on puet ne plus passer de paramètre du tout. En fait, il y en a un qui est implicite : l'objet lui-même.
-- Paul Gaborit - <http://www.enstimac.fr/~gaborit/> Perl en français - <http://www.enstimac.fr/Perl/>
Emmanuel Florac
Le Mon, 18 Oct 2004 17:10:20 +0200, GERBIER Eric a écrit :
et avec une approche "objet" ?
tu passes un seul objet en parametre, qui encapsule toutes tes donnees communes ?
Excuse moi de la jouer "niais", mais je suis étanche à l'approche objet en règle générale (je dois être trop vieux). Tu peux me faire un exemple bidon pour expliciter?
-- A thing of beauty is a joy forever. J. Keats.
Ah! Singe débotté, hisse un jouet fort et vert! Marcel Bénabou.
Le Mon, 18 Oct 2004 17:10:20 +0200, GERBIER Eric a écrit :
et avec une approche "objet" ?
tu passes un seul objet en parametre, qui encapsule toutes tes donnees communes ?
Excuse moi de la jouer "niais", mais je suis étanche à l'approche objet
en règle générale (je dois être trop vieux). Tu peux me faire un
exemple bidon pour expliciter?
--
A thing of beauty is a joy forever.
J. Keats.
Ah! Singe débotté, hisse un jouet fort et vert!
Marcel Bénabou.
Le Mon, 18 Oct 2004 17:10:20 +0200, GERBIER Eric a écrit :
et avec une approche "objet" ?
tu passes un seul objet en parametre, qui encapsule toutes tes donnees communes ?
Excuse moi de la jouer "niais", mais je suis étanche à l'approche objet en règle générale (je dois être trop vieux). Tu peux me faire un exemple bidon pour expliciter?
-- A thing of beauty is a joy forever. J. Keats.
Ah! Singe débotté, hisse un jouet fort et vert! Marcel Bénabou.
Emmanuel Florac
Le Mon, 18 Oct 2004 17:14:03 +0200, Paul Gaborit a écrit :
On n'utilise donc pas de variables globales ($p est toujours passé explicitement) mais on n'a qu'un seul paramètre. À charge de chaque fonction d'aller piocher les paramètres qui l'intéresse dans $p.
Je n'avais pas pensé à ça... éventuellement l'inconvénient serait qu'on n'a pas de notion de "syntaxe" d'appel de la fonction, mais c'est un moindre mal.
-- In girum imus nocte ecce et consumimur igni
Le Mon, 18 Oct 2004 17:14:03 +0200, Paul Gaborit a écrit :
On n'utilise donc pas de variables globales ($p est toujours passé
explicitement) mais on n'a qu'un seul paramètre. À charge de chaque fonction
d'aller piocher les paramètres qui l'intéresse dans $p.
Je n'avais pas pensé à ça... éventuellement l'inconvénient serait
qu'on n'a pas de notion de "syntaxe" d'appel de la fonction, mais c'est un
moindre mal.
Le Mon, 18 Oct 2004 17:14:03 +0200, Paul Gaborit a écrit :
On n'utilise donc pas de variables globales ($p est toujours passé explicitement) mais on n'a qu'un seul paramètre. À charge de chaque fonction d'aller piocher les paramètres qui l'intéresse dans $p.
Je n'avais pas pensé à ça... éventuellement l'inconvénient serait qu'on n'a pas de notion de "syntaxe" d'appel de la fonction, mais c'est un moindre mal.
-- In girum imus nocte ecce et consumimur igni
Emmanuel Florac
Le Mon, 18 Oct 2004 17:47:53 +0200, Aurelien a écrit :
Ainsi, si tu peux l'encapsuler dans des modules et quand même utiliser les variables globales. Ca permet quelque chose de sympa sans trop se compliquer la vie.
Oui, mais mon problème c'est bien d'éviter d'utiliser les variables globales, en premier lieu pour la pollution engendrée de l'espace de nommage, ensuite et surtout pour pouvoir facilement migrer les fonctions dans des modules sans trop me prendre le chou...
Si tu as besoin de ne pas polluer l'espace de nommage du package main, que tu veux quelque chose de vraiment propre, il faut prendre une solution plus "lourde", comme celles proposées.
Bon, merci. Je vois que le sujet a passionné, c'est bien :) Il me manque un mini exemple avec un objet, pour que je comprenne bien, et je m'y mettrai :)
-- Dix grammes d'abstraction valent des tonnes de bricolage. Loi de Booker.
Le Mon, 18 Oct 2004 17:47:53 +0200, Aurelien a écrit :
Ainsi, si tu peux l'encapsuler dans des modules et quand même utiliser
les variables globales. Ca permet quelque chose de sympa sans trop se
compliquer la vie.
Oui, mais mon problème c'est bien d'éviter d'utiliser les variables
globales, en premier lieu pour la pollution engendrée de l'espace de
nommage, ensuite et surtout pour pouvoir facilement migrer les fonctions
dans des modules sans trop me prendre le chou...
Si tu as besoin de ne pas polluer l'espace de nommage du package main,
que tu veux quelque chose de vraiment propre, il faut prendre une
solution plus "lourde", comme celles proposées.
Bon, merci. Je vois que le sujet a passionné, c'est bien :) Il me manque
un mini exemple avec un objet, pour que je comprenne bien, et je m'y
mettrai :)
--
Dix grammes d'abstraction valent des tonnes de bricolage.
Loi de Booker.
Le Mon, 18 Oct 2004 17:47:53 +0200, Aurelien a écrit :
Ainsi, si tu peux l'encapsuler dans des modules et quand même utiliser les variables globales. Ca permet quelque chose de sympa sans trop se compliquer la vie.
Oui, mais mon problème c'est bien d'éviter d'utiliser les variables globales, en premier lieu pour la pollution engendrée de l'espace de nommage, ensuite et surtout pour pouvoir facilement migrer les fonctions dans des modules sans trop me prendre le chou...
Si tu as besoin de ne pas polluer l'espace de nommage du package main, que tu veux quelque chose de vraiment propre, il faut prendre une solution plus "lourde", comme celles proposées.
Bon, merci. Je vois que le sujet a passionné, c'est bien :) Il me manque un mini exemple avec un objet, pour que je comprenne bien, et je m'y mettrai :)
-- Dix grammes d'abstraction valent des tonnes de bricolage. Loi de Booker.
Samuel Mouniee
Bonjour,
Voilà, c'est une réflexion à deux balles : J'ai un programme avec de nombreuses fonctions, qui elles-même prennent de nombreux paramètr es. Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales... C'est pas propre et puis ça ne fonctionnera pas si je mets mes fonctions dans des modules ... Comment faire autrement? Peut-être est-i l possible de passer des paramètres de façon implicite?
une fermeture ne serait elle pas approprié ?
genre :
sub a { my( $f1, $f2, $f3 ) = @_;
return sub { print join( " + ", "", $f1, $f2, $f3, @_, "n" ); }; }
Voilà, c'est une réflexion à deux balles : J'ai un programme avec
de nombreuses fonctions, qui elles-même prennent de nombreux paramètr es.
Cependant beaucoup de ces paramètres sont toujours les mêmes.
Pour éviter de passer ces paramètres systématiquement et d'alourdir mes
appels de fonctions, je mets ces données dans des variables globales...
C'est pas propre et puis ça ne fonctionnera pas si je mets mes
fonctions dans des modules ... Comment faire autrement? Peut-être est-i l
possible de passer des paramètres de façon implicite?
une fermeture ne serait elle pas approprié ?
genre :
sub a {
my( $f1, $f2, $f3 ) = @_;
return sub {
print join( " + ", "", $f1, $f2, $f3, @_, "n" );
};
}
Voilà, c'est une réflexion à deux balles : J'ai un programme avec de nombreuses fonctions, qui elles-même prennent de nombreux paramètr es. Cependant beaucoup de ces paramètres sont toujours les mêmes. Pour éviter de passer ces paramètres systématiquement et d'alourdir mes appels de fonctions, je mets ces données dans des variables globales... C'est pas propre et puis ça ne fonctionnera pas si je mets mes fonctions dans des modules ... Comment faire autrement? Peut-être est-i l possible de passer des paramètres de façon implicite?
une fermeture ne serait elle pas approprié ?
genre :
sub a { my( $f1, $f2, $f3 ) = @_;
return sub { print join( " + ", "", $f1, $f2, $f3, @_, "n" ); }; }
