Flash und XML unter einem Dach

Mit dem XML-Objekt wird es Flash ermöglicht, XML-Dokumente einzulesen, zu verarbeiten und auch zu erzeugen. Wie jedes andere Objekt in Flash 5 muss auch eine Variable zunächst mit dem Schlüsselwort new erzeugt werden. Dazu stehen zwei Konstruktoren zur Verfügung:

myObj = new XML();
myObj = new XML(source);
	

Die erste Form eignet sich gut, um in Flash ein XML-Dokument von Grund auf neu zu erstellen. Die zweite Form übernimmt einen XML-Quellcode als String, so dass hier schon vorhandener XML-Code übergeben werden kann. Eine Aufstellung aller Methoden und Eigenschaften des XML-Objekts findet sich im Web.

Wie das folgende Beispiel zeigt, ist aber auch die direkte Übergabe von XML-Objekten möglich:

$string = "<H1>Header</H1>";
myObj = new XML($string);
	

Damit enthält myObj bereits ein vollständiges XML-Objekt mit dem XML-Knoten (NodeName) <H1> und dem Wert (NodeValue) "Header". Vom Typ her handelt es sich hierbei um einen TextNode. Diese Informationen können mit dem Flash-eigenen Debugger angezeigt werden.

Der Debugger in Flash ist eigentlich kein richtiger Debugger, sondern mehr ein Viewer. Dennoch ist es ganz nützlich, sich die XML-Variable damit einmal anzuschauen, weil so die ganze Struktur des XML-Objekts etwas deutlicher wird:

Um den Film im Debug-Modus zu starten, verwendet man entweder den Menüpunkt Steuerung - Fehlersuche oder die Tastenkombination <Strg>+<Shift>+<Enter>. Im jetzt angezeigten Debug-Fenster sollte eine Filmsequenz "_level0" sichtbar sein. Ist das nicht der Fall, sollte man den Film wieder beenden (ohne das Debug-Fenster zu schliessen) und es noch einmal versuchen. Leider hat Flash manchmal Probleme bei der korrekten Anzeige im Debug-Fenster.

Man sieht, wie dieses einfache Beispiel schon eine recht komplex geschachtelte Struktur erzeugt:

XML-Objekt 
> lastChild (der XML-Knoten "H1")
	> lastChild (der XML-Knoten "Header")
	

Um den Aufbau eines solchen XML-Baumes zu verdeutlichen, soll diesem Beispiel ein weiterer Knoten hinzugefügt werden:

test = new XML("<H1>Header</H1>");
first = test.createElement('first_Element');
test.appendChild(first);
myText = test.toString();
	

Die erstellte Variable myText gehört in diesem Fall zu einem dynamischen Textelement, so dass der resultierende XML-Quellcode im Flashfilm angezeigt wird. Als Ergebnis für das hinzugefügte Element erhält man schliesslich den XML-Code:

<H1>Header</H1>
<first_Element />
	

Werden Attribute zu einem XML-Element benötigt, so können diese über die Eigenschaft "attribute" definiert und ausgelesen werden:

test = new XML("<H1>Header</H1>");
first = test.createElement('first_Element');
test.appendChild(first);
first.attributes.name = 'firstname';
first.attributes.dummy = 'dummy1';
	

Obige Anweisungen ergeben dann den folgenden XML-Code:

<H1>Header</H1>
<first_Element dummy="dummy1" 
name="firstname"/>
	

Damit wurden bisher nur Elemente erzeugt, die keine Inhalte haben. Um diese ebenfalls einzufügen, muss ein XML-Textknoten als Child des Elements eingefügt werden:

test = new XML("<H1>Header</H1>");
first = test.createElement('first_Element');
test.appendChild(first);
first.attributes.name = 'firstname';
first.attributes.dummy = 'dummy1';
second = test.createTextNode('text node');
first.appendChild(second);
	

Damit erhält man schliesslich den folgenden XML-Code:

<H1>Header</H1>
<first_Element dummy="dummy1" 
name="firstname">
text node
</first_Element>
	

