Werbung einblenden Werbung ausblenden


Home / Tutorials / PHP Handbuch / XML XSL PHP


Was ist XML
Auslesen eines XML Dokumentes mit XSL
Ausführen eines XSL Stylesheets
Nur manche Knoten zeigen
HTML Tags über ein XSL Stylesheet generieren lassen
XML Dokumente direkt im Browser zeigen

Was ist XML ?

XML erlaubt es, die hierarschische Struktur von Daten in beliebiger Präzision darzustellen. Allerdings macht XML weder eine Aussage darüber wie die Daten dargestellt werden noch auf welchem Medium. Somit ist klar, dass XML mit HTML praktisch nichts zu tun hat. Bei HTML geht es fast ausschliesslich um die Darstellung von Daten im Web. Bei HTML geht es primär um die Darstellung von Daten. Bei XML spielt das überhaupt keine Rolle. XML erlaubt es lediglich, Daten in einer hierarchischen Struktur, einer Baumstruktur, darzustellen. Um XML Dokumente dann tatsächlich darzustellen und die Gestaltung der Daten zu beeinflussen bedarf es einer weiteren Programmiersprache. Die Mächtigste davon ist wohl XSL. Zu den verschiedenen Anätzen XML Dokumente auszulesen werden wir in Kürze ein Handbuch schreiben. Hier wird nur das beschrieben, was man braucht, um das folgende Kapitel, XML/XSL und Sablotron zu verstehen. Das XML Dokument, auf dem alle Beispiel aufsetzen, sieht so aus.

<?xml version="1.0" encoding="iso-8859-1" ?>
<waren>
<nahrungsmittel>
<Milchprodukte>
<kaese>
<preis was="kilo">12</preis>
<währung>€</währung>
<herkunftsland genau="Amsterdam">Holland</herkunftsland>
<name>Gouda</name>
</kaese>
<kaese>
<preis was="kilo">23</preis>
<währung>€</währung>
<herkunftsland genau="Biel">Schweiz</herkunftsland>
<name>Emmentaler</name>
</kaese>
<yoghurt>
<preis was="kilo">1.20</preis>
<währung>€</währung>
<herkunftsland genau="Florenz">Italien</herkunftsland>
<name>Bioghurt, Geschmack, Kaffee</name>
</yoghurt>
</Milchprodukte>
<Fleischwaren>
<Wurst>
<preis was="gramm">2.44</preis>
<währung>€</währung>
<herkunftsland genau="Thüringen">Deutschland<sprache>Deutsch</sprache></herkunftsland>
<name>Thüringer Rostbratwurst</name>
</Wurst>
<Wurst>
<preis was="gramm">3.40</preis>
<währung>€</währung>
<herkunftsland genau="Freiburg">Deutschland</herkunftsland>
<name>alemanischer Leberkaes</name>
</Wurst>
</Fleischwaren>
</nahrungsmittel>
<kosmetik>
<duft>
<parfüm>
<name>Ives Saint Laurent</name>
<preis>230</preis>
<währung>€</währung>
</parfüm>
<parfüm>
<name>Le Rocher</name>
<herkunftsland genau="Biel">Schweiz</herkunftsland>
<preis>230</preis>
<währung>€</währung>
</parfüm>
</duft>
</kosmetik>
</waren>


Wir sehen, dass dieses Dokument eine Baumstruktur hat, die so aussieht.

Die Struktur des XML Dokuments ist damit selbsterklärend. Mit der Zeile

<?xml version="1.0" encoding="iso-8859-1" ?>

teilen wir dem verarbeitenden Programm, Browser, saxon, sablotron etc. mit, welche XML Version wir verwenden. Weiter geben wir den Zeichensatz an, den wir verwenden. Das ist wichtig, weil sonst unter Umständen z.B. deutsche Umlaute nicht dargestellt werden. Als nächstes kommt das sogenannten Wurzelelement waren. Es steht am Anfang der Hierarchie und umfasst alle anderen Tags. Anschliessend werden die Blöcke definiert, Nahrungsmittel und Kosmetik, die selber wieder aufgeteilt sind in Blöcke. Jeder Block wird von einem öffnenden und einem schliessenden Tag umklammert. Tags können, wie in HTML auch, Attribute haben. Wir haben dies zum Beispiel bei den Wurstwaren, von der Tag Preis das Attribut Gramm hat. Der Name der Tags kann freigewählt werden, allerdings, grosser Unterschied zu HTML, die Tags sind case sensitiv, es ist also falsch, einen Block mit

