 |
Sie kennen schon einige sehr nützliche Aspekte und Eigenschaften von XML. So z.B. die automatische Validierung oder auch die grundsätzlichen Vorteile (Textdateien, gut zu verarbeiten etc.).
Manche Personen sind der Meinung, das Thema dieses Kapitels, XSLT, wäre das nützlichste aller XML-Werkzeuge. XSLT steht für "Extensible Style Language for Transformation" und ist, wie der Name vermuten lässt, eine Sprache für die Transformation von XML-Dokumenten.
Transformation, das kann bedeuten, XML-Daten nach XHTML zu konvertieren. Oder vielleicht auch nur, aus tabellarischen Daten bestimmte Spalten herauszufiltern. Vielleicht bedeutet es aber auch, die gesamte Struktur eines Dokuments zu ändern. Was davon zutrifft, hängt ganz von Ihnen ab. An XSLT wird Ihr Vorhaben jedenfalls nicht scheitern.
Grundsätzliches
Auch für das Verständnis und die Verwendung von XSLT ist die Baum-Metapher von entscheidender Bedeutung. Unter XSLT fließt jeder Bestandteil eines Dokumentes mit in den Baum ein, sogar Kommentare und Steueranweisungen. Ein "Blatt" des Baumes heißt "Knoten". Erläuterungen dazu finden Sie in der vorangegangenen Folge des Tutorials.
Das darauf aufbauende Grundkonzept von XSLT ist ganz einfach: es werden Vorlagenregeln definiert. Zu jeder Regel gehört eine Bedingung und eine Konsequenz, d.h. im Endeffekt das, was erzeugt wird, wenn auf die Regel zugegriffen wird. Während der Verarbeitung bewegt sich der XSLT-Prozessor ("Prozessor" im Sinne von Verarbeitungsprogramm) durch den Baum und überprüft, welche der definierten Regel-Bedingungen gerade zutreffen könnte. Praktischerweise beziehen sich die meisten Regel-Bedingungen auch wieder irgendwie auf den Baum. Wenn eine Bedingung zutrifft, dann erzeugt der Parser die zur Regel gehörenden Inhalte (die "Konsequenz"). Dann, wenn eine bestimmte Anweisung in der aktuellen Regel steht (zu der weiter unten mehr), wendet der Prozessor sich den Nachkommen des aktuellen Baum-Knotens zu. Ansonsten klettert er in der Hierarchie wieder zurück nach oben.
Um uns die Arbeit zu erleichtern, gibt es zusätzlich dazu noch einige Standard-Regeln:
- Die Verarbeitung beginnt beim Wurzel-Knoten
- Standardmäßig wird jeder Element-Knoten bearbeitet, und zwar so, dass von ihm ausgehend der Prozessor nach Unterknoten sucht. Ausnahme: der Parser war schon bei einem der Vorfahren des Element-Knotens und bekam dort die Anweisung, nicht weiter nach unten abzusteigen.
- Wenn der Prozessor einen Text- oder Attribut-Knoten erreicht, werden die Inhalte automatisch ausgegeben. Wenn Sie sich an das Baum-Schema der letzten Lektion erinnern: Text-Knoten sind Unterknoten von Element-Knoten.
- Wenn der Prozessor einen Kommentar- oder Steueranweisungsknoten erreicht, werden die Inhalte ausgelassen.
In der Praxis bedeutet das: wenn Sie keine neuen Regeln definieren, werden alle Text- und Attributs-Knoten hintereinander ausgegeben. Wieso? Regel 2 definiert, dass normalerweise jeder Element-Knoten verarbeitet wird und dass von ihm ausgehend nach Unterknoten gesucht wird. Element-Inhalte (also Texte zwischen zwei Tags) und Attribute werden als solche Unter-Knoten gespeichert. Und Regel drei besagt, dass solche Knoten, wenn sie vom Prozessor erreicht werden, ausgegeben werden.
Insgesamt sind diese Regeln für die meisten Situationen genau das, was wir wollen, denn sie erleichtern uns die Arbeit. Wir können sie manuell überschreiben und erweitern, aber dazu weiter unten mehr.
XSLT in Action
Folgendes Beispiel zeigt, wie eine XML-Mitarbeiter-Datenbank (ja, die kennen Sie schon ;-) in XHTML transformiert wird.
Das hier ist die XML-Quelldatei:
<?xml version="1.0" encoding="iso-8859-1"?>
<?xml-stylesheet href="test.xsl" type="text/xsl"?>
<!DOCTYPE mb-datenbank SYSTEM "test.dtd">
<mb-datenbank>
<abteilung>
<name>
IT-Abteilung
</name>
<angehoerige>
<mitarbeiter>
<nachname>Meier</nachname>
<telefon>3421</telefon>
</mitarbeiter>
<mitarbeiter>
<nachname>Müller</nachname>
<telefon>5564</telefon>
</mitarbeiter>
<mitarbeiter>
<nachname>Hinkelstein</nachname>
<telefon>3456</telefon>
<untergebene>
<mitarbeiter>
<nachname>Schulz</nachname>
<telefon>3321</telefon>
</mitarbeiter>
<mitarbeiter>
<nachname>Zupul</nachname>
<telefon>6768</telefon>
<untergebene>
<mitarbeiter>
<nachname>Arletz</nachname>
<telefon>7593</telefon>
</mitarbeiter>
</untergebene>
</mitarbeiter>
</untergebene>
</mitarbeiter>
</angehoerige>
</abteilung>
</mb-datenbank>
Die XSLT-Quelldatei wird hier in der zweiten Zeile angegeben. Wenn Sie das Beispiel ausprobieren möchten, muss der Pfad entsprechend angepasst werden.
Und hier das XSLT-Stylesheet:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:template match="/">
<html>
<body>
<h1>Mitarbeiter-Datenbank</h1>
<ul>
<xsl:apply-templates/>
</ul>
</body>
</html>
</xsl:template>
<xsl:template match="mitarbeiter">
<li>
<xsl:apply-templates/>
</li>
</xsl:template>
<xsl:template match="telefon"/>
<xsl:template match="name"/>
</xsl:stylesheet>
Wohlgeformtheit
Eventuell überrascht? Die XSLT-Quelldatei ist selbst XML. Behalten Sie das im Hinterkopf, denn XSLT-Stylesheets müssen wohlgeformt sein, sonst funktionieren sie nicht. Validieren kann man XSLT nicht, wohl aber testen, z.B. mit Komodo.
Ansehen
Wenn Sie sich das Ergebnis der Transformation ansehen wollen, empfehlen wir Ihnen den Mozilla-Browser respektive aktuelle Netscape-Versionen. Er bietet die momentan beste, auch für Clients verfügbare XSLT-Implementation. Perfekt ist aber auch er nicht, manche Funktionen sind noch nicht eingebaut oder fehlerhaft.
Wenn Sie unserem Mozilla-Rat gefolgt sind, müssen Sie die zu transformierende XML-Datei einfach im Mozilla öffnen, die Transformation wird dann automatisch gestartet und das Ergebnis angezeigt - vorausgesetzt, sowohl XSLT-Einbindung als auch XSLT-Datei selbst sind in Ordnung. Hier hilft oft nur manuelles Überprüfen oder ein Tool wie der oben erwähnte Komodo.
Verstehen
Wie funktioniert unser kleines Beispiel? <xsl:template match="/">...</xsl:template> definiert eine Regel. Das match-Attribut legt fest, für welche Knoten die Regel greifen soll. Die erste Regel beispielsweise gilt für den Wurzel-Knoten (/), die zweite für Mitarbeiter-Tags. Die letzten beiden Regeln sind leer, um zu verhindern, dass der Name der Abteilung und die Telefonnummern der Mitarbeiter ausgegeben werden. Ansonsten würde der Prozessor sie gemäß der Standard-Regeln ausgeben, genauso, wie er es auch mit <nachname>-Tags tut.
Innerhalb der Regeln gibt es den Befehl <xsl:apply-templates/>. Er teilt dem Parser mit, eventuelle Unter-Knoten zu untersuchen.
Das match-Attribut...
unterstützt viele verschiedene Arten, anzugeben, für welche Knoten die Regel gelten soll oder nicht. Eine einfache Variante kennen Sie schon: man verwendet einfach den Element-Namen. Praktischerweise lassen sich auch Element-Hierarchien angeben. Folgendes sucht alle Mitarbeiter, die irgendeinem anderen Mitarbeiter untergeordnet sind, und gibt ihre Nachnamen aus:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:template match="/">
<html>
<body>
<h1>Mitarbeiter-Datenbank</h1>
<ul>
<xsl:apply-templates/>
</ul>
</body>
</html>
</xsl:template>
<xsl:template match="mitarbeiter">
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="telefon"/>
<xsl:template match="name"/>
<xsl:template match="angehoerige/mitarbeiter/nachname"/>
<xsl:template match="untergebene/mitarbeiter/nachname">
<li>
<xsl:apply-templates/>
</li>
</xsl:template>
</xsl:stylesheet>
Wie funktioniert dieser Code? Zunächst einmal wird von allen Mitarbeitern der Parser mit <xsl:apply-templates/> weiter nach unten geschickt. Dann stößt er irgendwann auf einen Nachnamen. Je nachdem, wo dieser Nachname steht, wird jetzt eine andere Regel angewandt: nur solche, die letztendlich von einem <untergebene>-Element abstammen, werden ausgegeben.
Vereinfachen ließe sich letztere Bedingung zu einem solchen Ausdruck:
<xsl:template match="untergebene//nachname">
Der doppelte Schrägstrich bedeutet im Gegensatz zum einfachen Schrägstrich nicht, dass das zweite Element ein direktes Kind vom ersten sein muss. Eine Nachfahren-Beziehung reicht hier aus. Oder, anders ausgedrückt: das erste Element muss in der Hierarchie irgendwo über dem zweiten stehen.
match II/XPath
XSLT bietet wesentlich weiter gehende Möglichkeiten, eine Regel-Bedingung zu definieren. Die dafür verwendete Sprache heißt XPath und ähnelt im Prinzip XPointer, die Sie aus dem letzten Kapitel kennen sollten.
Ausgehend vom Kontext-Knoten (dem Knoten, der gerade vom Parser bearbeitet wird), lässt sich hier eine Reihe relativer Ausdrücke aneinander fügen.
Aufbau
XPath-Ausdrücke sind aufgebaut nach dem Muster Achse::Knotentest[Prädikat]. Die Achse spezifiziert, wo nach möglichen Knoten gesucht wird: wer hier beispielsweise child angibt, sagt damit, dass nur direkte Nachfahren des Kontext-Knotens gefunden sollen. parent steht für den Eltern-Knoten, self bezieht sich auf den Kontext-Knoten selbst, following auf alle folgenden Knoten (nicht nur Kinder und Kindeskinder, sondern auch "Cousinen"). Schließlich preceding, das für alle vorangehenden Knoten steht, ancestor für direkte Vor- und descendant für Nachfahren, um nur eine Auswahl möglicher Optionen hier anzuführen. Wird die Achse weggelassen, gilt child als Standard. Auch der folgende Doppelpunkt muss dann weggelassen werden.
Knotentest
Wer nun z.B. following wählt, erhält erst einmal einen ganzen Knotensatz zurück. Um den weiter einzugrenzen, gibt es den Knotentest: following::mitarbeiter ergibt z.B. alle folgenden <mitarbeiter>-Elemente. following::text() liefert alle folgenden Text-Knoten zurück, und following::* steht für alle folgenden Element-Knoten.
Weitere Tests
Wer noch weitergehende Einschränkungen machen will, der verwendet den Prädikats-Zusatz. Hier lassen sich mehrere Boolesche Ausdrücke auswerten. Boolesche Ausdrücke kennen nur zwei Werte: wahr und falsch. Ergibt der Ausdruck ein "wahr", dann wird der Knoten verwertet, anderenfalls fällt er aus dem Raster.
Wer z.B. nur Element-Knoten finden will, die ein Attribut farbe mit dem Wert rot haben, schreibt Folgendes:
child::*[@farbe='rot']
Mehrere Bedingungen lassen sich zu einem logischen Oder verknüpfen, d.h. nur eine der Bedingungen muss erfüllt sein:
child::*[@farbe='rot' | @ausnahme='ja']
Auch Funktionen sind hier erlaubt. XSLT stellt z.B. die Funktion position() zur Verfügung, die die Position des aktuellen Knotens im gesamten gefundenen Knotensatz zurückgibt. Wer nur einen davon will, kann folgenden Ausdruck verwenden:
child::*[position()=1]
Die Kurzform davon ist child::*[1]. Im Zusammenspiel mit einer anderen Funktion kann man übrigens verhindern, dass der letzte Knoten aus dem Knoten-Satz übernommen wird: child::*[position()!=last()]. Ebenfalls im Beispiel: der Ungleich-Operator.
Wer es kompliziert mag, kann wiederum einen ganzen XPath-Ausdruck im Prädikat verstauen:
child::person[child::name] findet nur <person>-Elemente, die ein <name>-Element beinhalten.
Ausdrücke kombinieren
XPath-Ausdrücke lassen sich mit Slashes aneinanderfügen:
child::*[@farbe='rot']/child::zutat findet rot gefärbte Elemente, die eine Zutat enthalten.
Einschränkungen XSLT/XPath
XSLT akzeptiert im Zusammenspiel mit XPath leider nur zwei Achsen, wovon eine die child-Achse ist. Die andere, die attribute-Achse, enthält die Attribute des Kontext-Knotens. attribute::farbe findet z.B. das farbe-Attribut des Kontext-Knotens.
Wie Ihnen eventuell schon aufgefallen ist, sind auch die Einführungs-Beispiele (<xsl:template match="untergebene//nachname">) nichts anderes als XPath-Ausdrücke. untergebene z.B. wäre ausformuliert gleich child::untergebene, aber child:: ist ja Standard, sofern nichts anderes angegeben. Seltsam fällt lediglich auf, dass in der Kurzform der Trenn-Operator // akzeptiert wird, denn der ist eigentlich eine dritte Achse.
Regeln erstellen
Nachdem wir uns nun mit den verschiedenen Möglichkeiten auskennen, Regel-Bedingungen zu definieren, wenden wir uns nun den Regeln selbst zu. Es gibt einige nützliche Funktionen und Möglichkeiten, die Sie noch nicht kennen.
value-of
Das Tag xsl:value-of fügt einen bestimmten Wert ein, der mit dem select-Attribut festgelegt wird.
<xsl:value-of select="."> fügt den Inhalt des Kontext-Knotens ein. select akzeptiert aber nicht nur einen Punkt, sondern Ausdrücke im Allgemeinen. Ein "Ausdruck" kann viel sein: eine Zahl, eine Berechnung, ein boolescher Ausdruck, eine Zeichenkette oder sogar wieder ein eigener XPath.
<xsl:value-of select="3+8+9"/> z.B. fügt die Zahl 20 ein. Alle wichtigen mathematischen Operationen werden unterstützt.
Wenn Sie einen Lokalisierungspfad verwenden (z.B. <xsl:value-of select="mb-datenbank/abteilung/angehoerige/mitarbeiter/nachname"/>), wird der zurückgegebene Knotensatz in eine Zeichenkette umgewandelt. Das läuft darauf hinaus, dass der erste Text-Wert im Knotensatz angezeigt wird und die anderen verworfen werden.
Bedingungen
XSLT unterstützen bedingte Verzweigungen. Beispiel:
<xsl:template match="/">
<xsl:if test="1 = 2">
Eins ist gleich zwei!
</xsl:if>
<xsl:if test="1 != 2">
Eins ist nicht gleich zwei!
</xsl:if>
</xsl:template>
Das test-Attribut muss also einen Ausdruck enthalten, der entweder nach Wahr oder Falsch ausgewertet wird. Sie erinnern sich: Ausdrücke können so ziemlich alles enthalten. Zeichenketten sind wahr, sofern sie nicht leer sind. Zahlen sind wahr, sofern sie ungleich 0 sind. Knotensätze sind wahr, sofern sie Knoten enthalten.
Daneben gibt es noch die etwas herkömmlicheren Fälle, in denen vielleicht - wie im Beispiel - einfach zwei Werte verglichen werden. XSLT stellt alle wichtigen Vergleichsoperatoren (gleich =, größer >, kleiner <, größer-oder-gleich >=, kleiner-oder-gleich <=, ungleich !=) zur Verfügung, wobei nicht zwischen Zeichenketten- und Zahlenvergleichen unterschieden wird. Bitte beachten Sie, dass bei den Operatoren die öffnende spitze Klammer maskiert werden muss: <= anstelle von <=.
Besonders nützlich wird dieses Feature, wenn Sie z.B. in der Bedingung auf Attribut-Werte zurückgreifen.
Ganze Knotensätze verarbeiten
Mit Schleifen lassen sich ganze Knotensätze in einer Regel verarbeiten:
<xsl:template match="abteilung">
<xsl:for-each select="angehoerige//mitarbeiter">
<xsl:value-of select="position()"/>.
<xsl:value-of select="nachname"/><br/>
</xsl:for-each>
</xsl:template>+
Aus dem Ergebnis des select-Vorganges der for-each-Schleife wird ein neuer Kontext-Knotensatz generiert, auf den Sie dann innerhalb der Schleifen-Tags zugreifen können. Übrigens sehen Sie im Beispiel auch eine Technik, um Ausgaben durchzunumerieren.
Sortieren
Für unser Sortier-Beispiel haben wir die XML-Daten ein wenig verändert:
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- edited with XML Spy v4.4 U (http://www.xmlspy.com) by Alex Diltex (Nonetheless) -->
<?xml-stylesheet href="test.xsl" type="text/xsl"?>
<!DOCTYPE mb-datenbank SYSTEM "test.dtd">
<mb-datenbank>
<abteilung>
<name>
IT-Abteilung
</name>
<angehoerige>
<mitarbeiter>
<nachname>Zupul</nachname>
<telefon>6768</telefon>
</mitarbeiter>
<mitarbeiter>
<nachname>Meier</nachname>
<telefon>3421</telefon>
</mitarbeiter>
<mitarbeiter>
<nachname>Müller</nachname>
<telefon>5564</telefon>
</mitarbeiter>
</angehoerige>
</abteilung>
</mb-datenbank>
Wenn wir jetzt ein normales XSLT-Stylesheet aktivieren, um die Mitarbeiter-Namen auszugeben, erscheint Herr Zupul zuerst. Das gefällt uns nicht - wir hätten lieber eine alphabetische Ordnung. Dazu ändern wir die XSLT-Datei:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:template match="abteilung">
<xsl:apply-templates>
<xsl:sort select="nachname"/>
</xsl:apply-templates>
</xsl:template>
<xsl:template match="nachname">
<xsl:value-of select="."/><br/>
</xsl:template>
<xsl:template match="name"/>
<xsl:template match="telefon"/>
</xsl:stylesheet>
Wieso mussten wir die Daten-Datei ändern, um sortieren zu können? Mit der ursprünglichen Dokumenten-Struktur wären nur drei Mitarbeiter richtig sortiert worden. Indem wir aber auf eine for-each-Schleife zurückgreifen, können wir auch bei der alten Struktur bleiben:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:template match="mb-datenbank">
<xsl:for-each select="abteilung//mitarbeiter">
<xsl:sort select="nachname"/>
<xsl:value-of select="nachname"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
Text zeichengetreu einfügen
Normalerweise verändern XSLT Leerzeichen und Zeilenumbrüche. Um das zu verhindern, gibt es ein spezielles Tag:
<xsl:text disable-output-escaping="yes">
cout << "Ich bin ein toller Hengst!";
</xsl:text>
Wenn wie im Beispiel das Attribut disable-output-escaping auf yes gesetzt wird, kann sogar auf die Maskierung von Sonderzeichen verzichtet werden.
Fortgeschrittene Techniken
Die Basics beherrschen Sie nun. Um XSLT noch effizienter verwenden zu können, gibt es weitere Techniken und Möglichkeiten:
Attribute und Elemente erzeugen
Normalerweise erzeugen wir Elemente und Attribute, indem wir sie einfach in die Regel schreiben. Manchmal reicht dieses simple Verfahren aber vielleicht nicht aus, z.B. weil ein Attribut dynamisch erzeugt wird. Dann kann man ein solches Ausweich-Konstrukt verwenden:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:template match="/">
<html>
<body>
<h1>Mitarbeiter-Datenbank</h1>
<ul>
<xsl:apply-templates/>
</ul>
</body>
</html>
</xsl:template>
<xsl:template match="mitarbeiter">
<li>
<font>
<xsl:attribute name="color">
<xsl:if test="1 = 1">
red
</xsl:if>
</xsl:attribute>
<xsl:apply-templates select="nachname"/>
</font>
</li>
</xsl:template>
<xsl:template match="name"/>
<xsl:template match="telefon"/>
</xsl:stylesheet>
Für Elemente sieht es ähnlich aus. Diesmal erzeugen wir übrigens kein HTML, sondern ein neues XML-artiges Dokument:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:template match="/">
<db>
<xsl:apply-templates/>
</db>
</xsl:template>
<xsl:template match="mitarbeiter">
<xsl:element name="{nachname}">
<xsl:value-of select="telefon"/>
</xsl:element>
<xsl:apply-templates select="mitarbeiter"/>
</xsl:template>
<xsl:template match="name"/>
</xsl:stylesheet>
Das Ergebnis:
<db>
<Meier>3421</Meier>
<Müller>5564</Müller>
<Hinkelstein>3456</Hinkelstein>
</db>
Bitte achten Sie auf die geschwungenen Klammern um name-Attribut. Die brauchen Sie, weil Sie hier einen Ausdruck auswerten wollen.
Regeln manuell aufrufen
Wenn Sie programmieren, kennen Sie das Konzept der Subroutinen und Funktionen: ein Teil des Codes wird ausgelagert und dann von eventuell mehreren Punkten wieder aufgerufen. Das schafft Übersicht und Code, wenn ein Code-Stück mehrmals aufgerufen werden soll. Auch XSLT stellt so einen Mechanismus bereit:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:template match="/">
<xsl:call-template name="MeinTemplate"/>
</xsl:template>
<xsl:template name="MeinTemplate">
Hallo Template
</xsl:template>
</xsl:stylesheet>
Nach der call-template-Anweisung können Sie weitermachen wie gewohnt, also auch z.B. ein apply-templates starten.
Regeln mit Parametern
Dieses Konzept ist noch weiter ausbaubar: wie Subroutinen in Programmiersprachen können auch Vorlagenregeln Parameter annehmen und damit arbeiten. Soll heißen: das, was herauskommt, ändert sich, je nachdem, was man hereinsteckt ;-)
Hier ein Beispiel:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:template match="/">
<xsl:call-template name="addition">
<xsl:with-param name="S1">
3
</xsl:with-param>
<xsl:with-param name="S2">
8
</xsl:with-param>
</xsl:call-template>
</xsl:template>
<xsl:template name="addition">
<xsl:param name="S1"/>
<xsl:param name="S2"/>
<xsl:value-of select="$S1+$S2"/>
</xsl:template>
</xsl:stylesheet>
Eine Vorlagenregel, die zwei Zahlen addiert und zurückgibt - wie originell ;-)
Wenn Sie Parameter verwenden wollen, müssen Sie diese in der entsprechenden Vorlagenregel - der, die damit arbeiten soll - deklarieren: <xsl:param name="S1"/>. Wenn Sie wollen, können Sie auch einen Standard-Wert als Element-Inhalt angeben, falls der Parameter nicht von der aufrufenden Regel mitgeschickt werden sollte. Danach können Sie mit dem Parameter arbeiten, indem Sie ein Dollarzeichen voranstellen - allerdings nur innerhalb eines Ausdrucks, also z.B. bei value-of. Vergessen Sie auch hier nicht die geschweiften Klammern, wenn Sie die Parameter in einem zum Ergebnis-Baum gehörenden Attribut verwenden.
Um eine Regel mit Parameter zu übergeben, verwenden Sie <xsl:with-param> innerhalb von <xsl:call-template>.
Konstanten
Konstanten ähneln Parametern: sie sind genauso mit Hilfe des Dollar-Zeichens ansprechbar. Im Gegensatz zu Parametern kann man auf sie jedoch vom gesamten XSLT-Stylesheet aus zugreifen. Einmal gesetzt, sind sie nicht mehr änderbar:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:variable name="FirmenName">ExxoTron</xsl:variable>
<xsl:template match="/">
<xsl:value-of select="$FirmenName"/>
</xsl:template>
</xsl:stylesheet>
Spezielle Modi
Oft werden mit XSLT erzeugte Ergebnisse später von anderen Programmen weiterverarbeitet. Aber was, wenn dieses andere Programm nur HTML versteht und deshalb Probleme mit <br/> hat? In Ihren XSLT-Vorlagen sind Sie gezwungen, die korrekte XML-Form zu verwenden, weil sonst das Stylesheet nicht mehr wohlgeformt ist.
Die Lösung: verwenden Sie die Anweisung <xsl:output method="html"/>. Der verarbeitende XSLT-Prozessor wird dann - so weit es ihm möglich ist - die Daten in ein HTML-kompatibles Ausgabeformat bringen. Konkret bedeutet das hauptsächlich, dass der abschließende Slash vor der schließenden spitzen Klammer bei Elementen ohne Inhalt entfernt wird.
Wenn Sie dagegen ein ganz anderes Format erzeugen wollen, verwenden Sie <xsl:output method="text"/>. Der Prozessor wird dann nur die Text-Daten des Ergebnis-Baums, nicht aber die zugehörigen Tags ausgeben.
Andere Dateien importieren
Vielleicht wollen Sie ja aus irgendeinem Grund Ihre XSLT-Stylesheets auf mehrere Dateien aufteilen. Dafür gibt es zwei Methoden: Importieren und Inklusion. "Inklusion" bedeutet, dass die Daten der fremden Datei so behandelt werden, als hätten sie von Anfang an in der Haupt-Datei gestanden. Wenn jedoch eine Datei importiert wird, dann wird der Prozessor den Regeln der Haupt-Datei eine höhere Priorität geben als den neu hinzugekommenen. Das gibt Ihnen eine etwas bessere Kontrolle über das, was zur Transformation verwendet wird.
Wenn Sie erzwingen wollen, dass importierte Regeln verwendet werden, ersetzen Sie an den entsprechenden Stellen <xsl:apply-templates/> durch das ansonsten völlig gleiche <xsl:apply-imports/>.
Inklusion(darf überall platziert werden):
<xsl:include href="datei.xsl"/>
Import(muss vor allen anderen Regeln und Anweisungen stehen):
<xsl:include href="datei.xsl"/>
Fazit
Wenn Sie bisher alles verstanden haben, kann Ihnen nichts mehr passieren. Sie sind bereit, XSLT - und auch XML, denn das Tutorial endet hier - sicher anzuwenden und anspruchsvolle Anwendungen zu entwerfen. Wenn Sie tiefergehende Informationen zu einzelnen Bereichen suchen, können wir Ihnen entweder ein gutes Buch (z.B. Einführung in XML) oder die XML-Homepage des W3C empfehlen. Auch XML.com ist eine empfehlenswerte Ressource.
|
|
|
|
Sie wollen diese Seite ausdrucken? Dafür haben wir eine spezielle Druckversion ohne grafische Elemente entwickelt! |
|
|
Einführung in CSS bei HTMLWorld.
|
|
