Newsgroup: it.comp.lang.perl
Titolo: DuBBio: Moduli e Subs

Un dubbio: ma se metto "use" all'interno di una sub,
il modulo viene caricato lo stesso anche se la sub non viene usata in
runtime ??
--- esempio 1: ---
use GD;
print "ciao\n";
exit;
sub do_image {
    my $image = new GD::Image(100,100);
    # [eccetera....]
}
--- esempio 2: ---
print "ciao\n";
exit;
sub do_image {
    use GD;
    my $image = new GD::Image(100,100);
    # [eccetera....]
}
Cosa cambia fra il primo e il secondo esempio? Nel secondo viene caricato lo
stesso il modulo GD ??
So che al momento dell'esecuzione viene fatto il parsing di tutto il codice
e se un modulo non è disponibile viene restituito un errore.
Ma a me interessa sapere se mettendo "use" all'interno della sub, il modulo
viene caricato
solo se viene richiamata la sub.
E per i require ??
::guido::

::guido::
--
www.pigmalion.info
www.pigmalion.info/perl/

Guido NOOOOOOOOOOO!!!! :-)
Sei proprio fuori strada! Innanzi tutto use o require non si comportano per
niente allo stesso modo! use è una direttiva che perl chiama at compile
time, mentre require viene chianato at run time!!!
   use pippo;
ti da un errore di sintassi se ne verifichi la sintassi e non esiste il
modulo 
pippo.pm
, mentre
   require "
pippo.pm
";
non da nessun errore di sintassi quando ne verifichi la sintassi, ma quando
fai "girare" il programma.
Per rispondere alla domanda quindi: use viene trovato dal compilatore anche
se sta all'interno di una sub, mentre require viene invocato al momento in
cui sarà invocata la sub che lo contiene, quindi prova a fare un paio di sub
e vedere come reagiscono quando fai girarer il programma e quando lo compili
solamente.
sub r { require "pippo" };
sub u { use pippo }
ciao
--
perl -MLWP::Simple -e "getprint(' 
http://perl.4pro.net
 ')"

ops... il "NOOOOOOOO" era per pigmalion, non per guido :-)


 solamente.
rileggendo la mia replica, forse non si capisce bene:
use all'interno di una sub viene comunque eseguito al compile time ANCHE se
non si usa la sub durante il run time
require all'interno di una sub viene eseguito SOLO se la sub sarà eseguita
al momento del run time.
HTH


al momento del run time.
vero... ho provato...sorry, sono stato troppo precipitoso, del resto è
per questo che ho smesso di chiamare use nelle sub ma direttamente in
cima al file, più chiaro...
ma cazzo pure tu a guido..ma 2 prove?
Questi so gli sfizi che ti togli all'inizio...almeno mi evitavi la
tirata di recchie ^_^
ciaz
--
www.pigmalion.info
www.pigmalion.info/perl/

 al momento del run time.
Ok, ora è chiaro.
Grande Domizio (che nome!! :-))
Il problema me lo sono posto perché
finché creo un'applicazione va bene, ma se
sto creando uno script per web, la logica è quella di
creare subs ognuna preposta a uno scopo, e richiamarle in
base a un parametro action dalla query string.
Ora se per eseguire 10 funzioni ho bisogno di 10 moduli,
considerando che uno script web nasce e muore con la pagina web
magari ho usato solo una sub quindi un solo modulo, intanto ne ho caricati
(eseguiti) 10.
Quindi, a quanto pare, mettere "use" in una sub non serve a niente.
io di solito li metto sempre all'inizio, tranne in casi in cui "riciclo"
subs da altri programmi
che ho già fatto, tipo la mia riciclatissima sub "sendmail"
(che non usa Net::SMTP ma faccio tutto a modo mio, lo sai... keep on
reinventing the wheel!)
che uso ogni volta che faccio qualcosa per il web. All'interno ci metto use
IO::Socket, ma giusto per non
dimenticare di metterlo nel main.
Ma ci sono modi per ottimizzare l'uso dei moduli ?
::guido::

 ha scritto nel messaggio
news:67ac8vcjumivvb9fb...@4ax.com...

io ero sicuro che use viene controllato at compile time, ma non ho mai
capito
se viene anche "eseguito".
Per require, so che funziona diversamente da use, ma anche in questo caso
non ho mai capito
se require si puo' mettere in una sub o no, e in tal caso se viene eseguito
at compile time o at run time.
Ora San Domizio ci ha tolto i dubbi :-)
Scusa per le recchie... fanno male??

Ma ci sono modi per ottimizzare l'uso dei moduli ?
Che intendi?
Mi chiedo se sia preferibile evitare chiamate allo stesso modulo nelle
varie sub dello stesso script .
Ad occhio sembra del tutto irrilevante, ma questa è la sega mentale
della serata :) quindi...
ciaz
--
www.pigmalion.info
www.pigmalion.info/perl/

 ha scritto nel messaggio
news:pcbc8vg99l7avhoum...@4ax.com...