<Kaese>


zu öffnen und mit

</kaese>

zu schliessen. Weiter müssen die Blöcke
korrekt verschachtelt sein, der innere Block muss also immer vor dem äusseren Block geschlossen werden. Weiter gibt es in XML keine Tags, die keinen schliessenden Tags haben wie etwa <pre>, <br>,
<img src=tralala.jpg>
. Für das oben gezeigte xml-Dokument wird im Interent Explorer die Struktut angezeigt: zeigen Kommen wir zum eigentlich spannenden Teil. Wie liest man XML Dokumente aus.

Auslesen eines XML Dokumentes mit XSL

Installation saxon

Das erste was wir brauchen, ist eine Software, die XSL versteht. Hier stehen uns im wesentlichen drei Pakete zur Verfügung. Zum einen Sablotron, den werden wir verwenden, wenn wir tatsächlich über PHP XML Dokumente auslesen, siehe XML / XSL Sablotron. Weiter, wenn wir uns die Dokumente direkt im Browser anschauen wollen, könnten wir auch msxml von Microsoft verwenden. Das werden wir nachher kurz tun. Für den Einstieg ist aber die einfachste Variante es mit Saxon zu machen, den wir hier downloaden können. Wir packen die Datei saxon.exe in einen Ordner, den wir vorher eingerichtet haben, z.B. xmltest. Dann sind wir startklar und es kann losgehen.

Ausführen eines XSL Stylesheets

Im gleichen Ordner, in den die Datei saxon.exe abgelegt wurde, speichern wie auch oben stehendes XML Dokument unter dem Namen nahrung.xml. Es ist günstig, es so zu machen, da im folgenden immer davon davon ausgegangen wird, dass die Datei so heisst. Unser erstes XSL Stylesheet hat folgendes Aussehen.

<?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:value-of select="."/>hallo
</xsl:template>
</xsl:stylesheet>


Bevor wir besprechen, wie es funktionniert, lösen wir es erstmal aus. Wir fahren mit der Dos Box oder der Eingabeaufforderung in den Ordner, wo die drei Dateien sind, also saxon.exe, die XML Datei und das obige XSL Stylesheet.
Dann geben wir ein saxon name_der_xml_datei.xml name_der_xsl_datei.xsl

Wir sehen dann, dass alle Knoten des Dokuments auf dem Schirm erscheinen. Zur Verdeutlichung zeigen wir einen Ausschnitt
... weitere Daten.....

Bioghurt, Geschmack, Kaffe
2.44

DeutschlandDeutsch
Thüringer Rostbratwurst
3.40

Deutschland
alemanischer Leberkaes
Ives Saint Laurent
230

Le Rocher
Schweiz
230

hallo

Aus Gründen der besseren Lesbarkeit, wurden die Sonderzeichen wieder eingesetzt. Bei einer Auswertung im Browser, was wir eigentlich wollen, entsteht dieses Problem nicht. Die Frage, die sich jetzt stellt, ist wieso wir alle Datensätze sehen. Die Erklärung hierfür ist einfach. Mit

<xsl:template match="/">
</xsl:template>

legen wir fest, für welchen Knoten wir das Template definieren. Hierbei steht der Slash für den Wurzelknoten, den es nur einmal gibt. Ein template wird aber so oft aufgerufen, wie es den dazugehörigen Knoten gibt. Beispielsweise würde das Template

<XSL:TEMPLATE MATCH="waren/Nahrungsmittel/Milchprodukte/kaese">
</XSL:TEMPLATE>

