Newsgroup: it.comp.lang.javascript
Titolo: script che includono script

Ciao
sto lavorando ad una libreria in javascript costituita da un grande 
numero di file che ovviamente non servono tutti contemporaneamente nella 
stessa pagina. Quindi per ora includo manualmente per ogni pagine tutti 
i file necessari.
Dato che alcuni file richiedono altri file, volevo chiedervi se 
conoscevate un sistema che permette ad uno script di includerne un altro 
automaticamente. In particolare mi servirebbe un sistema che permetta 
agli script di includere i file di cui necessita, se questi non sono già 
stati inclusi.
Avevo anche pensato di usare un sistema per comprimere il codice e 
creare un unico file, ma la libreria comprende oggetti molto diversi tra 
loro (tooltip, dragger, finestre, bottoni, scelta colore, ecc..) e credo 
sarebbe uno spreco aggiungere tutti questi componenti anche in pagine 
che tanto non li usano.
Altrimenti avete altre idee?
grazie
FF

 stati inclusi.
mmm
perche' mi viene in mente il c? :P
#include "libreria.h" 
+
#ifndef LIBRERIA_H
#define LIBRERIA_H
...
#endif
seriamente.
Che io sappia, non si puo' includere un js in un altro direttamente,
tuttavia si puo' creare un libreria.js che, una volta inserito in una
pagina html con un classico
<script type="text/javascript" src="libreria.js"></script>
contenga una serie di
if (!l1)
document.write("<script type=\"text/javascript\" src=\"l1.js\"></script>");
if (!l2)
document.write("<script type=\"text/javascript\" src=\"l2.js\"></script>"); 
if (!l3)
document.write("<script type=\"text/javascript\" src=\"l3.js\"></script>"); 
document.close();
ovviamente si presuppone che l1, l2 e l3 vengano avvalorate a true in l1.js,
l2.js e l3.js...
-- 
Torno subito

 stati inclusi.
mmm
perche' mi viene in mente il c? :P
#include "libreria.h" 
+
#ifndef LIBRERIA_H
#define LIBRERIA_H
...
#endif
seriamente.
Che io sappia, non si puo' includere un js in un altro direttamente,
tuttavia si puo' creare un libreria.js che, una volta inserito in una
pagina html con un classico
<script type="text/javascript" src="libreria.js"></script>
contenga una serie di
document.write("<script type=\"text/javascript\" src=\"l1.js\"></script>");
document.write("<script type=\"text/javascript\" src=\"l2.js\"></script>"); 
document.write("<script type=\"text/javascript\" src=\"l3.js\"></script>"); 
document.close();
non so che dirti riguardo l' "unicita'" dell'inclusione... sorry
-- 
Torno subito

 non so che dirti riguardo l' "unicita'" dell'inclusione... sorry
mi sa tanto di "accrocchio" pero'... (similmente all' ifndef...endif del c)
potresti mettere, nei singoli file inclusi, qualcosa come
try { nomeLib==true } catch (e) { nomeLib=true;
//qui ci metti tutto quello che andrebbe
//nel file nomeLib.js
}
su firefox pare che funge...
-- 
Torno subito

Si può utilizzare anche un approccio simile a quello di JavaScript O
Lait,
dove c'è la nozione di moduli. Si può fare qualcosa del tipo:
var codecs = importModule("codecs");
Dove per importare un modulo si fa:
- si carica il contenuto di un file JS residente sul server tramite un
oggetto XMLHttpRequest;
- si esegue il programma JS tramite il metodo eval.
http://jsolait.net/doc/tutorial.xhtml
Non so comunque quanto convenga. Io farei caricare tutti gli script,
magari utilizzando un "minifier" per minimizzare la lunghezza degli
script stessi.
Es.:
http://www.crockford.com/javascript/jsmin.html
Gaetano

 
E' perfetto. Io avevo fatto una cosa simile (le variabili sono aggiunte 
ad un oggetto invece che definite globali), ma mi mancava il metodo 
close!! Senza non vedevo i file caricati. Ora funge tutto, anche l'unicità.
Appena finisco la libreria vi posto l'indirizzo, è LGPL magari a 
qualcuno interessa.
Ciao e grazie!
FF

 Ora funge tutto, anche l'unicità.
'spetta, stai dicendo che con l' "if (!variabile_non_ancora_definita)"
funge?!
Ma guarda che a me ff da solo un bell' errore...
-- 
Torno subito 

 attaccando un nodo <script src="..."> ? Con i CSS funziona :-)
