N.raebiger: Die Seite wurde neu angelegt: „In diesem Abschnitt beschreibe ich die wichtigsten Befehle in einem XSLT-Stylesheet. Um sich selbst ein Stylesheet zu erstellen, ist es sinnvoll, die Struktur…“

2016-09-06T13:53:38Z

Die Seite wurde neu angelegt: „In diesem Abschnitt beschreibe ich die wichtigsten Befehle in einem XSLT-Stylesheet. Um sich selbst ein Stylesheet zu erstellen, ist es sinnvoll, die Struktur…“

Neue Seite

In diesem Abschnitt beschreibe ich die wichtigsten Befehle in einem XSLT-Stylesheet. Um sich selbst ein Stylesheet zu erstellen, ist es sinnvoll, die Struktur der [[Kiribati-XML-Export |XML-Datei aus Kiribati]] zu verstehen.

== Grundgerüst des Stylesheets ==
Eingeleitet wird ein XSLT-Stylesheet durch

=== Version 1.0 ===
<pre>
<?xml version="1.0" encoding="UTF-8"?>

<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">

<xsl:output method="xml" version="1.0" encoding="UTF-8" standalone="yes" indent="yes"/>
</pre>

=== Version 2.0 ===
<pre>
<?xml version="1.0" encoding="UTF-8"?>

<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fn="http://www.w3.org/2005/xpath-functions"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
version="2.0">

<xsl:output method="xml" version="1.0" encoding="UTF-8" standalone="yes" indent="yes"/>
</pre>

Der Unterschied besteht in der Versionsmitteilung <code>1.0</code> oder <code>2.0</code> und den aufgeführten Namensräumen (Namespaces xmlns:fn und xmlns:xs - diese werden von der Version 1.0 nicht zur Verfügung gestellt).

Die <code>xsl:output</code> Anweisung weist den Compiler an, eine neue XML-Datei zu erstellen.

Als nächstes wird in beiden Versionen das Template erstellt. Dies geschieht durch:

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

Der Matchparameter gibt an, auf welches Element das Template bezogen wird <code>match="/"</code> gibt an, dass das Template für die gesamte Datei gilt.

Abgeschlossen wird das Stylesheet noch durch das schließende Tag

<pre>
</xsl:stylesheet>
</pre>

== XSLT-Befehle ==
Eine XML-Datei zeichnet sich durch einen strukturierten Inhalt aus. Die Struktur wird mit sogenannten Tags dargestellt. XML selbst steht für Extensible Markup-Language, also eine erweiterbare Beschreibung der Struktur. Ein Tag besteht aus einem öffnenden und einem schließenden Element: <code><element>INHALT</element></code>. Ist der Inhalt leer, wird das öffnende Tag als <code><element /></code> geschrieben. '''element''' ist ein freiwählbarer Text aus Buchstaben, Ziffern und dem Unterstrich.