zweimal aufgerufen, da es zwei Knoten gibt, die kaese heissen (

<kaese>Inhalt</kaese>

gibt es zweimal). Wir stellen also fest, ein Template wird so oft aufgerufen, wie es den entsprechenden Knoten gibt. Das wäre nun noch lange kein Grund, alle Knoten zu zeigen, was ja tatsächlich passiert. Auch dies läßt sich aber erklären. Innerhalb eines Templates wird definiert, was passieren soll, wenn der entsprechende Knoten aufgerufen wird. Wir definieren in dem Beispiel oben mit

<XSL:VALUE-OF SELECT="."/>hallo

dass er den Knoten zeigen soll, in dem er sich aktuell befindet. Der default ist nun aber nicht, dass ein Knoten, der nicht explizit aufgerufen wird, nicht erscheint, sondern genau umgekehrt. Auch ein Knoten, der nicht expressis verbis aufgerufen wird erscheint. Will man, dass er nicht erscheint, so muss man das angeben. Da wir aber keine Knoten ausschliessen, erscheinen alle. Das hallo dient hier didaktischen Zwecken. Wie deutlich zu sehen, erscheint hallo nur einmal, weil das Template ja auch nur einmal aufgerufen wird, da es den Wurzelknoten nur einmal gibt. Anders herum ausgedrückt, eine solche Definition eines Templates nützt uns in der Regel gar nichts. In der Regel wollen wir jeden Knoten einzeln erwischen, z.B. weil wir ihn einbetten wollen in einen HTML Tag. Genau das ist aber mit der Konstruktion oben nicht möglich, weil wir alle Knoten en bloque haben, das heisst, auf einen einzelnen Knoten können wir so nicht zugreifen.

Nur manche Knoten zeigen

Nehmen wir mal an, wie wollen uns nur die kaesesorten anzeigen lassen. Das können wir mit diesem Stylesheet tun.

<?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:apply-templates select="waren/nahrungsmittel/Milchprodukte/kaese/name"/>
</xsl:template>
<xsl:template match="name">
<xsl:value-of select="."/>hallo
</xsl:template>
</xsl:stylesheet>

Man beachte, dass XSL Dokumente selber XML Dokumente sind und folglich deren Ansprüche an Wohlgeformtheit entsprechen müssen. Das heisst, dass alle Tag einen schliessenden Tag haben müssen, habe sie das nicht, muss der Tag mit einem Slash am Ende besonders gekennzeichnet werden. Weiter dürfen innerhalb von einer xsl:template-match-Definition nicht weitere xsl:template match Definitionen stehen. Der Aufruf eines Templates aus einem Template heraus erfolgt also mit

<XSL:TEMPLATE MATCH="/">
<XSL:APPLY-TEMPLATES SELECT="waren/nahrungsmittel/Milchprodukte/kaese/name"/>


Wenn man sehen will, was dieses XSL Stylesheet macht, ist es wieder unter dem Namen irgendein_name.xsl im selben Ordner abzulegen, wo auch die Datei
nahrung.xml und die saxon.exe liegt. Der Aufruf ist dann wieder wie oben. Man muss sich in dem Ordner befinden, wo die Dateien liegen.


saxon nahrung.xml irgendein_name.xsl

Das Ergebnis sieht dann so aus.

C:\saxon2\test3>saxon nahrung.xml n_manche_zeigen1.xsl
<?XML VERSION="1.0" ENCODING="utf-8"?>
Goudahallo
Emmentalerhallo

C:\saxon2\test3>

Wir erhalten das, was wir wollen, und wir haben auch Zugriff auf jeden einzelnen Knoten isoliert. Wir sehen, dass das Template zweimal aufgerufen wurde, den wir erhalten zweimal hallo, einmal für jeden Aufruf. Die Knoten, die wir nicht sehen wollen, erscheinen nicht. Wie haben wir das gemacht ? Zuerst haben wir wieder das Wurzelelement aufgerufen. Im Gegensatz zum vorherigen Beispiel, haben wir jetzt aber verhindert, dass alle Knoten angezeigt werden, indem wir einen Knoten der letzten Hierarchiestufe aufrufen und damit alle anderen Hierarchiestufen ausschalten. Ein Template für den Knoten den wir tatsächlich sehen wollen rufen wir auf mit

