Discussion :

[frenchlion]

bonjour,

il y a un petit principe de base que j'ai du rater sur les packages (ou les appelle-t'on modules ?)

aujourd'hui, j'ai une boucle (je simplifie), et j'aimerais appeler un différent package (module?) suivant la valeur de la boucle.

un truc du genre :

Code :

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

1
2
3
4
5
6
 
foreach my $app (@apps) {
  use machin::$app;
  my $ret = &machin::$app::sub(truc);
  print $ret . "\n";
}

bien évidemment ça ne fonctionne pas, je dois apparemment utiliser des "eval" pour faire fonctionner le tout (même si j'ai pas réussi).

on me dit que ce n'est pas la bonne méthode à utiliser, quid ?
un best practice svp ?

globalement, suivant l'application ($app), j'aimerais utiliser des fonctions etc. différentes et les mettre dans différents modules/packages/fichiers.

comment faire cela ?

merci!

cdt,

[alainbb]

Pour ma part, j'ai voulu faire de même pour une gestion de plugin.
Je fais une boucle sur tous les .pm du répertoire "plugin" et je les "use", en effet dans un "eval".
Le résultat est assez sympathique, car je rajoutais automatiquement un menu Tk en fonction des modules trouvés, mais en effet, cela alourdissait d'autres choses, de mémoire du débugage ou des incompatiblités avec divers outils.
J'ai abandonné mais je reste intéressé par le principe.

[Lolo78]

Le plus simple serait tout de même de charger tous les modules dont tu peux avoir besoin, quitte à ne les utiliser tous, sauf s'ils sont vraiment très gros et/ou très nombreux.

Sinon, la fonction require permet une inclusion conditionnelle. Un truc dans ce genre (non testé)

Code :

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

1
2
3
4
5
6
 
if ($c eq "A") {
     require module_A;
} else {
     require module_B;
}

Les fonction eval et do permettent aussi de faire des choses similaires, mais je ne recommanderais pas vraiment, sauf besoin particulier.

[frenchlion]

salut

les charger n'est pas un soucis, j'y arrive avec un :

my $module = "machin::$app"
eval("use $module");

le soucis est d'utiliser les routines des modules après.. (comment je fais ?)

et c'est pas très pratique non plus

[Lolo78]

La manière normale, de nos jours, d'inclure un module est d'utiliser l'opérateur use :

Code :

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

1
2
use my_module;
use my_other_module qw /func1, func2, func3/;

La première syntaxe n'importe du module que les fonctions qui sont automatiquement exportées par le module. La seconde syntaxe spécifie une liste de fonctions que l'on veut utiliser. Mais l'opérateur use est exécuté à la compilation, et ne peut donc dépendre de conditions qui ne seront connues qu'à l'exécution.

Je pense franchement que le plus simple serait d'utiliser use pour importer inconditionnellement tous les modules dont tu peux avoir besoin (à moins qu'ils ne soient vraiment trop gros ou trop nombreux, ou qu'il y ait des dangers de collisions de noms, ce qui serait sans doute le signe d'une conception fautive).

Mais, si tu veux vraiment faire un import conditionnel, alors il faut comprendre que:

Code :

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

1
2
 
use my_other_module qw /func1, func2, func3/;

est équivalent à:

Code :

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

BEGIN { require my_other_module; my_other_module->import( qw /func1, func2, func3/ ); }

L'opérateur require est moins puissant que use, mais l'avantage de require dans ton cas est qu'il n'importe les fonctions du module qu'à l'exécution, et que l'importation peut donc être rendue conditionnelle.

Je te conseille d'éviter les deux autres opérateurs susceptibles d'importer du code dans ton programme, eval et do, car ils sont bien moins perfectionnés et exigent bien plus de travail de vérification.

Les opérateurs use et require présentent au moins les deux avantages suivants:
- un module n'est chargé qu'une et une seule fois, même si par exemple ton module_A et ton module_B, tous les deux appelés par ton programme, incluent tous les deux le module_C. Avec do ou eval, cela conduirait à des problèmes de redéfinition des mêmes fonctions et des warnings (et tu actives les warnings, j'espère).
- Toute erreur de syntaxe dans le fichier inclus entraîne la mort du programme. Pas besoin de vérifier s'il y a eu un problème en consultant le contenu de la valeur de la variable $@ comme il faut impérativement le faire avec eval et do.

Les opérateurs eval et do restent très utiles pour leurs autres usages, mais ils sont obsolètes et à éviter pour inclure du code d'un autre fichier dans le fichier courant. Les opérateurs use (préférentiellement) et accessoirement dans certains cas particuliers require sont ceux qu'il faut utiliser de nos jours.

[frenchlion]

merci pour l'explication complète des modules, mais cela ne répond pas à ma question originale sur le fait d'appeler un module avec une variable dans le nom (utiliser une variable pour appeler différents modules).