O_o
boh, onestamente non lo so... pero' non sarebbe tanto insana come idea... 
(anche se alla fine non c' e' molta differenza tra una serie di appendchild
e i vari document.write() ... tranne che l'appendChild e' piu' figosa :P)
per quanto riguarda l' unicita'... stavo pensando... e usare l'attributo
src?
-- 
Sto ascoltando: "Francesco De Gregori - I muscoli del capitano" (da: "Fuoco
                amico", album del 2002, traccia 9, voto 0)

 ogni volta ne appendi uno nuovo alla hread, sono sempre nodi diversi.
si', ma, in generale, non e' bello che un certo file (es: doppione.js) venga
incluso 2 volte. per dire, che succede se ho
libreria1.js, che richiede per funzionare doppione.js e libreria2.js che,
anch' essa richiede doppione.js?
mi ritrovero' (a "run time") una cosa come
 <script type="text/javascript" src="doppione.js"></script>
 <script type="text/javascript" src="libreria1.js"></script>
 <script type="text/javascript" src="doppione.js"></script>
 <script type="text/javascript" src="libreria2.js"></script>
e non e' bello...
pero' se si "premette" l' inclusione della libreria tramite un if... e
pensavo a quale fosse la condizione giusta per evitare la presenza di
questi problemi, quindi pensavo di utilizzare l' attributo src...
-- 
Sto ascoltando: (voto )

 anch' essa richiede doppione.js?
Il sistema che avevi detto funziona bene. Io ho usato questo sistema:
var Manager =
{
	...	
	path : "il_path_dei_file",
	include : function(module)
	{
		if(eval('!BiiOJS.'+module))
		{
			document.writeln('<script language= "JavaScript" type= 
"text/javascript" src= "'+BiiOJS.path+'/'+module+'.js" ></script>');
			document.close();
			eval('BiiOJS.'+module+' = 1;');
		}
	},
	.....
 
}
Ovviamente i moduli devono avere nomi diversi, ed il path ben definito. 
Cosě mi basta fare Manager.include("miomodulo"); e se non c'č viene incluso.
Non ho ancora provato perň con appenChild. Secondo voi alla fine cambia 
veramente qualche qualche cosa tra i due sistemi.
FF

 che tanto non li usano.
Non è detto. Dipende dal peso del file risultante, dalla complessità degli
oggetti già istanziati. Ricordati che quell'unico file verrà poi cachato
dopo il primo accesso dal browser, e quindi i successivi accessi saranno
più performanti e veloci; soprattutto rispetto ad "n" file, a maggior
ragione se richiamati dinamicamente.
Inoltre c'è il vantaggio di avere tutto in un unico blocco. Non rischierai
di richiamare cose che ancora non sono state "lette".
Ripeto, tutto questo ovviamente è subordinato alla complessità del file
risultante.
Per l'inclusione "da codice js, di codice js", è bene aspettare la versione
di Javascript 2.0, dove si potrà fare nativamente (a meno che le cose non
siano cambiate nel frattempo).
-- 
~ "L'arte non riproduce cio' che e' visibile,ma rende visibile cio' che
non sempre lo e'" (Paul Klee)

 attaccando un nodo <script src="..."> ?
Per funzionare funziona, ma non sempre nel modo corretto; anche perché pare
che l'attributo "defer" non funzioni correttamente su tutti i browser.
-- 
~ Non sono disordinato. Sono solo un massimizzatore di entropia.

 ... tranne che l'appendChild e' piu' figosa :P)
Più figosa non direi. Più lenta, magari.
-- 
~ Un computer e' fondamentalmente stupido.
Non fa cio' che vuoi che faccia, ma cio' che gli dici di fare.

 
Aspetterò e speriamo non ci voglia tanto :-)

 Aspetterò e speriamo non ci voglia tanto :-)
Il problema sarà la diffusione. Anche quando uscirà, tale caratteristica
non potrà essere usata fintanto che non sarà uno standard almeno nei
browser più diffusi.
-- 
~ Se potete leggere questo, la mia donna è caduta.
(Letta sul retro di una maglietta di un motociclista)

 presente che lavori in un ambiente del tutto diverso. 
La libreria per come la sto progettando si basa proprio sulla 
modularizzazione, e non saprei come poter organizzare tutti questi 
componenti (con relative personalizzazioni) senza "sprecare" risorse.
Il JS è interpretato, e se io non creo componenti separati, i file 
raggiungereanno (nel tempo) dimensioni enormi, e ne perderà l'efficienza.

 componenti (con relative personalizzazioni) senza "sprecare" risorse.
Così come stai facendo le risorse vengono "sprecate". Perché il tuo
concetto di "spreco" è quello della programmazione canonica.
Qui, facendo troppi file separati da dover far caricare al browser, perdi
in efficienza. E non il contrario.
Ti ripeto, non devi buttare tutto in un unico file. Ma neppure averne 10
separati. Devi trovare un buon compresso, una via di mezzo.
Che ti consenta di avere una discreta modularità a livello di codice, e un
numero limitato di file esterni.
-- 
~ Confondi il mondo, sorridi tutti i lunedì!