<XSL:APPLY-TEMPLATES SELECT="Pfad_zu_dem_Knoten_den_wir_sehen_wollen"/>

Dieses Templates müssen wir dann anschliessend definieren, was im Beispiel oben ja auch tatsächlich passiert. Es macht wahrscheinlich Sinn, anhand eines anderen Beispiels sich die Zusammenhänge nochmals zu verdeutlichen.

<?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:apply-templates select="waren/nahrungsmittel/Milchprodukte"/>
</xsl:template>
<xsl:template match="Milchprodukte">
<xsl:value-of select="."/>Hallo
</xsl:template>
</xsl:stylesheet>


Bei diesem Beispiel sind wir durchmaschiert bis auf die Hierarchiestufe Milchprodukte, das heisst, die Schwestern Knoten, die auf der selben Hierarchiestufe liegen, wurden ausgeblendet. Allerdings gibt es nur einen Knoten Milchprodukte (

<Milchprodukte>Inhalt</Milchprodukte>

). Folglich erscheint auch nur einmal Hallo, da das Template nur einmal aufgerufen wird. Alle Knoten unter Milchprodukte erscheinen en bloque.

Das Ergebnis sieht so aus:


C:\saxon2\test3>saxon nahrung.xml n_manche_zeigen1.xsl
<?XML VERSION="1.0" ENCODING="utf-8"?>
12

Holland
Gouda
23

Schweiz
Emmentaler
1.20

Italien
Bioghurt, Geschmack, Kaffe
Hallo
C:\saxon2\test3>


Zur Illustrierung noch ein letztes Beispiel, das Zeigt, dass Knoten, die nicht definiert werden, gezeigt werden:

<?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="/waren/nahrungsmittel/Milchprodukte/kaese">
hallo
</xsl:template>
</xsl:stylesheet>

Auch bei diesem Beispiel ist für den Knoten waren/nahrungsmittel/Milchprodukte/kaese ein Template definiert. Von der Sorte kaese gibt es zwei Knoten, folglich sagt dieser Stylesheet zweimal hallo. Für alle anderen Knoten allerdings ist kein Template definiert. Dies hat zur Folge,dass sie aufgeblendet werden. Wenn man das nicht will, müsste man ein Template für den Wurzelknoten definieren und innerhalb dieses Templates dann obiges Templates aufrufen. Mit der bis jetzt vorgestellten Syntax wäre es umständlich, Knoten auf der selben Hierachiestufe zu erfassen. Wenn man z.B. alle Namen der Milchprodukte sehen will, müsste man bei diesem Ansatz zwei Templates definieren, eines für den kaese und eines für den Yoghurt. Das kann man tun. Es würde dann so aussehen.

<?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:APPLY-TEMPLATES SELECT="waren/nahrungsmittel/Milchprodukte/kaese/name"/>
<XSL:APPLY-TEMPLATES SELECT="waren/nahrungsmittel/Milchprodukte/Yoghurt/name"/>
</XSL:TEMPLATE>
<XSL:TEMPLATE MATCH="name">
<XSL:VALUE-OF SELECT="."/>Hallo
</XSL:TEMPLATE>
</XSL:STYLESHEET>


Das Ergebnis sieht dann so aus:

C:\saxon2\test3>saxon nahrung.xml n_manche_zeigen3.xsl
<?XML VERSION="1.0" ENCODING="utf-8"?>GoudaHallo
EmmentalerHallo
Bioghurt, Geschmack, KaffeHallo
Thüringer RostbratwurstHallo
alemanischer LeberkaesHallo
C:\saxon2\test3>

Wird das zugrunde liegende XML Dokument komplexer, ist das kein gangbarer Weg mehr. Mit dieser Schreibweise lassen sich Knoten auf der selben
Hierarchiestufe auf einen Schlag erfassen.


<?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:APPLY-TEMPLATES SELECT="waren/nahrungsmittel/child::*/child::*/name"/>
</XSL:TEMPLATE>
<XSL:TEMPLATE MATCH="name">
<XSL:VALUE-OF SELECT="."/>Hallo
</XSL:TEMPLATE>
</XSL:STYLESHEET>