Um die einzelnen Elemente anzufügen, muss man die Gesamtstruktur des XML-Dokuments beachten. Ausgehend von dem Hauptknoten (dem Dokument selbst), gibt es den ersten Child-Knoten (hier: "first_Element"). Unterhalb eines jeden Knotens können weitere Child-Knoten existieren (hier: der Textknoten zu "first_Element").

Ausserdem können zu jedem Knoten gleichberechtigte Geschwister (Siblings) existieren, die auf der gleichen Ebene stehen wie der referenzierte Knoten.

Analyse von XML-Code

Um dies etwas deutlicher zu machen, soll folgendes XML-Dokument analysiert werden, das einen Auszug aus einem Adressenstamm darstellt:

<address>
  <fname>Heinz</fname>
  <lname>Becker</lname>
  <street>Holzweg</street>
  <street>Hinterhaus 2a</street>
</address>
	

Der Knoten "address" ist der erste childNode unterhalb des Dokuments. Die Knoten "fname", "lname" und "street" befinden sich allesamt auf der gleichen Ebene, sind also "siblings" des ersten childNode "address". Der Flash-Code zeigt nun diese Elemente einzeln an:

test = new XML();
test.ignorewhite=true;
test.load('test.xml');
test.onLoad = loader;
	

Ein neues XML-Objekt wird erzeugt und mit der Methode load() von der Textdatei eingelesen. Hinweise zu der Eigenschaft "ignoreWhite" sind im Textkasten beschrieben. Um das Beispiel in der gleichen Weise nachvollziehen zu können, sollten alle Zeilenschaltungen aus dem XML-Code entfernt werden. Mit dem Ereignis onLoad wird die Funktion loader() aufgerufen, die später im Code definiert wird.

function show_adr(x)
{
   $string = "";
   child1 = x.firstChild;
   $string += "child1: " + 
	child1.nodeName + "\n";
   child2 = child1.firstChild;
   $string += "child2: " + child2.nodeName + 
	":" + child2.firstChild.nodeValue +
	"\n";
   sib1 = child2.nextSibling;
   $string += "sib1: " + sib1.nodeName + 
	":" + sib1.firstChild.nodeValue + 
	"\n";
   sib2 = sib1.nextSibling;
   $string += "sib2: " + sib2.nodeName 
	+ ":" + sib2.firstChild.nodeValue +
	"\n";
   sib3 = sib2.nextSibling;
   $string += "sib3: " + sib3.nodeName + 
	":" + sib3.firstChild.nodeValue + 
	"\n";
  return $string
}
	

Die Funktion show_adr() liest den ersten Child-Knoten und zeigt dessen node-Namen an. Das ist in diesem Beispiel "address". Der Child-Knoten des address-Elements ist wiederum ein XML-Knoten mit dem Namen "fname". Um gleichzeitig auch den Inhalt anzuzeigen, wird der Text der childNode von fname über firstChild.nodeValue gleich mit ausgegeben. Die einzelnen Geschwister werden dann nacheinander mit "nextSibling" abgerufen und deren Namen und Inhalt angezeigt.

function loader(success)
{
  if (success)
  {
    myText = show_adr(test);
  }
}
	

Die Funktion loader wird über das onLoad-Ereignis beim Laden des XML-Codes automatisch aufgerufen. Ist die Variable "success" auf true gesetzt, so wurde der Code vollständig gelesen. Diese Abfrage ist insbesondere dann wichtig, wenn grösserer XML-Code über das Internet eingelesen werden soll. Solange der Code nicht vollständig gelesen wurde, kann auch keine Auswertung erfolgen.

Fazit

Das XML-Objekt ist ein leistungsstarkes Tool, wenn es darum geht, XML-Code zu analysieren und auszuwerten. Da der gesamte XML-Code als Baum im Speicher gehalten wird, benötigt dieses Objekt gerade bei umfangreichen XML-Dokumenten sehr viel Arbeitsspeicher. Der Vorteil dieser Methode ist jedoch, dass eine Navigation zwischen den XML-Knoten des Dokuments möglich ist. Wegen des komplexen Aufbaus eines solchen Dokumentenbaumes ist eine solche Navigation jedoch gewöhnungsbedürftig und nicht ganz einfach.