Auch ein XSLT-Stylesheet wird durch Tags beschrieben, die wie in einer XML-Datei aufgebaut sind. Den einzelnen Befehlen wird allerdings ein Namensraum vorangestellt: '''xsl:'''. Die hier beschriebenen Tags sind eine Auswahl, die für die Verarbeitung einer XML-Datei aus Kiribati zur Vorbereitung des Imports in InDesign hilfreich sein können. Weitere Tags und detailierte Beschreibungen können leicht über eine Suchmaschine gefunden werden (z. B. [http://www.w3schools.com/xsl]). Die Anweisungen zur Verarbeitung der XML-Datei werden zwischen <code><xsl:template match="/">...</xsl:template></code> geschrieben.

=== Element erstellen ===
Möchte man ein neues Feld erstellen, teilt man dies dem Stylesheet durch das Tag <code><xsl:element name="'''Bezeichnung'''"></code> mit. Zwischen das öffnende und das schließende Tag wird dann der Inhalt gestellt. Der Inhalt kann entweder ein statischer Text sein, oder durch das Stylesheet berechnet werden.

<code><xsl:element name="Bezeichnung">Statischer Text</xsl:element></code>

; <code><xsl:element name="veranstaltungen">...</xsl:element></code>
: Damit wird ein umschließenden Tag um alle aufgeführten Veranstaltungen erstellt. Gleiches ist in der Ausgangsdatei zu finden. Dieses Tag wird als Root-Tag bezeichnet. In InDesign wird dieses Element dann in das Textfeld gezogen.

=== Mehrere gleiche Elemente behandeln ===
In der Ausgangsdatei sind die Daten der einzelnen Veranstaltungen jeweils zwischen <code><veranstaltung>...</veranstaltung></code> enthalten. Die einzelnen Veranstaltungen müssen nun auch einzeln behandelt werden. In einem XSLT-Stylesheet wird dies in einer '''fore-each'''-Schleife erledigt (für alle Elemente eines Pfades - in unserem Fall veranstaltungen/veranstaltung).

<code><xsl:fore-each select="Pfad">...</xsl:fore-each></code>

; <code><xsl:fore-each select"veranstaltungen/veranstaltung">...</xsl:fore-each></code>
: Durch diese Anweisung wird die Schleife so oft durchlaufen, bis alle Veranstaltungen in der XML-Datei bearbeitet wurden.
'''Anmerkung''': Innerhalb der Schleife muss dann noch ein <code><xsl:element name="veranstaltung">...</xsl:element></code> aufgenommen werden, damit in der Ausgabedatei jede Veranstaltung auch wieder in einem eigenen Pfad enthalten ist.

=== Element aus der Ausgangsdatei kopieren ===
Möchte man ein Element komplett übernehmen, kann man dies ganz einfach durch die Anweisung <code><xsl:copy-of select="Bezeichnung" /></code> erledigen. Damit wird das Element inklusive der umschließenden Tags in die Ausgabedatei kopiert.

; <code><xsl:copy-of select="ver_titel1" /></code>
: Kopiert das Feld <code>ver_titel1</code> in die Ausgabedatei.

=== Nur den Wert eines Elements übernehmen ===
Im Gegensatz zu <code>copy-of</code> kann man mit <code>value-of</code> auf den Wert eines Elements zugreifen. Dadurch kann man z. B. mehrere Elemente zusammenfassen, den Wert in einer Variablen zwischenspeichern oder mit Funktionen (Version 2.0) bearbeiten. Der Wert wird ohne die umschließenden Tags übernommen.

<code><xsl:value-of select="Bezeichnung" /></code>

; <code><xsl:element name="art_nummer"><xsl:value-of select="ver_art" /> - <xsl:value-of select="ver_nummer" /></xsl:element></code>
: Durch diesen Anweisungsblock wird ein neues Element in der Ausgabedatei mit dem Namen <code>art_nummer</code> erstellt. Die Werte der Felder <code>ver_art</code> und <code>ver_nummer</code> werden ausgelesen und zwischen das neue umschließende Element geschrieben. Zwischen den beiden Werten wird ein Gedankenstrich platziert.

=== Bedingte Ausführung von Anweisungen ===
Damit Elemente in der Ausgabedatei in Abhängigkeit von bestimmten Werten in der Ausgangsdatei erstellt werden, kann mit Bedingungen gearbeitet werden. XSLT kennt zwei unterschiedliche Anweisungen für eine bedingte Ausführung.

==== einfache Bedingung ====
Die einfache Bedingung kennt nur einen Zweig, der ausgeführt wird, wenn ein Test positiv ist: <code><xsl:if test="'''Bedingung'''">...</xsl:if></code>. '''Bedingung''' steht dabei für einen logischen Ausdruck, z. B. einen Vergleich. Damit zwei Werte verglichen werden können, benötigt man unterschiedliche [http://www.w3schools.com/xsl/xpath_operators.asp Operatoren].

; <code><xsl:if test="ver_titel2 != <nowiki>''</nowiki>"><xsl:copy-of select="ver_titel2" /></xsl:if></code>
: Hier wird geprüft, ob <code>ver_titel2</code> nicht leer ist. Wenn also ein Text enthalten ist, wir dieser in die Ausgabedatei kopiert.

XSLT kennt keine <code>else</code>-Anweisung. Man kann dies aber durch eine Fallunterscheidung umgehen.

==== Fallunterscheidungen - mehrere Bedingungen ====
Es ist auch möglich eine komplexere Fallunterscheidung aufzubauen, die dann zu verschiedenen Bedingungen jeweils andere Ergebnisse liefert. Anders als bei <code><xsl:if>...</xsl:if></code> gibt es bei der Fallunterscheidung die Möglichkeit einen Anweisungsblock aufzurufen, wenn keiner der vorangegangenen Fälle zutrifft. So lässt sich auch ein <code>else</code>-Block aufbauen.

<pre>
<xsl:choose>
<xsl:when test="Bedingung_1">...</xsl:when>
<xsl:when test="Bedingung_2">...</xsl:when>
...
<xsl:when test="Bedingung_n">...</xsl:when>
<xsl:otherwise>...<xsl:otherwise>
</xsl:choose>
</pre>

Mit <code><xsl:choose>...</xsl:choose></code> wird ein Block mit einer Fallunterscheidung aufgebaut. Die einzelnen Bedingungen werden mit <code><xsl:when test="Bedingung_x">...</xsl:when></code> aufgebaut. Trifft keine der Bedingungen zu, wird der Block <code><xsl:otherwise>...</xsl:otherwise></code> ausgeführt.

<pre>
<xsl:choose>
<xsl:when test="ver_titel2 != <nowiki>''</nowiki>"><xsl:copy-of select="ver_titel2" /></xsl:when>
<xsl:when test="ver_beschreibung_2" != <nowiki>''</nowiki>"><xsl:element name="ver_titel2"><xsl:value-of select="ver_beschreibung_2" /></xsl:element></xsl:when>
</xsl:choose>
</pre>
: Hier wird zunächst geprüft, ob <code>ver_titel2</code> einen Wert enthält. Ist dies der Fall, wird eine Kopie von <code>ver_titel2</code> erstellt. Falls <code>ver_titel2</code> leer ist, wird die nächste Bedingung überprüft. Ist in dieser <code>ver_beschreibung_2</code> nicht leer, wird ein Element mit dem Namen <code>ver_titel2</code> erzeugt und der Wert aus <code>ver_beschreibung_2</code> in das neue Element geschrieben. Sind beide Felder leer, erhält die Ausgabedatei für diese Veranstaltung auch keinen <code>ver_titel2</code>. Für InDesign ist dies wichtig, würde ein leerer <code>ver_titel2</code> in der Ausgabedatei stehen, würde InDesign auch für ein leeres Feld einen Platzhalter einbauen.

=== Arbeiten mit Variablen ===
Manchmal ist es sinnvoll Werte zwischenzuspeichern und diese dann an unterschiedlichen Stellen wieder aufzurufen. Mit <code><xsl:variable name="'''Bezeichner'''">...</xsl:variable></code> ist dies möglich. Der Name der Variablen wird mit '''Bezeichner''' festgelegt. Im Anweisungsblock zwischen den umschließenden Tags wird dann der Inhalt der Variablen aufgebaut.

; <code><xsl:variable name="tab"><xsl:text>	</xsl:text></xsl:variable></code>
: Damit wir eine Variable <code>tab</code> angelegt. Der Inhalt ist ein Textelement, dessen Inhalt ein Tabulatorzeichen ist. Auf diese Variable kann dann mit <code><xsl:value-of select="$tab" /></code> zugegriffen werden. Eine praktische Anwendung davon ist die Kombination mehrerer Felder in einem neuen Ausgabefeld. Die Inhalte der Eingabefelder wird dann durch ein Tabulator getrennt. In InDesign stellt man dann die Tabulatoren in den Absatzformaten entsprechend ein.

=== Funktionen zur Verarbeitung von Feldern (Version 2.0) ===
Möchte man die Inhalte von Feldern noch weiter verändern, benötigt man einen Compiler, der die Version 2.0 von XSLT unterstützt. Hier sind nur wenige Funktionen beschrieben, mit denen man den Text verändern kann. Eine detailierte Beschreibungen der Funktionen findet sich unter http://www.xsltfunctions.com/.

==== fn:replace(''string'', ''pattern'', ''replace'') ====
Mit dieser Funktion kann der Inhalt eines Feldes verändert werden.

; <code><xsl:value-of select="fn:replace(fn:replace(ver_geb_betrag, '\.', ','), ',00', '')" /></xsl:element><xsl:text> Euro</xsl:text></code>
: Mit diesem Ausdruck werden im Feld <code>ver_geb_betrag</code> Punkte durch Kommas ersetzt und Nachkommastellen gelöscht, wenn sie <code>,00</code> sind. Und hinten wird noch ''Euro'' angehängt.

<pre>
<xsl:variable name="termine"><xsl:value-of select="ver_termine"/></xsl:variable>
<xsl:variable name="newline"><xsl:text>
</xsl:text></xsl:variable>
<xsl:variable name="delimiter">[<xsl:value-of select="ver_delimiter"/>]</xsl:variable>
<xsl:element name="termine"><xsl:value-of select="fn:replace(fn:replace($termine, $delimiter, $newline), ' von', ',')"/></xsl:element>
</pre>
: In der Variablen <code>termine</code> wird der Wert aus <code>ver_termine</code> zwischengespeichert. Die Variable <code>newline</code> erhält ein Textelment, dessen Inhalt ein Zeilenumbruch ist. Das Trennzeichen aus Kiribati wird in der Variablen <code>delimiter</code> gespeichert. Die Zeichen <code>[...]</code> sind notwendig, da das Trennzeichen in Kiribati der senkrechte Strich '|' ist. In XSLT bezeichnet dieser jedoch eine Schnittmenge. Würde man die Klammern nicht setzen, bricht der Compiler mit einer Fehlermeldung ab. Anschließend werden die Trennzeichen durch das Zeichen ''neue Zeile'' mithilfe von <code>fn:replace($termine, $delimiter, $newline)</code> ersetzt. Außerdem wird, ebenfalls mit einer <code>fn:replace</code>-Anweisung, ''von'' durch ein Komma ersetzt.

== XML-Daten filtern und aufbereiten ==
=== Version 1.0 ===
==== XML-Datei und Stylesheet Version 1.0 direkt in InDesign importieren ====
==== XML-Datei mit einem Compiler bearbeiten ====

=== Stylesheet Version 2.0 mit Saxon kompilieren ===

== Weiterführende Links ==
* Einführung in XSLT http://www.w3schools.com/xsl/
* XSLT-Funktionen http://www.xsltfunctions.com/ (Version 2.0)
* [https://www.data2type.de/xml-xslt-xslfo/xslt/ XSLT-Referenz]
* [https://www.data2type.de/xml-xslt-xslfo/xpath/ XPath-Einführung]
* [https://www.data2type.de/en/xml-xslt-xslfo/xslt/xslt-xpath-function-reference/ XSLT- und XPath Funktionsreferenz]
* Saxon
* XML-Editor

* http://www.java2s.com/Tutorial/XML/0100__XSLT-stylesheet/countTakesanodesetargumentandreturnsavalueequaltothenumberofnodesinthenodeset.htm
* http://www.fh-wedel.de/~si/seminare/ss01/Ausarbeitung/5.xslt/xslt6.htm
* http://www.w3schools.com/xsl/el_preserve-space.asp
* http://www.w3schools.com/xsl/xsl_w3celementref.asp
* http://www.w3schools.com/xsl/el_decimal-format.asp
* *http://www.w3schools.com/xsl/el_text.asp

XSLT-Stylesheet - Versionsgeschichte

N.raebiger: Die Seite wurde neu angelegt: „In diesem Abschnitt beschreibe ich die wichtigsten Befehle in einem XSLT-Stylesheet. Um sich selbst ein Stylesheet zu erstellen, ist es sinnvoll, die Struktur…“