Mit dieser Syntax erfassen wir alle Schwesternknoten (Knoten auf derselben Hierarchiestufe), die unterhalb von nahrungsmittel liegen, also kaese und Wurst und
alle Schwesternknoten die wiederum unterhalb von kaese bzw. Wurst liegen und von denen allen zusammen wiederum den Knoten name. Weiter erfassen wir
jeden Knoten einzeln, das heisst es wäre ein Leichtes, jeden Knoten in HTML Tags einzubinden.

HTML Tags über ein XSL Stylesheet generieren lassen

Für XSL interessiert man sich in der Internetprogrammierung vor allem deshalb, weil man sich mit XSL XML Dokumente in HTML Dokumente transformieren lassen.
Wir haben gesehen, dass das nur gelingt, wenn auf die Knoten, die man in HTML Tags einbinden will, isoliert zugegriffen werden kann. Im folgenden nun ein Beispiel,
das zeigt, wie eine XML Datei in eine HTML Datei transformiert wird. Wer das Beispiel nachvollziehen will, sollte dieses XML Dokument
in den Ordner legen, wo sich auch die Datei saxon.exe befindet.


<?xml version="1.0" encoding="iso-8859-1" ?>
<buecher>
<buch>
<title lagerbestand="500">Der Mann ohne Eigenschaften</title>
<autor>Robert Musil</autor>
<erscheinungsjahr>1922</erscheinungsjahr>
</buch>
<buch>
<autor>Thomas Mann</autor>
<erscheinungsjahr>1917</erscheinungsjahr>
<title lagerbestand="300">Der Zauberberg</title>
</buch>
<buch>
<title lagerbestand="400">Die Stadt und die Hunde</title>
<autor>Mario Vargas Llosa</autor>
<erscheinungsjahr>1988</erscheinungsjahr>
</buch>
</buecher>

Mit diesem XSL Stylesheet können wir diese Datei in ein HTML Dokument konvertieren.

<?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><head><title>Test></title></head><body>
<xsl:apply-templates select="buecher/buch"/>
</body></html>
</xsl:template>
<xsl:template match="buch">
<table width="500">
<xsl:apply-templates select="title"/>
<xsl:apply-templates select="autor"/>
<xsl:apply-templates select="erscheinungsjahr"/>
</table>
</xsl:template>

<xsl:template match="title">
<tr><td bgcolor="yellow"><xsl:value-of select="."/></td></tr>
</xsl:template>

<xsl:template match="autor">
<tr><td bgcolor="green"><xsl:value-of select="."/></td></tr>
</xsl:template>

<xsl:template match="erscheinungsjahr">
<tr><td><xsl:value-of select="."/></td></tr>
<tr><td><hr/></td></tr>
</xsl:template>
</xsl:stylesheet>


Aus Gründen der Übersichtlichkeit und damit wir diese transformierte Datei anschliessend auch gleich im Browser betrachten können lassen wir sie
auf die Festplatte drucken. Um dies zu erreichen, müssen wir die Art der Übergabe der XML Datei und der XSL Datei an den saxon Interpreter etwas
modifizieren.

Der Aufruf sieht dann so aus.

C:\saxon\>saxon irgendeiname_fuer_die_XML_Datei.xml irgendein_Name_fuer_die_XSL_Datei.xsl>name_der_transformierten_Datei.htm

Das Ergebnis dieser Transformation, oder genauer, der HTML Quelltext der Datei name_der_transformierten_Datei.htm, die sich im gleichen Ordner
eingerichtet wird, wie die Dateien, die sie generieren, sieht dann so aus.


