Il codice Action Script che abbiamo utilizzato nel nostro ultimo esempio potrebbe apparire un po' complesso e articolato. Bisogna inoltre tener conto che la sua complessità dipende in modo direttamente proporzionale alla complessità della struttura dell'albero XML da analizzare.
Osservando la figura sopra riusciamo subito a capire quanti array di appoggio e quanti cicli for dobbiamo utilizzare per scorrere tutto l'albero e recuperare i dati (nel nostro caso infatti abbiamo utilizzato 3 array e 3 cicli for). Se l'albero XML fosse stato più profondo avremmo dovuto utilizzare più array e più cicli for. Diventa quindi importante anche la programmazione dell'XML in modo da ottenere degli XML più semplici e leggeri possibili, tenendo presente anche che i nomi dei TAG da utilizzare non devono essere troppo lunghi in modo da incidere il meno possibile sulla quantità di informazione del documento XML.
Un'altra considerazione da fare riguarda invece le prestazioni ed i limiti che può avere la nostra applicazione Flash XML. Per far questo dobbiamo capire quanto può essere pesante il file XML.
Utilizzando sempre il filmato flash dell'ultimo esempio, ho preso il file XML e ho copiato diverse volte il blocco dei tag "volo" all'interno di "voli" ottenendo così un file XML (orari3.xml) che pesa 37 Kb. Dopo aver modificato l'url del file in modo che richiami il file XML orari3.xml ho mandato in esecuzione il filmato. L'accesso al Debugger è stato molto faticoso (vista la grossa quantità di dati) ma è stato possibile (attenzione: le prestazioni dipendono anche dalle risorse del vostro PC!).
Flash aveva in memoria 5 array con oltre 300 elementi ciascuno!!! Risultato più che soddisfacente, anche se ovviamente è vivamente sconsigliato far caricare a Flash una quantità di dati così elevata perché rischiamo di mandare in blocco l'esecuzione dell'applicazione.
Prima di procedere è bene fare un piccolo riepilogo delle funzioni e metodi utilizzati finora per l'XML e per far questo sarebbe opportuno che consultaste in Dizionario di Action Script di Flash cercando:
- XML.attributes
- XML.nodeName
- XML.childNodes
- XML.nextSibling
- XML.toString
Utilizzare l'XML "bad formed"
Il metodo che spesso utilizzo per sviluppare le mie applicazioni dinamiche con Flash si basa sull'XML "bad formed".
Questo metodo può risultare molto utile quando si sviluppano applicazioni dove il documento XML viene elaborato solo da Flash, e ci permette di avere degli XML più leggeri e del codice Action Script più semplice e veloce.
Spieghiamo cos'è l'XML "bad formed". Per far questo dobbiamo avere in mente prima di tutto le caratteristiche che deve possedere un documento XML "well formed" (che rispetta lo standard).
Secondo lo standard XML dobbiamo avere il primo nodo che indica la versione dell'XML che stiamo utilizzando (che con Flash può essere omesso), e allo stesso livello di questo nodo abbiamo poi il nodo principale che è unico, all'interno della quale abbiamo tutti gli altri nodi del documento XML.
Negli esempi precedenti abbiamo visto che con Flash quando utilizziamo ad esempio XML.childNodes otteniamo sempre un documento XML (che è però una porzione del documento XML che abbiamo in origine), composto da tutti i nodi secondari al nodo preso in esame. <
Quindi analizzando il nostro documento XML orari.xml se effettuiamo il childNodes del nodo <voli> otteniamo il sotto-albero composto dall'insieme dei nodi <volo>, ovvero:
(XML "bad formed")
volo id="AZ1570">
<partenza h="06:45">Cagliari</partenza>
<arrivo h="07:50">Roma</arrivo>
</volo>
...
...
...
...
...
...
<volo id="AZ1576">
<partenza h="13:25">Cagliari</partenza>
<arrivo h="14:30">Roma</arrivo>
</volo>
Se quindi noi utilizzassimo già di partenza un documento XML così strutturato, potremmo tranquillamente evitare nel codice Action Script di Flash di applicare il primo childNodes al documento XML e di fare il primo ciclo for per entrare nel nodo <voli>.
Utilizzare quindi in partenza un documento XML come quello visualizzato sopra, vuol dire utilizzare un XML "bad formed", che non rispetta quindi lo standard XML.
Utilizzare un XML di questo tipo permette di creare documenti XML più leggeri e meno complessi che hanno una struttura simile alle tabelle del Data Base. Infatti poiché l'XML viene ottenuto da degli script che prelevano i dati da un Data Base, risulta molto semplice aggiungere i TAG necessari per formattarli.
Facciamo un esempio trasformando il documento XML orari.xml in un XML "bad formed" per Flash (orari_bf.xml):
<volo id="AZ1570"/> <partenza h="06:45">Cagliari</partenza> <arrivo h="07:50">Roma</arrivo>
<volo id="AZ1572"/> <partenza h="07:20">Cagliari</partenza> <arrivo h="08:25">Roma</arrivo>
<volo id="AZ1578"/> <partenza h="09:05">Cagliari</partenza> <arrivo h="10:10">Roma</arrivo>
<volo id="AZ1574"/> <partenza h="10:50">Cagliari</partenza> <arrivo h="11:55">Roma</arrivo>
<volo id="AZ1568"/> <partenza h="12:00">Cagliari</partenza> <arrivo h="13:05">Roma</arrivo>
<volo id="AZ8111"/> <partenza h="12:00">Cagliari</partenza> <arrivo h="13.00">Roma</arrivo>
<volo id="AZ1576"/> <partenza h="13:25">Cagliari</partenza> <arrivo h="14:30">Roma</arrivo>
Come potete osservare la struttura ci ricorda la tabella di un Data Base, più che un albero di dati. Non abbiamo più un nodo principale, ma tutti i nodi sono allo stesso livello. Notate bene che il nodo <volo> adesso è allo stesso livello di tutti gli altri nodi, e risulta essere un nodo vuoto che ha solo un attributo "id".
Osserviamo inoltre che il peso di questo documento è di 600 byte mentre quello del documento originale "well formed" (orari.xml) è di 800 byte! Questa differenza di peso tenderà ad aumentare ovviamente quanto più saranno i dati del documento!
Vediamo come sarà il codice Action Script (es7.fla) per l'XML "bad formed":
filexml = "orari_bf.xml";
ApriXML();
function ApriXML () {
mioxml = new XML();
myarray = new Array();
mioxml.load(filexml);
mioxml.onLoad = ElaboraXML;
function ElaboraXML (success) {
if (mioxml.loaded) {
myarray = mioxml.childNodes;
Dati();
delete myarray;
delete mioxml;
}
};
};
// Funzione che prende i dati XML e li mette in degli Array
function Dati () {
// Array che contengono i Dati -----------------------
idvolo = new Array();
hpartenza = new Array();
harrivo = new Array();
partenza = new Array();
arrivo = new Array();
// ---------------------------------------------------
for (k=0; k<=myarray.length; k++) {
if (myarray[k].nodeName == "volo") {
idvolo.push(myarray[k].attributes.id);
} else if (myarray[k].nodeName == "partenza") {
hpartenza.push(myarray[k].attributes.h);
partenza.push(myarray[k].childNodes.toString());
} else if (myarray[k].nodeName == "arrivo") {
harrivo.push(myarray[k].attributes.h);
arrivo.push(myarray[k].childNodes.toString());
}
};
};
Osservando il debugger ci rendiamo conto che il risultato è lo stesso che abbiamo ottenuto con l'esempio 6, ovvero i dati prelevati dall'XML sono stati inseriti nei rispettivi array.
In questo caso però abbiamo utilizzato un unico array d'appoggio per manipolare i nodi del documento XML e quindi un unico ciclo for per estrapolare i dati e metterli nei diversi array, quindi meno risorse utilizzate. Inoltre le righe di codice Action Script che abbiamo scritto sono nettamente inferiori rispetto a quelle dell'esempio 6.
Un'altra modifica che abbiamo introdotto nel Codice è l'utilizzo della funzione Dati all'interno della quale dichiariamo gli array che ci servono per memorizzare i dati ed effettuiamo poi il ciclo for per l'estrapolazione dei dati dall'XML. Anche in questo caso gli spazi bianchi tra i vari nodi del documento XML non influiscono sul funzionamento del codice Action Script che riesce ad ogni modo ad estrapolare i dati correttamente.
I vantaggi di utilizzare delle funzioni è evidente, perché permette di creare all'interno del Codice Action Script dei blocchi indipendenti facilmente riutilizzabili e adattabili alle varie esigenze. Inoltre come vedremo più avanti questo è indispensabile affinché l'applicazione sia capace di interagire con gli script lato server e con l'utente lato client.
Considerazioni
L'utilizzo dell'XML "bad formed" è un approccio che ho sviluppato personalmente nella realizzazione di applicazioni dinamiche Flash - XML, molto utile quando il documento XML viene elaborato solo da Flash, risparmiando sui tempi di sviluppo e ottenendo degli script più leggeri e semplici. Questo metodo funziona sia con Flash 5 che con Flash MX e i relativi player. Tuttavia non è consigliato utilizzare questo metodo nel caso l'XML debba essere manipolato anche da altre applicazioni non-flash come ad esempio documenti XSLT.
Inoltre l'XML "bad formed" non viene visualizzato correttamente dai Browser che supportano l'XML in quanto mostrano un messaggio d'errore e per vedere il codice con i TAG bisogna andare sul "view source HTML" del browser stesso.