La sega mentale è stare di sabato sera a casa davanti a sto maledetto
computer!
(e senza nemmeno l'odore di una gnokka che ti si concede!! :-)))

> Ora San Domizio ci ha tolto i dubbi :-)
hmmm... veramente mi sembra di no. :-) Quello che davvero potrebbe togliere
i dubbi sarebbe leggersi un po' di documentazione su require e su use
Quello che mi pare pure di capire qui è che si voglia fare un uso di "use"
condizionale: importare un certo modulo solo se serve e non sempre.
Per fare ciò (dopo aver letto la documentazione) sarebbe pure utile leggere
qualcosa sull'uso di moduli che auto-importano (leggono) una sub solo se
viene usata all'interno del programma. Non ne scrivo direttamente il nome
così la ricerca diventa più interessante da parte vostra ;-)
Si devono comunque sempre considerare vantaggi-svantaggi specifici relativi
a quantità e tempi di loading dei moduli interessati. Ad esempio se hai un
paio di moduli leggeri da includere con use, forse ritardare la compilazione
del modulo che includi causerà un tempo più lungo in totale che quello di
caricarli entrambi in una volta. Se invece ne hai una cinquantina, mi punge
vaghezza che sarebbe più economico caricare SOLO quelli che effettivamente
servono.
Un altro modo più casereccio (senza moduli auto) di ottenere un use
condizionale (o at run time) è quello di dividerlo nei suoi componenti
naturali require e import. (tutto scritto nella doc). Use è più efficiente
di require + import, ma come detto prima, a volte può essere più conveniente
tralasciare il caricamento di parecchi moduli. Provare... provare...
provare.....   :-)
ciao
dd


 Ma ci sono modi per ottimizzare l'uso dei moduli ?
si: leggersi la documentazione e capire bene COSA succede e quando, e
decidere cosa conviene facendo anche prove pratiche. :-)
ciao


 varie sub dello stesso script .
se per "chiamate" intendi scrivere "use modulo" o "require "file"" in più
parti del programma... allora si è del tutto irrilevante, visto che sia use
che require vengono fatti UNA sola volta sullo stesso file.


 decidere cosa conviene facendo anche prove pratiche. :-)
Una di queste prove pratiche potrebbe essere l'uso di B::Deparse.
E` un'interfaccia del compilatore Perl [1] che puo` essere usata per
vedere come e` stato compilato e ottimizzato il proprio codice.
Spesso e` molto istruttivo per vedere "what's going on", e per
scoprire i bug piu` insidiosi (che spesso dipendono da una scorretta
interpretazione della documentazione). Schematicamente:
[usate un font non proporzionale]
                    +-----------+    +----------+
   Sorgente Perl -> |Compilatore| -> |B::Deparse| -> Sorgente Perl
                    +-----------+    +----------+    corrispondente alla
                                                     struttura interna
                                                     generata dal 
compilatore
In questo caso, scrivendo in un file 
foo.pl
 questo codice:
     sub foo
     {
         if ( rand > 0.5 ) {
             use CGI; # Un modulo a casaccio
         }
     }
Poi da linea di comando:
     ------------------------------
     $ perl -MO=Deparse 
foo.pl
     use CGI;
     sub foo {
         if (rand > 0.5) {
         }
     }
     ;
 
prova.pl
 syntax OK
     ------------------------------
Si veda la differenza sostituendo 'use' con 'require'.
ciao
Stefano
[1] 
http://www.perl.com/doc/FMTEYEWTK/comp-vs-interp.html

Stefano! Non smetti mai di stupirmi!
In effetti tutta la documentazione sotto B:: per me č sempre stata molto
simile all'arabo :-), cosě mi sono privato delle delizie piů saporite...
come nel caso di B::Deparse, di cui ignoravo addirittura l'esistenza! Grazie
dd


 subs da altri programmi
Il metodo più pulito ma anche più compicato è quello di usare AutoLoad 
-scusa Dom se ho fatto il nome... ;-)- che ben si adatta al caricamento 
runtime di subs.
Un'altra tecnica, che può più o meno piacere, è quella di usare costrutti del 
tipo:
	eval { use My::Module }
	if ( $@ ) {
		# Errore nel caricamento del modulo
	}
	...
all'interno delle varie subs.
by 
	- Enrico

 ha scritto nel messaggio
news:20030331113047....@sorcinelli.it...


 [...]
Ciao,
scusa ma forse ho inteso male il tuo post?
Mi pare che riguardasse la tua preoccupazione a caricare troppi moduli in uno 
script Web, quando per una singola invocazione potrebbero servirne meno.
Ora le mie indicazioni sono applicabili a quei sistemi operativi per i quali 
è stato fatto il porting di Apache/mod_perl e praticamente tutti (Amiga 
compreso mi pare).
E comunque l'uso di "eval { use Nome::Modulo }" è una possible soluzione al 
tuo problema.
Semmai, mea culpa, ho dato per scontato che tu usassi Apache come web server.
In ambiente M$ IIS, PerlEx (della ActiveState) offre simili vantaggi, ma non 
è free.
by
	- Enrico