<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Test&gt;</title>
</head>
<body>
<table width="500">
<tr><td bgcolor="yellow">Der Mann ohne Eigenschaften</td></tr>
<tr><td bgcolor="green">Robert Musil</td></tr>
<tr><td>1922</td></tr>
<tr><td><hr></td></tr>
</table>
<table width="500">
<tr><td bgcolor="yellow">Der Zauberberg</td></tr>
<tr><td bgcolor="green">Thomas Mann</td></tr>
<tr><td>1917</td></tr>
<tr><td><hr></td></tr>
</table>
<table width="500">
<tr><td bgcolor="yellow">Die Stadt und die Hunde</td></tr>
<tr><td bgcolor="green">Mario Vargas Llosa</td></tr>
<tr><td>1988</td></tr>
<tr><td><hr></td></tr>
</table>
</body>
</html>

Was im Browser so wiedergegeben wird: zeigen.
Wie wir sehen, handelt es sich um ein perfektes HTML Dokument. Der XSL Stylesheet ist schnell erklärt. Das erste Template, das aufgerufen wird, definiert das Wurzelelement. Dieses wird nur einmal ausgeführt. In diesem definieren wir die Bestandteile der HTML Seite, die einmalig sind und das gesamte HTML Dokument umklammern. Innerhalb der HTML Tags


<html><head><title>Test></title></head><body

und

</body></html>


rufen wir wieder ein Template auf, nämlich das Template, dass die HTML Tags definiert, die jedes einzelne Buch umklammern. Da wir wollen, dass jedes Buch innerhalb eines tables erscheint schreiben wir

<table>


und

</table>
.

Innerhalb dieser Tags rufen wir dann die templates auf, die festlegen von welchen Tags die Werte titel, autor, erscheinungsjahr umklammert werden. Das wars dann.

XML Dokumente direkt im Browser zeigen

Unser Ziel ist es, XML Dokumente über ein XSL Stylesheet zu tranformieren und es direkt im Browser aufzurufen. Wir wollen dies schluss endlich mit PHP realisieren. Die eigentliche Transformation wird hierbei die ab PHP 4.2.2 mitgelieferte Sablotron Extension realisieren. Es gäbe aber noch einen Weg, ein XML Dokument über ein XSL Stylesheet zu tranformieren und es direkt im Browser anzeigen zu lassen. Möglich wäre dies auch durch den XSL Interpreter von Microsoft msxml, den man hier downloaden kann. Man installiert ihn, indem man einen Doppelclick auf die Datei macht und dann mit next, yes, ok, weiter alles bestätigt. Um die transformierte HTML Datei dann im Browser anzeigen zu lassen muss lediglich das XSL Stylesheet, das die Transformation durchführt in die XML Datei eingebunden werden.
Das sieht dann so aus.

<?xml version="1.0" encoding="iso-8859-1" ?>
<?xml-stylesheet href="direkt_in_Browser.xsl" type="text/xsl"?>
<buecher>
<buch>
<title lagerbestand="500">Der Mann ohne Eigenschaften</title>
<autor>Robert Musil</autor>
<erscheinungsjahr>1922</erscheinungsjahr>
</buch>
<buch>
<autor>Thomas Mann</autor>
<erscheinungsjahr>1917</erscheinungsjahr>
<title lagerbestand="300">Der Zauberberg</title>
</buch>
<buch>
<title lagerbestand="400">Die Stadt und die Hunde</title>
<autor>Mario Vargas Llosa</autor>
<erscheinungsjahr>1988</erscheinungsjahr>
</buch>
</buecher>

Nachdem wir den Mircrosoft XSL Parser installiert haben und die XML Datei wie oben modifiziert haben, also die Zeile

<?XML-STYLESHEET HREF="direkt_in_Browser.xsl" TYPE="text/xsl"?>

hinzugefügt haben, müssen wir noch noch beide Dateien also die XML Seite und das XSL Stylesheet direkt_in_Browser.xsl in der document root des http Servers ablegen. Anschliessend können wir die Datei über http://127.0.0.1/name_der_xml_datei.xml aufrufen. Wir sehen dann das gleiche Dokument sofort im Browser, dass wir oben auf die Festplatte gedruckt haben.
Der ganze Umfang von XSL wurde hier natürlich nicht dargestellt. Es sollte aber reichen, um das im Kapitel XML / XSL Sablotron Beschriebene zu verstehen. Denn unser Thema ist, wie transformiert man XML Dokumente mit PHP.

vorhergehendes Kapitel