TextKonverter

Referenzen

Mit der Hilfe von Referenzen lassen sich Inhalte aus dem zu bearbeitenden Text, aus der zu bearbeitenden Datei oder auch aus beliebigen sonstigen anderen Textdateien in den Textfeldern der meisten Aktionen und Funktionen des TextKonverters nutzen. Diese Inhalte können zum Beispiel Zeichen, Wörter, Zeilen, CSV-Zellen, innere XML-Texte, XML-Attributwerte oder auch ein gesamter Dateiinhalt sein. Wie Sie diese Referenzen im TextKonverter nutzen und je nach Bedarf vor ihrer Einfügung optional bearbeiten können, möchten wir Ihnen in diesem Tutorial anhand von Erläuterungen und vielen Beispielen erklären. Das Tutorial ist in die folgenden Abschnitte gegliedert:

• Grundlagen der Verwendung von Referenzen
• Unterstützte Funktionen
• Referenzen auf Zeichen
• Referenzen auf Wörter
• Referenzen auf Zeilen
• Referenzen auf Zellen innerhalb von CSV-Daten
• Referenzen auf Texte innerhalb einer XML-Struktur
• Referenzen auf Attribute innerhalb einer XML-Struktur
• Referenzen auf Dateien
• Funktionsplatzhalter
• Kombination verschiedener Referenzen und Funktionsplatzhalter
• Referenzen in Aktionslisten
• Referenzen in Dateinamen
• Referenzen in Skripts
• Übersicht über alle Platzhalter für Referenzen
• Übersicht über alle Funktionsplatzhalter für Referenzen

Grundlagen der Verwendung von Referenzen

Referenzen sind eine besondere Form von Platzhaltern, mit denen Sie sowohl einzelne als auch mehrere Zeichen, Wörter oder Zeilen, den Inhalt von Zellen aus CSV-Daten, Bestandteile aus einer XML-Struktur wie innere Texte und Attributwerte oder auch ganze Dateien sowie Kombinationen aus diesen Bestandteilen in den Funktionen und Aktionen des TextKonverters verwenden können, als würden Sie den jeweiligen Text direkt in die betreffenden Felder schreiben.

Um Referenzen nutzen zu können, muss zunächst die folgende Option im TextKonverter aktiviert sein:

Aktionen > Optionen > Referenzen 

• Falls diese Option aktiviert ist, werden alle Platzhalter für Referenzen in den Textfeldern der unterstützen Funktionen und Aktionen durch ihre jeweilige Referenz ersetzt. In den betreffenden Textfeldern können die Platzhalter für Referenzen entweder alleine oder auch in Kombination mit beliebigen anderen Zeichen, anderen Referenzen, Funktionsplatzhaltern oder sonstigen Platzhaltern verwendet werden.
• Falls diese Option nicht aktiviert ist, bleiben alle Platzhalter für Referenzen als solche stehen und werden nicht durch die jeweilige Referenz, für die sie stehen, ersetzt.

Die Platzhalter für Referenzen beginnen alle mit "%ref:" und enden alle mit einem "%". Dazwischen können einzelne Referenzen oder auch mehrere mit einem ">" miteinander kombinierte Referenzen sowie Funktionsplatzhalter in einer beliebigen Reihenfolge stehen. Zum Beispiel steht der Platzhalter

%ref:line=1%

für die erste Zeile der aktuellen Datei beziehungsweise des aktuellen Textes oder

%ref:file=E:\Datei.txt%

für den gesamten Inhalt der Datei "E:\Datei.txt". Kombinieren können wir diese beiden Referenzen mit dem Zeichen ">" zu dem folgendem Platzhalter:

%ref:file=E:\Datei.txt>line=1%

Dieser kombinierte Platzhalter steht dann entsprechend für die erste Zeile der Datei "E:\Datei.txt". Verwenden wir %ref:line=1% dagegen alleine, steht der Platzhalter für die erste Zeile des Textes, der gerade bearbeitet wird. Solange in einem Platzhalter keine Referenz zu einer anderen Datei vorhanden ist, beziehen sich alle in diesem Tutorial vorgestellten Platzhalter demnach immer auf den Text oder die Datei, die gerade bearbeitet wird.

Bei der Kombination von Referenzen gibt es kein Limit für die Verschachtelung. Sie könnten also zum Beispiel auch den folgenden Platzhalter kreieren, der vier verschiedene Referenzen enthält, die sich aufeinander beziehen:

%ref:file=E:\Datei.txt>line=2>word=3>char=1%.

Dieser Platzhalter steht dann für das erste Zeichen des dritten Wortes der zweiten Zeile der Datei "E:\Datei.txt".

Zusätzlich können die Platzhalter für Referenzen auch mit Funktionsplatzhaltern kombiniert werden, mit denen sich der Text vor dem Einfügen ändern oder bearbeiten lässt. Ein Beispiel wäre der folgende Platzhalter:

%ref:line=1>trim=whitespace>chars=1-3>write=uppercase%

Bei der Auflösung dieses Platzhalters wird als erstes der Text aus der ersten Zeile durch eine Zeilenreferenz ausgelesen. Danach wird als nächstes der Whitespace (zum Beispiel Leerzeichen oder Tabs) von vorne und hinten mit dem Funktionsplatzhalter für das Trimmen von Text entfernt. Anschließend werden die ersten drei Zeichen durch eine Zeichenreferenz extrahiert und diese mit dem Funktionsplatzhalter zur Änderung der Schreibweise in Großbuchstaben konvertiert. Wie Sie sehen können die Funktionsplatzhalter an beliebigen Stellen eingefügt werden und bearbeiten immer den bis zu dieser Stelle vorliegenden Text. Mehr über dieses Thema erfahren Sie in den Abschnitten über Funktionsplatzhalter sowie in der Übersicht über alle verfügbaren Funktionsplatzhalter.

Wie bereits angesprochen wurde, können Sie die Referenzen sowohl alleine als auch in Kombination mit beliebigen anderen Zeichen, Buchstaben oder Platzhaltern in den unterstützten Funktionen verwenden. Sie könnten also zum Beispiel in das Feld "Ersetzen durch" der Ersetzen-Funktion des TextKonverters sowohl nur "%ref:line=1%" schreiben oder auch "Die erste Zeile der Datei %filename% lautet: %ref:line=1%" um einen beliebigen Text entweder nur durch den Text aus der ersten Zeile zu ersetzen oder durch den genannten Satz, in den der Dateiname sowie der Inhalt aus der ersten Zeile statt der Platzhalter eingefügt wird.

Mehr zu den verschiedenen Typen von Referenzen erfahren Sie in den Abschnitten nach dem nächsten Abschnitt dieses Tutorials sowie in der Übersicht über alle verfügbaren Platzhalter für Referenzen. Auf die Kombination mehrerer Platzhalter wird näher im Abschnitt über die Kombination verschiedener Referenzen eingegangen.

Unterstützte Funktionen

In der aktuellen Version des TextKonverters können Sie Referenzen in den folgenden Aktionen und Funktionen aus den Bereichen Textaktionen, Zeilenaktionen, CSV-Aktionen, XML-Aktionen und Aktionslisten sowie in den Speicheroptionen verwenden:

• Textaktionen: Ersetzen, Löschen, Trimmen, Voranstellen, Anhängen, Einfügen und Counter.
• Zeilenaktionen: Zeilen ersetzen, in Zeilen ersetzen, Zeilen löschen, in Zeilen löschen, Trimmen, Text voranstellen, Text anhängen, Text einfügen, Zeilen hinzufügen und Zeilen sortieren.
• CSV-Aktionen: Felder ersetzen, in Feldern ersetzen, Text löschen, Trimmen, Text voranstellen, Text anhängen, Text einfügen und Spalten hinzufügen.
• XML-Aktionen: In inneren Texten, Tagnamen, Attributnamen und Attributwerten ersetzen, Text löschen, Trimmen, Text voranstellen, Text anhängen, Text einfügen sowie Elemente und Attribute hinzufügen.
• Aktionslisten: In den Textaktionen REPLACE, DELETE, TRIM, APPEND, PREPEND und INSERT, in den Zeilenaktionen REPLACE_LINES, REPLACE_IN_LINES, DELETE_IN_LINES, TRIM_LINES, PREPEND_TO_LINES, APPEND_TO_LINES, INSERT_IN_LINES, ADD_LINES, SELECT_LINES und DESELECT_LINES, in den CSV-Aktionen REPLACE_CELLS, REPLACE_IN_CELLS, DELETE_IN_CELLS, TRIM_CELLS, PREPEND_TO_CELLS, APPEND_TO_CELLS, INSERT_IN_CELLS und ADD_COLUMNS sowie in den XML-Aktionen REPLACE_IN_INNERTEXTS, REPLACE_IN_TAGNAMES, REPLACE_IN_ATTRIBUTENAMES, REPLACE_IN_ATTRIBUTEVALUES, DELETE_IN_INNERTEXTS, DELETE_IN_TAGNAMES, DELETE_IN_ATTRIBUTENAMES, DELETE_IN_ATTRIBUTEVALUES, TRIM_INNERTEXTS, TRIM_ATTRIBUTENAMES, TRIM_ATTRIBUTEVALUES, TRIM_ATTRIBUTEVALUES, PREPEND_TO_INNERTEXTS, PREPEND_TO_TAGNAMES, PREPEND_TO_ATTRIBUTENAMES, PREPEND_TO_ATTRIBUTEVALUES, APPEND_TO_INNERTEXTS, APPEND_TO_TAGNAMES, APPEND_TO_ATTRIBUTENAMES, APPEND_TO_ATTRIBUTEVALUES, INSERT_IN_INNERTEXTS, INSERT_IN_TAGNAMES, INSERT_IN_ATTRIBUTENAMES, INSERT_IN_ATTRIBUTEVALUES, ADD_ELEMENTS und ADD_ATTRIBUTES von Aktionslisten.
• Speicheroptionen: Referenzen können auch in den Feldern "Ordner", "Name" und "Dateiendung" der Speicheroptionen verwendet werden. Damit können Sie Ihre Dateien unter einen Dateinamen abspeichern, der Teile des Inhaltes der jeweiligen Datei enthält. Mehr dazu erfahren Sie im Abschnitt "Referenzen in Dateinamen" dieses Tutorials.

In allen genannten Aktionen können Sie die Platzhalter für die Referenzen in den Textfeldern sowohl alleine verwenden als auch zusammen mit beliebigen anderen Zeichen, beliebigen anderen Referenzen, Funktionsplatzhaltern sowie beliebigen sonstigen Platzhaltern.

Referenzen auf Zeichen

Mit den drei Platzhaltern %ref:char=x% sowie %ref:chars=x-y% und %ref:chars=x,y% können Sie einzelne beziehungsweise mehrere Zeichen referenzieren.

Wenn Sie einzelne Zeichen referenzieren möchten, können Sie dafür den Platzhalter %ref:char=x% verwenden. Das x steht dabei für die Position des Zeichens, das übernommen werden soll. Mit positiven Werten von x wird die Zeichenposition beginnend bei 1 von vorne gezählt. Wenn Sie die Zeichenpositionen von hinten zählen möchten, können Sie negative Werte für x verwenden. Schauen wir uns dazu ein paar Beispiele an:

Wenn Sie mehrere Zeichen hintereinander referenzieren möchten, können Sie dafür einen der beiden Platzhalter %ref:chars=x-y% oder %ref:chars=x,y% nutzen. Das x steht in beiden Platzhaltern für die erste Zeichenpositon, ab der Zeichen übernommen werden sollen. Das y hat in beiden Platzhaltern eine andere Bedeutung. In %ref:chars=x-y% steht das y für die letzte Zeichenposition, die übernommen wird. Es werden mit diesem Platzhalter also die Zeichen von den Zeichenpositionen x bis y referenziert. In %ref:chars=x,y% steht das y dagegen für die Anzahl der Zeichen, die übernommen werden sollen. Setzen Sie für das y beispielsweise eine "3" ein, werden drei Zeichen referenziert: Das Zeichen an der Zeichenposition x sowie die beiden darauf folgenden Zeichen.

Wieder können die Zeichen alternativ auch von hinten gezählt werden, indem im Platzhalter %ref:chars=x,y% ein negativer Wert für x eingesetzt wird, womit y Zeichen ab der Zeichenposition x gezählt von hinten übernommen werden. In dem anderen Platzhalter %ref:chars=x-y% kann nur für y ein negativer Wert verwendet werden. Dieser bedeutet, dass die Buchstaben in diesem Fall von Zeichenposition x (von vorne gezählt) bis Zeichenposition y (von hinten gezählt) übernommen werden.

Schauen wir uns für die erwähnten Fälle einige Beispiele zur Verdeutlichung an:

Die Platzhalter %ref:char=x%, %ref:chars=x-y% und %ref:chars=x,y% können mit allen anderen Platzhaltern für Referenzen sowie mit allen Platzhaltern zur Textbearbeitung kombiniert werden, um so zum Beispiel Zeichen aus einer anderen Datei, Zeichen innerhalb eines Wortes, Zeichen innerhalb einer CSV-Zelle oder Zeichen innerhalb einer Zeile zu referenzieren. Dazu können die Platzhalter für Zeichen einfach mit den anderen Platzhaltern auf die folgende Art und Weise kombiniert werden:

Mehr Informationen zur Kombination der Zeichen-Referenzen mit anderen Referenzen finden Sie im Abschnitt über die Kombination verschiedener Referenzen.

Referenzen auf Wörter

Die drei Platzhalter %ref:word=x%, %ref:words=x-y% sowie %ref:words=x,y% funktionieren genauso wie die drei im letzten Abschnitt vorgestellten Referenzen auf Zeichen. Der einzige Unterschied besteht darin, dass mit diesen Platzhaltern statt der Zeichen einzelne oder mehrere Wörter referenziert werden können.

Ein einzelnes Wort an der Wortposition x lässt sich mit dem Platzhalter %ref:word=x% referenzieren. Wenn Sie mehrere Wörter gleichzeitig referenzieren möchten, können Sie die Platzhalter %ref:words=x-y% und %ref:words=x,y% verwenden. Der erste dieser beiden Platzhalter referenziert die Wörter von Wortposition x bis y, der zweite Platzhalter referenziert eine Anzahl von y Wörtern ab der Wortposition x.

Wieder kann die Wortposition mit negativen Werten für x in den Platzhaltern %ref:word=x% sowie %ref:words=x,y% alternativ auch von hinten gezählt angegeben werden, während im Platzhalter %ref:words=x-y% negative Werte für y verwendet werden können, um die Wortposition des letzten übernommenen Wortes von hinten zu zählen.

Schauen wir uns auch dazu einige Beispiele an:

Wörter definieren sich bei allen drei Platzhaltern dadurch, das ein Wort eine Ansammlung von Zeichen ist, die entweder mit einem Leerzeichen oder mit einem Zeilenumbruch von anderen Bestandteilen des Textes abgetrennt ist. Bei der Zählung der Wörter bleibt doppelter Whitespace wie zum Beispiel mehrere Leerzeichen hintereinander unberücksichtigt.

Diese Art der Extraktion von Worten aus dem Text führt dazu, dass auch Satzzeichen wie Punkte, Kommata, Fragezeichen oder Ausrufezeichen als Bestandteil von einem "Wort" angesehen werden, sofern diese nicht durch Leerzeichen oder Zeilenumbrüche voneinander getrennt sind. Das letzte "Wort" aus dem letzten Satz dieses Abschnitts wäre demnach "sind." mit einem angehängten Punkt. Möchten Sie dies nicht, können Sie zum Beispiel einen der Funktionsplatzhalter wie delete_chars oder trim_chars verwenden, um die Satzzeichen aus den Wörtern zu entfernen. Damit könnte der Platzhalter zum Beispiel so erweitert werden:

Der Unterschied zwischen diesen beiden Platzhaltern liegt darin, ob auch Satzzeichen innerhalb eines Wortes entfernt werden sollen oder nicht. Schauen wir uns als Beispiel einen Satz an, der mit einem Dateinamen endet. Mit %ref:word-1% alleine würden wir als letztes Wort beispielsweise "datei.txt." erhalten. In Verbindung mit dem "remove_chars"-Beispiel würden alle Punkte entfernt werden und wir bekämen "dateitxt". Mit "trim_chars" würden die Punkte nur von den Seiten entfernt und blieben in der Mitte erhalten, das Ergebnis wäre "datei.txt".

Genauso wie bei den Referenzen auf Zeichen können auch die Referenzen auf Wörter mit allen anderen Platzhaltern inlusive Funktionsplatzhaltern kombiniert werden. Hier sind einige Beispiele für mögliche Kombinationen:

Mehr über die Kombination der Platzhalter für Wörter mit anderen Referenzen und Platzhaltern finden Sie im Abschnitt über die Kombination verschiedener Referenzen.

Referenzen auf Zeilen

Auch die Platzhalter %ref:line=x% sowie %ref:lines=x-y% und %ref:lines=x,y% für einzelne oder mehrere Zeilen folgen dem gleichen Prinzip wie die Platzhalter für Zeichen und Worte, die in den letzten beiden Abschnitten vorgestellt wurden.

Einzelne Zeilen können mit dem Platzhalter %ref:line=x% referenziert werden, wobei x für die Zeilennummer steht und für eine Zählung von hinten auch negativ sein kann. Mehrere Zeilen können mit den Platzhaltern %ref:lines=x-y% und %ref:lines=x,y% referenziert werden, wobei %ref:lines=x-y% für die Zeilen mit den Zeilennummern x bis y steht und %ref:lines=x,y% für y Zeilen beginnend mit der Zeile mit der Zeilennummer x. Für eine Zählung der Zeilennummern von hinten können im Platzhalter %ref:lines=x,y% negative Werte für x verwendet werden und im Platzhalter %ref:lines=x-y% negative Werte für y.

Hier sind einige Beispiele für alle 3 Typen von Zeilen-Platzhaltern:

Natürlich können auch die Platzhalter für einzelne oder mehrere Zeilen mit den anderen Platzhaltern für Referenzen oder mit den Funktionsplatzhaltern kombiniert werden. Auch dazu möchten wir uns einige Beispiele ansehen:

Wenn Sie mehr über die Kombination der Zeilen-Referenzen mit anderen Platzhaltern für Referenzen erfahren möchten, können Sie sich den Abschnitt über die Kombination verschiedener Referenzen ansehen.

Referenzen auf Zellen innerhalb von CSV-Daten

Mit dem Platzhalter %ref:cell=x:y% lässt sich der Inhalt von Feldern aus CSV-Daten oder CSV-Dateien referenzieren. Das x in diesem Platzhalter steht dabei für die Nummer der Spalte, das y steht für die Zeilennummer. Die folgenden vier Verwendungen dieses Platzhalters würden demnach beispielsweise die aufgeführten Felder innerhalb der ersten beiden Spalten und der ersten beiden Zeilen referenzieren:

Entscheidend für die Interpretation von Texten als CSV-Daten und damit für diese Referenz auf CSV-Felder sind die Einstellungen im TextKonverter unter "Aktionen > CSV > Importformat" sowie "Aktionen > Dateien > Zeilenumbruchtyp". In diesen Einstellungen lässt sich festlegen, welche benutzerdefinierten Zeichen, Codepoints oder feste Zeichenlängen für die Feldtrennung, die Feldbegrenzung und das Zeilenende verwendet werden sollen oder ob der TextKonverter diese anhand des Textes automatisch erkennen soll (was die Voreinstellung ist). Mehr zu diesem Thema erfahren Sie im Tutorial über die CSV-Bearbeitung mit dem TextKonverter.

Wie alle anderen Platzhalter auch lässt sich natürlich auch dieser Platzhalter mit allen anderen Platzhaltern für Referenzen oder Funktionsplatzhaltern kombinieren. Hier sehen Sie einige Beispiele dafür:

Im Abschnitt über die Kombination von Platzhaltern erfahren Sie mehr über diese Kombinationen und was es dabei zu beachten gibt.

Referenzen auf Texte innerhalb einer XML-Struktur

Wenn Sie Texte aus einer XML-Struktur referenzieren möchten, können Sie dafür den Platzhalter %ref:xml=x% verwenden. Das x in diesem Platzhalter steht dabei für einen CSS-Selektor, mit dem sich die Elemente innerhalb der XML-Struktur ansprechen lassen. Unterstützt werden alle gebräuchlichen CSS-Selektoren wie zum Beispiel Typselektoren, ID-Selektoren, Klassenselektoren, Positionsselektoren und so weiter.

Auslesen aller Texte einer XML-Beispieldatei

Zur Verdeutlichung möchten wir uns als Beispiel ansehen, mit welchen Platzhaltern wir die Texte der folgenden HTML-Seite extrahieren können.

<!DOCTYPE HTML>
<html>
<head>
  <title>Titel der Seite</title>
</head>
<body>
  <h1>Überschrift der Seite</h1>
  <p class="a">Text des ersten Absatzes.</p>
  <p class="b">Text des zweiten Absatzes.</p>
  <p>Text des dritten Absatzes.</p>
  <div id="footer" class="b">Text im Footer</div>
</body>

Mit den folgenden Platzhaltern können wir den Titel der Seite, die Überschrift der Seite, die Texte der ersten beiden Absätze sowie den Text aus dem Footer der Seite für die Weiterverwendung auslesen:

Dazu verwenden wir die Typselektoren "title" und "h1", mit denen wir die Elemente des Title-Tags und der Überschrift direkt über ihren Tagnamen ansprechen. Die beiden Absätze sprechen wir anschließend über ihre Klasse an. Den ersten Abschnitt nur über den Klassennamen "a" mit dem CSS-Klassen-Selektor ".a", den zweiten Abschnitt über Typ und Klasse mit dem CSS-Selektor "p.b". Wir nutzen in diesem Fall "p.b", da weder der Tagname "p" noch die Klasse "b" zu einem eindeutigen Ergebnis führen würden, da sie mehrfach in der HTML-Seite vorkommen. Zuletzt sprechen wir den Footer über seine ID "footer" mit dem CSS-ID-Selektor "#footer" an.

Selektoren mit mehreren Treffern

Sicherlich haben Sie sich schon die Frage gestellt, was passiert, wenn wir einen Selektor verwenden, der mehr als ein Element unserer XML-Struktur matcht. In unserem Beispiel wären das beispielsweise die CSS-Selektoren "p" oder ".b", die jeweils drei beziehungsweise zwei Matches erzielen würden. Würden wir einen solchen Selektor verwenden, würden wir alle inneren Texte aller Elemente, auf die der Selektor zutrifft, erhalten. Und zwar mit einem Zeilenumbruch voneinander getrennt, also eine Zeile je Match.

Wenn wir also die CSS-Selektoren "p" oder ".b" als Referenz nutzen würden, wäre das Ergebnis für unsere HTML-Beispielseite wie folgt:

Was können wir aber tun, wenn wir nur einen bestimmten Text aus der Vielzahl von Treffern eines Selektors benötigen? Wir können unsere XML-Referenz zum Beispiel einfach mit einer Zeilen-Referenz beliebig kombinieren und erhalten damit die Möglichkeit, gezielt einen bestimmten Treffer über dessen Nummer anzusprechen oder auch mehrere der Treffer auszuwählen:

Wenn wir die Treffer nicht über ihre Nummer auswählen möchten, können wir alternativ auch einen der Zeilenfilter verwenden, um die Treffer aufgrund ihres Inhalts einzuschränken:

In diesen drei Beispielen verwenden wir die Zeilenfilter find_lines und delete_lines. In den ersten beiden Beispielen suchen wir alle Treffer, die den Text "w" beziehungsweise "Absatz" enthalten, im dritten Beispiel entfernen wir alle Zeilen aus dem Suchergebnis, die das Wort "Absatz" enthalten.

Kombinationen der XML-Referenz mit anderen Platzhaltern

Kombinationen sind natürlich nicht nur mit einer Zeilenreferenz oder einem Zeilenfilter möglich. Die XML-Referenz können Sie auch mit jedem beliebigen anderen Platzhalter für Referenzen sowie mit Funktionsplatzhaltern kombinieren, wie die kleine Auswahl der folgenden Beispiele demonstriert:

Eine Besonderheit sehen Sie im Beispiel des CSS-Selektors "ul>li", der für ein li-Listenelement unterhalb eines ul-Elements steht. Da das für diesen Selektor nötige Zeichen ">" als Trennzeichen zwischen mehreren kombinierten Platzhaltern dient, müssen wir das Zeichen verdoppeln, wenn es nicht in der Funktion des Trennzeichens gebraucht wird. Mehr darüber sowie über die Kombination von Platzhaltern im Allgemeinen erfahren Sie im Abschnitt über die Kombination von Referenzen.

Referenzen auf Attribute innerhalb einer XML-Struktur

Wenn Sie die Werte von Attributen aus einer XML-Struktur referenzieren möchten, können Sie den im letzten Abschnitt vorgestellten Platzhalter %ref:xml=x% um den Platzhalter für Attribute ">attribute=name" erweitern. Der sich ergebende Platzhalter %ref:xml=x>attribute=y% steht entsprechend für den Wert des Attributs mit dem Namen "y" des Elementes innerhalb einer XML-Struktur, auf das der CSS-Selektor "x" zutrifft. Der XML-Teil beziehungsweise die Auswahl der XML-Nodes, aus denen die Attributwerte ausgelesen werden sollen, kann damit genauso verwendet werden wie im letzten Abschnitt beschrieben und muss lediglich um den Attribut-Teil ergänzt werden, um auf die Attributwerte zugreifen zu können.

Auslesen aller Attributwerte einer XML-Beispieldatei

Schauen wir uns zur Demonstration dieser Referenz wieder eine kleine Beispieldatei an.

<?xml version="1.0"?>
<audios year="2023">
  <audio id="sample1" genre="Pop">
    <title en="The Pilot's Dance" de="Der Pilotentanz">
  </audio>
  <audio id="sample2" genre="Rock">
    <title en="Hard Way to Jupiter" de="Beschwerlicher Weg zum Jupiter">
  </audio>
  <audio id="sample3" genre="Dance">
    <title en="Ringle Man" de="Ringelmann">
  </audio>
  <audio id="sample4" genre="Hardstyle">
    <title en="The Exit" de="Der Ausgang">
  </audio>
</audios>

Nun möchten wir jeden einzelnen Typ von Attributwert, der in dieser Datei vorkommt, auslesen.

Am einfachsten ist dies für Attribute von Elementen, die eindeutig oder nur ein einziges Mal in der XML-Datei vorkommen. Also zum Beispiel das Element "audios" mit dem Attribut "year" oder die "genre"-Attribute, die wir über die ID des Elements "audio" eindeutig ansprechen können:

Wie Sie sehen, können wir die Elemente auf die gleiche Weise über CSS-Selektoren auswählen, wie es im letzten Abschnitt für das Referenzieren von inneren Texten beschrieben wurde und hängen einfach nur den Namen unseres gewünschten Attributs des jeweiligen Elementes mittels ">attribute=attributname" an.

Falls wir einen Selektor verwenden, auf den mehrere Elemente unserer XML-Struktur zutreffen, erhalten wir zeilenweise alle passenden Attributwerte dieser Elemente. Ein Beispiel dafür ist der Selektor "audio" in Kombination mit dem ID-Attribut. Der Selektor "audio" matcht insgesamt 4 Elemente unserer Beispieldatei und jedes dieser Elemente enthält ein eigenes ID-Attribut. Wir bekommen also 4 Zeilen und in jeder dieser Zeilen steht einer der 4 Attributwerte:

Wenn wir nicht alle Zeilen benötigen, können wir unseren Platzhalter mit einer Zeilenreferenz oder einem Zeilenfilter beliebig kombinieren, um gezielt nur bestimmte dieser Zeilen auszulesen. Die Vorgehensweise ist genauso wie beim Referenzieren einzelner innerer Texte (wie im letzten Abschnitt gezeigt wurde) und kann sowohl für das Auslesen einzelner Zeilen als auch für das Auslesen mehrerer Zeilen angewendet werden:

Mit der gleichen Methode lassen sich auch entweder alle oder eine Auswahl der "genre"-Attribute aus der Beispieldatei auslesen. In den folgenden Beispielen filtern wir die Attributwerte sowohl über ihre Nummer als auch über ihren Inhalt:

Interessant wird es wieder beim Auslesen der Attribute "en" und "de" da diese ein Level unterhalb der Elemente mit einer ID stehen und selber keine eigene ID haben sondern alle gleich aufgebaut sind. Wenn wir als Selektor nur "title" verwenden und die Attribute "en" oder "de" auslesen möchten, erhalten wir wieder alle 4 Attributwerte auf einmal. Falls wir nur einen bestimmten dieser Attributwerte auslesen möchten und dabei über die ID des Parent-Elements gehen möchten, lässt sich der Selektor "#sample3>title" verwenden (title-Element unterhalb des Elements mit der ID "sample3" wobei wir das ">"-Zeichen verdoppeln müssen). Alternativ könnten wir natürlich auch wieder mit der line-Referenz arbeiten, wie im letzten Beispiel. Hier sind Beispiele für all diese Fälle:

Damit hätten wir alle verfügbaren Attributtypen der Beispieldatei ausgelesen.

Eigenschaften aus HTML-Dokumenten auslesen

Die Attribut-Referenz lässt sich unter anderem auch dazu verwenden, bestimmte Eigenschaften aus HTML-Dateien auszulesen. Hier sind einige Beispiele dafür, die zeigen, wie sich beispielsweise die Sprache, der Autor, die Keywords oder die Meta-Description (Beschreibung) von HTML-Dokumenten auslesen lässt (ein Beispiel für das Auslesen des Title-Attributs finden Sie im letzten Abschnitt, da für das Auslesen des Title-Attributes keine Attribut-Referenzen nötig sind):

Kombination der Attribut-Referenz mit anderen Platzhaltern

Natürlich lässt sich auch der Platzhalter für Attributwerte mit beliebigen anderen Platzhaltern oder Platzhalterfunktionen kombinieren. Einige Beispiele dafür finden sich in der folgenden Tabelle:

Die Platzhalter zum Auslesen der internen und externen Links wurden umgesetzt mit der FindLines- sowie der DeleteLines-Funktion in Kombination mit regulären Ausdrücken. Mehr über das Kombinieren von Platzhaltern erfahren Sie in den Abschnitten über die Kombination von Platzhaltern und die Verwendung von Platzhalterfunktionen.

Referenzen auf Dateien

Während sich alle bisher in diesem Tutorial vorgestellten Platzhalter für sich genommen immer auf den aktuellen Text beziehungsweise auf die aktuelle Datei beziehen, die gerade bearbeitet wird, können Sie mit dem Platzhalter %ref:file=Dateiname% auch beliebige andere Textdateien beziehungsweise den Inhalt dieser Dateien referenzieren. Statt "Dateiname" können Sie einen beliebigen Dateinamen beziehungsweise einen Pfad zu einem Dateinamen in den Platzhalter einsetzen. Also zum Beispiel:

%ref:file=C:\Ordner\Datei.txt%

Wenn Sie diesen Platzhalter genau so verwenden, steht er für den gesamten Inhalt der Datei "C:\Ordner\Datei.txt". Falls Sie diesen Platzhalter also zum Beispiel in das Textfeld einer Einfügen-Funktion des TextKonverters schreiben, wird der gesamte Inhalt der angegebenen Datei an der gewünschten Stelle eingefügt.

Falls Sie die eigene Datei referenzieren möchten, also die Datei, die gerade bearbeitet wird, können Sie statt dem exakten Dateipfad auch das Wort "self" verwenden. Der Platzhalter %ref:file=self% steht entsprechend für den gesamten Inhalt der Datei, die gerade bearbeitet wird. Die Referenzierung mit "self" funktioniert nicht nur für Dateibearbeitungen sondern auch für ungespeicherte Texte: Auch wenn Sie einen ungespeicherten Text bearbeiten, können Sie diesen Text in seiner ganzen Länge mit %ref:file=self% referenzieren.

Tipp: Falls Sie keine Lust haben, den gesamten Dateipfad händisch in den Platzhalter hineinzuschreiben und sich die Datei, die Sie referenzieren möchten, in der Dateiliste des TextKonverters befindet, können Sie einfach mit der rechten Maustaste auf die Datei klicken und die Option "Dateipfad in die Zwischenablage kopieren" aus dem Kontextmenü wählen, um den Dateipfad bequem über die Zwischenablage einfügen zu können.

Natürlich kann der Inhalt der Datei vor seiner Verwendung noch mit den Funktionsplatzhaltern bearbeitet, angepasst und modifiziert werden. Wie Sie in den folgenden Beispielen sehen können, können dabei auch mehrere Funktionsplatzhalter hintereinander geschrieben werden, um mehrere Bearbeitungsschritte zu realisieren:

Wenn Sie eine Datei-Referenz nicht an die erste Position einer Kette von kombinierten Platzhaltern setzen oder mehrere Datei-Referenzen hintereinander schreiben, wird der Inhalt der Datei zum bisherigen Text der Referenz hinzugefügt. Also zum Beispiel:

Zum Verbinden mehrerer Dateien kann natürlich alternativ auch die Funktion "Aktionen > Dateien > Dateien aneinanderhängen" des TextKonverters verwendet werden, die im Tutorial über das Aneinanderhängen von Textdateien beschrieben wird. Ob es sinnvoller ist, mit dieser Funktion zu arbeiten oder mit Referenzen, hängt von dem jeweiligen Anwendungsfall ab. Während Referenzen eine flexiblere Integration bieten, lässt sich die "Dateien aneinanderhängen"-Funktion schneller bedienen, um Textdateien ohne weitere Bearbeitungsschritte einfach nur aneinanderzuhängen (dafür ist lediglich das Setzen eines Hakens erforderlich).

Falls Sie nicht den gesamten Inhalt der Datei einfügen möchten, sondern nur Teile deren Inhalts, wie zum Beispiel nur einzelne Buchstaben, Wörter oder Zeilen, können Sie den Dateireferenz-Platzhalter einfach mit beliebigen anderen Platzhaltern für Referenzen kombinieren. Einige Beispiele dafür wären:

Wie Sie sehen lassen sich die einzelnen Platzhalter für Referenzen beliebig oft hintereinanderschreiben und beliebig untereinander sowie auch mit Funktionsplatzhaltern kombinieren. Mehr über die Funktionsplatzhalter erfahren Sie im nächsten Abschnitt, mehr über die Kombination von Referenzen im übernächsten Abschnitt.

Funktionsplatzhalter

Der TextKonverter stellt Ihnen einige Funktionsplatzhalter zum Ersetzen, Löschen, Trimmen, Voranstellen, Anhängen, Einfügen, Filtern, Umschreiben und Auffüllen des über Referenzen ausgelesenen Textes zur Verfügung.

Eine tabellarische Übersicht über alle verfügbaren Funktionsplatzhalter finden Sie in der Übersicht über alle Funktionsplatzhalter für Referenzen am Ende dieses Tutorials. Eine Beschreibung aller Funktionsplatzhalter finden Sie im Anschluss an diese Einführung in diesem Abschnitt.

Funktionsplatzhalter können genauso verwendet und mit anderen Platzhaltern kombiniert werden, wie die übrigen Platzhalter für Referenzen auch. Der einzige Unterschied besteht darin, dass die Funktionsplatzhalter keine Referenz auf einen Textbestandteil oder eine Datei erzeugen sondern den bis zur Stelle des Funktionsplatzhalters innerhalb des Platzhalters ausgelesenen Text bearbeiten können. Aus diesem Grund ergeben die Funktionsplatzhalter auch erst ab der zweiten Position in der Platzhalterkette einen Sinn, da sie nur mit dem bis dahin ausgelesenen Text arbeiten und selber keinen Text auslesen können (auch wenn Funktionsplatzhalter grundsätzlich an jeder beliebigen Stelle des Platzhalters stehen können und ein Funktionsplatzhalter an erster Stelle der Kette keinen Fehler erzeugen würde sondern nur den zu diesem Zeitpunkt leeren String der Referenz "bearbeiten" würde).

Schauen wir uns zunächst als Beispiel für die Nutzung von Funktionsplatzhaltern einen Platzhalter an, der eine Kette von Referenzen und Funktionen zur Bearbeitung des ausgelesenen Textes enthält:

%ref:line=1>trim=whitespace_left>chars=1-3>replace,a,b>write=lowercase%

Dieser Platzhalter steht für die ersten 3 Zeichen der ersten Zeile, die keine Leerzeichen sind, in denen der Buchstabe "a" durch den Buchstaben "b" ersetzt wurde, geschrieben in Kleinbuchstaben.

• Im ersten Schritt liest dieser Platzhalter den Text aus der ersten Zeile aus (line=1).
• Anschließend kommt der erste Funktionsplatzhalter ins Spiel (trim=whitespace_left). Es handelt sich dabei um den Trim-Funktionsplatzhalter, der mit dem Parameter "whitespace_left" aufgerufen wird. Dieser sorgt dadurch dafür, dass von dem eben ausgelesenen Text aus der ersten Zeile vorne (linksseitig) der Whitespace entfernt wird.
• Als nächstes folgt kein Funktionsplatzhalter sondern eine Zeichenreferenz auf die ersten 3 Zeichen (chars=1-3) des bis zu diesem Zeitpunkt ausgelesenen Textes. Durch den Trim-Funktionsplatzhalter haben wir zuvor sichergestellt, dass es sich bei diesen 3 Zeichen nicht um Whitespace handeln kann, so dass wir die ersten 3 Zeichen der ersten Zeile erhalten, die keine Leerzeichen oder Tabs sind.
• Zuletzt folgen wieder zwei Funktionsplatzhalter: Zunächst werden alle Vorkommnisse des Buchstabens "a" durch den Text "b" mit dem Replace-Platzhalter ersetzt, anschließend wird der Write-Platzhalter dazu verwendet, alle bisher ausgelesenen Buchstaben in Kleinbuchstaben zu verwandeln.

Die einzelnen Kettenglieder dieses Platzhalters sind mit dem Zeichen ">" verknüpft. Mehr zur Verknüpfung von Referenzen und Funktionen erfahren Sie im nächsten Abschnitt. Zunächst schauen wir uns aber Erklärungen und Beispiele für jeden einzelnen der verfügbaren Funktionsplatzhalter an:

• Platzhalter für das Ersetzen von Text
• Platzhalter für das Löschen von Text
• Platzhalter für das Trimmen des Textes
• Platzhalter zum Einfügen und Anhängen von Text
• Platzhalter zum Filtern des Textes
• Platzhalter zum Filtern von Zeilen
• Platzhalter zum Umschreiben des Textes
• Platzhalter zum Auffüllen des Textes
• Platzhalter für die Anpassung von Zahlen
• Zeilenumbrüche und Tabs in den Funktionsplatzhaltern verwenden
• Das ">"-Zeichen in den Funktionsplatzhaltern nutzen

Platzhalter für das Ersetzen von Text

Funktionsplatzhalter für das Ersetzen von Text gibt es in den drei verschiedenen Versionen replace=x,y sowie replace=x,y,z und replace_regex=x,y. Mit der Basisversion replace=x,y wird der Text x durch den Text y ersetzt. Das x steht also für einen beliebigen Suchtext und y für eine beliebige Ersetzung. In der erweiterten Version replace=x,y,z können über den zusätzlichen Parameter z Optionen übergeben werden und replace_regex=x,y kann für Ersetzungen mit der Hilfe von regulären Ausdrücken verwendet werden. Im folgenden möchten wir uns Beispiele für jede dieser Varianten ansehen.

Unser erstes Beispiel demonstriert die einfachste Verwendung des Replace-Funktionsplatzhalters:

%ref:line=1>replace=abc,def%

Dieser Platzhalter steht für den Inhalt der ersten Zeile, in dem der Text "abc" durch den Text "def" ersetzt wurde.

Falls wir in unserem Suchtext und/oder in unserer Ersetzung ein Komma verwenden möchten, müssen wir den betreffenden Text in Anführungszeichen setzen, damit eindeutig wird, welches Komma zum Text gehört und welches Komma die Parameter voneinander trennt:

%ref:line=1>replace="1,0","1,1"%

Ein weiterer Sonderfall ist die Verwendung von Zeilenumbrüchen und Tabs im Suchtext oder in der Ersetzung. Zeilenumbrüche können als "\l" geschrieben werden, Tabs als "\t", wie auch in unserem nächsten Beispiel:

%ref:file=E:\Datei.txt>replace=\t,\l%

Dieser Platzhalter steht entsprechend für den Inhalt der Datei "Datei.txt", in dem sämtliche Tabs durch Zeilenumbrüche ausgetauscht wurden. Mehr über dieses Thema erfahren Sie im Abschnitt über die Verwendung von Zeilenumbrüchen und Tabs in Funktionsplatzhaltern.

Wenn wir den Replace-Funktionsplatzhalter in der Weise verwenden, wie wir ihn in unseren bisherigen Beispielen gesehen haben, wird die Ersetzung unabhängig von der Groß- und Kleinschreibung ausgeführt. Das heißt "replace=a,b" ersetzt nicht nur alle klein geschriebenen "a" durch "b" sondern auch alle groß geschriebenen "A" durch "b". Wenn wir dies nicht möchten, können wir diesen Wunsch als Option über den optionalen dritten Parameter der Replace-Funktion replace=x,y,z äußern:

%ref:line=1>replace=a,b,c>replace=A,B,c%

Dieser Platzhalter steht für den Inhalt der ersten Zeile, in dem alle kleingeschriebenen "a" durch "b" ausgetauscht wurden und alle großgeschriebenen "A" durch "B" ersetzt wurden. Als dritten Parameter haben wir "c" (case sensitive) übergeben. Damit wird der Suchtext unter Beachtung der Groß- und Kleinschreibung interpretiert. Lassen wir das "c" weg, gibt es keinen Unterschied zwischen einer Suche nach "a" und einer Suche nach "A". Gleichzeitig ist dieser Platzhalter ein Beispiel dafür, wie wir mehrere Ersetzungen innerhalb eines Platzhalters durchführen können, indem wir die Funktionsplatzhalter einfach hintereinander hängen.

Eine weitere Option, die wir als dritten Parameter übergeben können, ist "r". Falls wir dies tun, werden x und y in replace=x,y,z als reguläre Ausdrücke interpretiert. Also zum Beispiel:

%ref:line=1>replace=[1-9],0,r%

Dieser Platzhalter steht für den Inhalt der ersten Zeile, in dem sämtliche Ziffern von 1 bis 9 durch "0" ersetzt wurden. Als Suchtext haben wir den regulären Ausdruck [1-9] angegeben und als Parameter "r" übergeben, der dem TextKonverter mitteilt, dass die Eingaben als regulärer Ausdruck zu interpretieren sind.

Dasselbe Ergebnis bekommen wir übrigens auch mit dem folgenden Platzhalter:

%ref:line=1>replace_regex=[1-9],0%

Der Funktionsplatzhalter replace_regex=x,y ist eine Kurzform für replace=x,y,r in der wir uns den dritten Parameter sparen können.

Natürlich können "c" und "r" nicht nur alleine sondern auch gemeinsam verwendet werden:

%ref:file=self>replace=([A-Z]),_$1,cr%

Dieser Platzhalter steht für den Inhalt des gesamten Textes (file=self) der gerade bearbeitet wird, in dem allen Großbuchstaben von A bis Z das Zeichen "_" vorangestellt wurde. Als dritten Parameter haben wir "cr" übergeben, da wir einerseits mit regulären Ausdrücken arbeiten möchten und uns andererseits nur die Großbuchstaben interessieren. Dieses Mal haben wir sowohl als Suchtext als auch als Ersetzung einen regulären Ausdruck angegeben, da wir den gefundenen Buchstaben mit $1 referenzieren. Mit replace_regex können wir an dieser Stelle nicht arbeiten, da wir die "c"-Option benötigen und replace_regex immer unabhängig von der Groß- und Kleinschreibung arbeitet.

Platzhalter für das Löschen von Text

Die Funktionsplatzhalter delete=x sowie delete_regex=x für das Löschen von Text funktionieren ähnlich wie die im letzten Abschnitt beschriebenen Funktionsplatzhalter für das Ersetzen von Text. Der einzige Unterschied besteht darin, dass immer mit einem leeren Text ersetzt wird - der Suchtext also nicht im klassischen Sinne ersetzt sondern gelöscht wird. Hinzu kommt delete_chars=x als dritter Funktionsplatzhalter für das Löschen einzelner Zeichen. Im folgenden möchten wir uns wieder Beispiele für alle drei Typen ansehen.

Um einen beliebigen Text zu löschen, können wir den Funktionsplatzhalter delete=x in seiner Reinform verwenden:

%ref:line=1>delete=abc%

Dieser Platzhalter steht für den Inhalt der ersten Zeile, in dem der Text "abc" gelöscht wurde. Die Löschung findet unabhängig von der Groß- und Kleinschreibung statt. Das heißt "a" löscht nicht nur "a" sondern auch "A". Um einen Text unter Beachtung der Groß- und Kleinschreibung zu löschen, können Sie auf den Replace-Funktionsplatzhalter zurückgreifen. Dieser ist in der Form replace=x,,c zu verwenden, um den Text x unter Beachtung der Groß- und Kleinschreibung zu löschen.

Wenn Sie keinen spezifischen Text löschen möchten sondern jegliche Textfragmente, die einem regulären Ausdruck entsprechen, können Sie delete_regex=x verwenden, wobei x durch den regulären Ausdruck zu ersetzen ist:

%ref:line=1>delete_regex=[0-9]%

Dieser Platzhalter steht für den Inhalt der ersten Zeile, aus dem sämtliche Zahlen entfernt wurden. Auch dieser Platzhalter kann mit dem Replace-Funktionsplatzhalter ausgedrückt werden: Das Äquivalent zu "delete_regex=[0-9]" ist "replace=[0-9],,r". Genauso wie "delete=x" arbeitet auch "delete_regex=x" unabhängig von der Groß- und Kleinschreibung. Um Textfragmente mit der Hilfe von regulären Ausdrücken unter Beachtung der Groß- und Kleinschreibung zu löschen, ist daher wieder ein Rückgriff auf den Replace-Funktionsplatzhalter nötig. Für diesen Fall ist die Form "replace=x,,cr" erforderlich, um alle Textfragmente zu löschen, die dem regulären Ausdruck x unter Beachtung der Groß- und Kleinschreibung entsprechen.

Wenn Sie mehrere einzelne Zeichen löschen möchten, könnten Sie den folgenden Platzhalter aus der Kombination mehrerer einzelner Delete-Funktionsplatzhalter konstruieren:

%ref:line=1>delete=a>delete=b>delete=c%

Dieser Platzhalter steht für den Inhalt der ersten Zeile, aus dem als erstes der Buchstabe "a", danach der Buchstabe "b" und zuletzt der Buchstabe "c" gelöscht wurde. Für das Löschen einzelner Buchstaben gibt es allerdings eine Kurzform, die uns die Arbeit erleichtert:

%ref:line=1>delete_chars=abc%

Auch dieser Platzhalter steht für den Inhalt der ersten Zeile, aus dem die Buchstaben "a", "b" und "c" gelöscht wurden. Dabei müssen diese Buchstaben nicht in einer Einheit als "abc" vorkommen, um gelöscht zu werden, sondern werden wie bei dem Beispiel zuvor auch, alle einzelnen und unabhängig voneinander gelöscht. Das heißt der gesamte Text, den wir delete_chars=x übergeben, wird in seine Einzelbuchstaben aufgelöst und eine einzelne Löschung für jeden dieser Buchstaben veranlasst. Dieses Beispiel könnte man übrigens auch leicht mit regulären Ausdrücken umsetzen: Auch der Platzhalter "delete_regex=[a-c]" würde zu dem gleichen Ergebnis führen.

Falls wir Zeilenumbrüche oder Tabs löschen möchten, können wir dafür die Platzhalter \l, \r, \n und \t in unserem Suchtext verwenden. Mehr zu diesem Thema erfahren Sie in dem Abschnitt über die Verwendung von Zeilenumbrüchen und Tabs in Funktionsplatzhaltern.

Platzhalter für das Trimmen des Textes

Der Funktionsplatzhalter trim=x kann dazu verwendet werden, bestimmte Zeichen vom Beginn und/oder vom Ende des aktuellen Textes zu entfernen. Je nachdem, welcher Parameter für x verwendet wird, können dies verschiedene Zeichen sein: Entfernt werden können zum Beispiel Whitespace-Zeichen, eine bestimmte Anzahl von Zeichen, bestimmte frei definierbare Zeichen oder alle Zeichen bis zu einem bestimmten Text. All diese Typen gibt es in Varianten für eine beidseitige Entfernung (vorne und hinten) sowie für eine ausschließlich linksseitige (vorne, left) oder eine ausschließlich rechtsseitige (hinten, right) Entfernung von Zeichen.

Um Whitespace, also Leerzeichen, Zeilenumbrüche oder Tabs zu entfernen, kann trim=x mit "whitespace", "whitespace_left" oder "whitespace_right" aufgerufen werden. Der folgende Platzhalter steht beispielsweise für die erste Zeile, deren Inhalt beidseitig von Whitespace befreit wurde:

%ref:line=1>trim=whitespace%

Würden wir stattdessen "trim=whitespace_left" oder "trim=whitespace_right" schreiben, würde der Whitespace nicht beidseitig sondern nur vorne beziehungsweise nur hinten entfernt werden.

Wenn Sie eine bestimmte Anzahl von Zeichen vom Beginn und/oder vom Ende des Textes entfernen möchten, unabhängig davon, welche Zeichen dies sind, können Sie für x in trim=x die Parameter "number_of_chars:y", "number_of_chars_left:y" sowie "number_of_chars_right:y" verwenden, wobei y für die Anzahl der zu entfernenden Zeichen steht. Ein Beispiel dafür ist der folgende Platzhalter, der für den Inhalt der zweiten Zeile steht, von dem vorne die ersten 3 Zeichen abgeschnitten wurden:

%ref:line=2>trim=number_of_chars_left:3%

Analog dazu lassen sich natürlich auch die Parameter "number_of_chars:y", und "number_of_chars_right:y" verwenden, mit denen eine beliebige Anzahl von Zeichen beidseitig oder vom Ende abgeschnitten werden können.

Wenn Sie selber bestimmen möchten, welche Zeichen vom Beginn und/oder vom Ende des Textes entfernt werden sollen, können Sie in trim=x für x die Parameter "chars:y", "chars_left:y" sowie "chars_right:y" einsetzen, um alle in y definierten Zeichen zu entfernen. Schauen wir uns auch dazu ein Beispiel an:

%ref:file=E:\datei.txt>trim=chars:0123456789 .!?%

Dieser Platzhalter steht für den Inhalt der Datei "datei.txt", von dem sowohl vorne als auch hinten sowohl Ziffern als auch Leerzeichen sowie Punkte, Ausrufezeichen und Fragezeichen entfernt wurden. Die Zeichenauswahl ist beliebig und es spielt keine Rolle, in welcher Reihenfolge die Zeichen angegeben werden. Analog lassen sich natürlich auch die Parameter "chars_left:y" sowie "chars_right:y" verwenden, um Zeichen nur linksseitig oder nur rechtzeitig zu entfernen. Ein Beispiel dafür ist der folgende Platzhalter, der "chars_left:y" und "chars_right:y" miteinander kombiniert:

%ref:line=3>trim=chars_left:123>trim=chars_right:abc%

Dieser Platzhalter steht für den Inhalt der dritten Zeile, von dem vorne alle Ziffern von 1 bis 3 entfernt wurden und hinten alle Buchstaben von a bis c entfernt wurden. Sie können den Trim-Funktionsplatzhalter also auch dafür verwenden, vorne und hinten auf voneinander abweichender Art und Weise Zeichen zu entfernen. So wäre es zum Beispiel genauso möglich, nur vorne Whitespace zu entfernen und nur hinten eine bestimmte Anzahl von Zeichen zu entfernen.

Neben der Entfernung bestimmter Zeichen oder der Entfernung einer bestimmten Anzahl von Zeichen, können auch alle Zeichen vor und/oder nach einem bestimmten Text entfernt werden. Dafür können Sie in trim=x für x einen der Parameter "till_text:y,z", "till_text_left:y,z" oder "till_text_right:y,z" einsetzen. In diesen Parametern steht y für den Text ab dem oder bis zu dem alle Zeichen entfernt werden und über z können optional Oprionen übergeben werden. Zur Verfügung stehen die Optionen "c" (Groß- und Kleinschreibung beachten), "r" (als regulären Ausdruck interpretieren) und/oder "i" (Text einbeziehen).

Das folgende Beispiel demonstriert all diese Optionen:

%ref:line=4>trim=till_text_left:[0-9],ri>trim=till_text_right="a,b",c%

Diese Referenz steht für den Inhalt der vierten Zeile, von dem vorne und hinten nach unterschiedlichen Kriterien Zeichen bis zu einem bestimmten Text abgeschnitten wurden:

• Vorne sollen alle Zeichen entfernt werden, die vor einer beliebigen Zahl stehen. Als Parameter haben wir "ri" übergeben, so dass unser Suchtext [0-9] als regulärer Ausdruck interpretiert wird (r) und die gefundene Zahl als erstes Zeichen am Zeilenanfang stehen bleibt (i).
• Hinten sollen dagegen alle Zeichen entfernt werden, die nach dem Text "a,b" vorkommen. Als Parameter haben wir nur "c" übergeben, es soll also die Groß- und Kleinschreibung von "a,b" bei der Suche beachtet werden ("A,b" wäre kein Treffer). Da wir kein "i" als Parameter übergeben haben, wird "a,b" mit abgeschnitten und erscheint nicht am Ende. Außerdem haben wir unseren Suchtext in Anführungszeichen gesetzt, da unser Suchtext ein Komma enthält und andernfalls nicht von den Optionsparametern abzugrenzen wäre.

Wieder kann der Parameter "till_text:y,z" analog zu diesem Beispiel verwendet werden, falls die Zeichen beidseitig abgeschnitten werden sollen statt nur auf einer bestimmten Seite.

Platzhalter zum Einfügen und Anhängen von Text

Mit den beiden Funktionsplatzhaltern insert=x,y sowie append=x können Sie einen beliebigen Text einfügen (insert) oder anhängen (append). Während das Anhängen von Text immer hinten erfolgt, können Sie mit der Einfügen-Funktion die Zeichenposition für den Text selber bestimmen.

Der folgende Platzhalter steht beispielsweise für den Inhalt der ersten Zeile, in der der Text "abc" an Zeichenposition 3 eingefügt wurde:

%ref:line=1>insert=3,abc%

Falls die erste Zeile aus dem Text "12345" besteht, erhalten Sie mit diesem Platzhalter entsprechend "12abc345". In "insert=x,y" steht demnach das x für die Einfügeposition und das y für den Text, der eingefügt wird.

Der Funktionsplatzhalter "append=x" kennt dagegen nur einen Parameter. Das x steht für den Text, der an den vorhandenen Text angehängt wird. Der folgende Platzhalter steht entsprechend für die ersten 3 Zeichen, an die die 3 weiteren Zeichen "abc" angehängt wurden:

%ref:chars=1-3>append=abc%

Falls die ersten 3 Zeichen "123" sind, steht dieser Platzhalter entsprechend für "123abc".

Eine eigene separate "prepend"-Funktion zum Anhängen von Text an den Beginn eines Textes ist übrigens nicht notwendig, da der "append"-Platzhalter auch vorangestellt werden kann und damit die gleiche Funktion erfüllt:

%ref:append=->word=1%

Dieser Platzhalter steht für das erste Wort, dem das Zeichen "-" vorangestellt wurde. Dasselbe Resultat könnten wir übrigens auch mit der Insert-Funktion erzielen, falls wir als Einfügeposition "1" verwenden:

%ref:word=1>insert,1,-%

In diesem Fall wäre allerdings weder die "append"- noch die "insert"-Funktion nötig, da wir dasselbe Resultat auch erhalten würden, wenn wir statt "%ref:append=->word=1%" oder "%ref:word=1>insert,1,-%" einfach "-%ref:word=1%" schreiben würden. Sprich, wir können den Bindestrich in diesem Fall auch ganz aus dem Platzhalter herausnehmen und ihn stattdessen direkt als Text in die Funktion schreiben, in der wir die Referenz verwenden möchten.

Dasselbe gilt natürlich nicht nur für Texte, die wir an den Beginn voranstellen möchten, sondern auch für Texte, die wir an das Ende anhängen möchten. Da der "append"-Funktionsplatzhalter Texte ausschließlich an das Ende anhängt, ist der sinnvollste Einsatzort dieses Platzhalters demnach in kombinierten Platzhaltern als Zwischenglied. Aber auch diese Anwendung lässt sich in vielen Fällen alternativ auch durch die Verwendung von zwei statt nur einem kombinierten Platzhalter ersetzen.

Auch wenn wir in den bisherigen Beispielen nur Buchstaben und Bindestriche als Text verwendet haben, können sowohl in der insert- als auch in der append-Funktion natürlich auch Zeilenumbrüche und Tabs verwendet werden. Wie dies funktioniert ist im Abschnitt über die Verwendung von Zeilenumbrüchen und Tabs in Funktionsplatzhaltern erklärt.

Platzhalter zum Filtern des Textes

Der Funktionsplatzhalter beziehungsweise Textfilter find_text=x funktioniert wie eine Suchfunktion. In diesem Platzhalter steht x für einen regulären Ausdruck und gefunden werden alle Textfragmente, die auf diesen regulären Ausdruck passen.

Im folgenden Beispiel nutzen wir find_text, um alle Zahlen aus der ersten Zeile zu extrahieren:

%ref:line=1>find_text=[0-9]+%

Mit dem regulären Ausdruck [0-9]+ matchen wir alle Zahlen, unabhängig davon ob eine Zahl aus einer oder mehreren Ziffern besteht. Dieser Platzhalter steht also für alle Zahlen aus der ersten Zeile.

Wenn wir nicht den vollständigen Text, den der verwendete reguläre Ausdruck matcht, übernehmen möchten, können wir Klammern innerhalb des regulären Ausdrucks verwenden, um die Suche auf diese eingeschlossenen Zeichen zu begrenzen. Dadurch werden nur die Zeichen übernommen, die innerhalb der Klammer stehen, während für die Suche natürlich weiterhin der gesamte reguläre Ausdruck angewendet wird. Ein Beispiel dafür ist der folgende Platzhalter:

%ref:file=self>find_text= (a[a-t]+) %

Dieser Platzhalter steht für alle Wörter aus dem gesamten Text (file=self), die mit dem Buchstaben "a" beginnen und aus den Zeichen a bis t bestehen. Ein Wort haben wir innerhalb dieses regulären Ausdrucks so definiert, dass ein Leerzeichen vor dem ersten "a" stehen muss und das Wort mit einem weiteren Leerzeichen endet. Diese beiden Leerzeichen möchten wir allerdings nicht in unserem gefundenen Text wieder finden, weswegen wir Klammern verwenden und die Leerzeichen außerhalb dieser Klammer schreiben und damit ausschließen.

Falls der verwendete reguläre Ausdruck mehrere Textfragmente matcht, bekommen wir mit find_text jeden dieser Treffer in einer eigenen Zeile geliefert. Das ermöglicht uns, eine Zeilenreferenz nachzuschalten, um einen bestimmten dieser Treffer auszuwählen, falls wir nicht alle Treffer haben möchten. Ein Beispiel dafür ist der folgende Platzhalter:

%ref:file=self>find_text=[0-9]+>line=1%

Dieser Platzhalter steht für die erste Zahl, die in dem Text, der gerade bearbeitet wird, enthalten ist. Zuerst wird mit "file=self" der gesamte Text der eigenen Datei oder des eigenen Textes ausgewählt. Anschließend werden aus diesen Text mit "find_text=[0-9]+" alle Zahlen extrahiert (jede dieser Zahlen in einer Zeile). Zuletzt verbleibt nach Anwendung der Zeilenrferenz "line=1" nur die erste aus der Auswahl dieser Zeilen, also die Zeile, in der die erste gefundene Zahl steht. Damit steht der Platzhalter für die erste Zahl des Textes.

Auf diese Weise lässt sich jeder beliebige Treffer gezielt über dessen Nummer ansprechen. Natürlich können auch mehrere Treffer gleichzeitig ausgewählt werden:

%ref:file=self>find_text=[0-9]+>lines=3-7%

Hier wählen wir nicht mit "line=x" einen bestimmten Treffer über dessen exakte Nummer aus, sondern mit "lines=x-y" mehrere auf einmal. Entsprechend steht dieser Platzhalter für die dritte, vierte, fünfte, sechste und siebte Zahl, die im aktuellen Text vorkommt.

Wenn wir die einzelnen Treffer nicht zeilenweise untereinander aufgelistet haben möchten, können wir den Replace-Funktionsplatzhalter nutzen, um die Zeilenumbrüche durch ein anderes Zeichen oder einen anderen Text auszutauschen:

%ref:file=self>find_text=[0-9]+>lines=3-7>replace=\l,", "%

In diesem Beispiel ersetzen wir die Zeilenumbrüche (\l) durch den Text ", " und erhalten unsere 5 Zahlen dadurch nicht untereinander in mehreren Zeilen sondern komma-getrennt hintereinander.

Darüber hinaus bietet sich für manche Einsatzzwecke auch der Zeilenfilter an, der im nächsten Abschnitt vorgestellt wird. Damit lassen sich die Treffer nicht nach ihrer Erscheinungsnummer sondern über ihren Inhalt filtern.

Platzhalter zum Filtern von Zeilen

Die Funktionsplatzhalter beziehungsweise Zeilenfilter find_lines=x und find_lines=x,y sowie delete_lines=x und delete_lines=x,y dienen dem Filtern von Zeilen. Mit find_lines=x werden nur diejenigen Zeilen beibehalten, die den Text x enthalten. Mit delete_lines=x werden dagegen alle Zeilen aussortiert, die den Text x enthalten und entsprechend nur diejenigen Zeilen beibehalten, die den Text x nicht enthalten. Beide Funktionsplatzhalter können optional um den Parameter y erweitert werden, mit dem Optionen übergeben werden können, zum Beispiel um die Funktionsplatzhalter mit regulären Ausdrücken verwenden zu können.

Ein einfaches Beispiel für eine Anwendung des Zeilenfilters ist der folgende Platzhalter:

%ref:file=self>find_lines=abc%

Dieser Platzhalter steht für alle Zeilen des aktuellen Textes (file=self), die den Text "abc" enthalten.

Das Gegenteil dieses Platzhalters ist der folgende Platzhalter, der für alle Zeilen des aktuellen Textes steht, die den Text "abc" nicht enthalten:

%ref:file=self>delete_lines=abc%

Der Funktionsplatzhalter delete_lines erzeugt entsprechend ein inverses Resultat zu dem Resultat von find_lines, ansonsten arbeitet er genauso wie find_lines und kann auch mit denselben Parametern verwendet werden.

Natürlich kann das Ergebnis von find_lines oder delete_lines immer noch mehrere Zeilen umfassen, auf die das gewählte Kriterium zutrifft. Falls wir dieses Ergebnis noch weiter eingrenzen möchten, können wir dies zum Beispiel durch Zeilenreferenzen tun:

%ref:file=self>find_lines=abc>line=1%

Dieser Platzhalter steht beispielsweise für die erste Zeile des gesamten Textes, die den Text "abc" enthält. Durch die Zeilenreferenz "line=1" wird nur die erste Zeile aller möglichen Treffer beibehalten und alle anderen verworfen. Im nächsten Beispiel möchten wir dagegen nicht nur eine Zeile behalten sondern drei Zeilen ab der zweiten Zeile:

%ref:file=self>find_lines=abc>lines=2,3%

In unseren bisherigen Beispielen haben wir unabhängig von der Groß- und Kleinschreibung nach einem Text gesucht, der in den Zeilen enthalten sein muss. Statt unabhängig von der Groß- und Kleinschreibung zu suchen, können wir allerdings auch unter Beachtung der Groß- und Kleinschreibung suchen. Statt nach Text können wir auch mit regulären Ausdrücken suchen. Und anstatt dass es ausreicht, dass der Suchtext lediglich in einer Zeile vorkommen muss, um einen Treffer zu erzielen, können wir auch dafür sorgen, dass die ganze Zeile mit dem Suchtext übereinstimmen muss, um einen Treffer zu erzeugen. All diese verschiedenen Fälle lassen sich über den optionalen Parameter y steuern, den wir eingangs bereits erwähnt haben.

In den Funktionsplatzhaltern find_lines=x,y und delete_lines=x,y steht x für den Suchtext beziehungsweise für den regulären Ausdruck und y für die Parameter. Falls y den Buchstaben "r" enthält, wird x als regulärer Ausdruck interpretiert (ansonsten als Text). Falls y den Buchstaben "c" enthält, wird x unter Beachtung der Groß- und Kleinschreibung gesucht (ansonsten findet eine Suche nach "a" sowohl "a" als auch "A"). Und falls y den Buchstaben "a" enthält, muss die ganze Zeile mit x übereinstimmen, um zu matchen (ansonsten reichen nur Teile davon).

Der folgende Platzhalter steht beispielsweise für alle Zeilen, die ausschließlich Zahlen beziehungsweise Ziffern und keine sonstigen anderen Zeichen enthalten:

%ref:file=self>find_lines=[0-9]+,ra%

Als Parameter haben wir "ra" übergeben. Unser Suchtext "[0-9]+" soll entsprechend als regulärer Ausdruck interpretiert werden (r) und der gesamte Zeileninhalt muss mit diesem regulären Ausdruck übereinstimmen (a). Hätten wir den Parameter "a" weggelassen, wäre das Kriterium stattdessen, dass lediglich mindestens eine Ziffer in der Zeile enthalten sein muss, es würden also auch Zeilen gefunden werden, die andere Zeichen neben den Ziffern enthalten.

Ein Beispiel für den "c"-Parameter ist der folgende Platzhalter:

%ref:file=self>delete_lines=Das sind,c%

Dieser Platzhalter steht für alle Zeilen, in denen der Text "Das sind" nicht vorkommt. Ohne das "c" würden auch diejenigen Zeilen, die nur den Text "das sind" enthalten, aussortiert. Da wir durch das "c" aber mitteilen, dass wir Wert auf die Beachtung der Groß- und Kleinschreibung legen, müssen alle Buchstaben mit diesem Platzhalter genau in dieser Schreibweise vorkommen, um zu matchen. Hätten wir beispielsweise "ca" als Parameter genommen, würden sogar nur diejenigen Zeilen matchen, die genau den Text "Das sind" enthalten, ohne abweichende Schreibweise und ohne irgendein weiteres Zeichen.

Falls unser Suchtext ein Komma enthält, müssen wir den Suchtext in Anführungszeichen setzen, damit klar ist, dass bei dem Komma noch nicht der zweite Parameter beginnt. Das folgende Beispiel sucht beispielsweise alle Zeilen mit dem Text "a,b" unter Berücksichtigung des Parameters "c":

%ref:file=self>find_lines="a,b",c%

Die Verwendung der Zeilenfilter-Platzhalter ist natürlich an jeder beliebigen Stelle einer Kette von kombinierten Platzhaltern möglich und muss sich daher keineswegs immer nur auf den gesamten Text beziehen, wie wir es in den bisherigen Beispielen mit "file=self" gemacht haben. Der folgende Platzhalter steht beispielsweise für diejenigen der ersten 20 Zeilen, die die Zahl "1" enthalten (alle Zeilen ab der 21ten Zeile werden entsprechend nicht beachtet):

%ref:lines=1-20>find_lines=1%

Auch zur Eingrenzung von Suchergebnissen können die Zeilenfilter verwendet werden:

%ref:xml=h2>find_lines=abc%

Dieser Platzhalter steht beispielsweise für alle h2-Überschriften, die den Text "abc" enthalten. Mit der XML-Referenz "xml=h2" werden zunächst alle inneren Texte aller h2-Elemente ausgelesen. Anschließend wird find_lines dazu verwendet, diese Liste zu filtern. Dasselbe funktioniert natürlich auch für alle anderen Suchergebnisse von Referenzen oder Funktionsplatzhaltern wie zum Beispiel für die Resultate der Referenzen auf Attributwerte innerhalb von XML-Dateien oder für die Trefferlisten des Textfilters.

Platzhalter zum Umschreiben des Textes

Mit den beiden Funktionsplatzhaltern write=x und rewrite=x können Sie einen Text umschreiben oder dessen Schreibweise ändern. Dabei ändert write=x ausschließlich die Groß- und Kleinschreibung des Textes, während rewrite=x auch für tiefergehende Umschreibungen und Textänderungen verwendet werden kann. Was genau geändert werden soll, kann bei beiden Funktionsplatzhaltern über den Parameter x gesteuert werden.

Im Falle von write=x kann das x einen der Werte "lowercase", "uppercase", "uppercase_words", "uppercase_first" oder "randomcase" annehmen und damit die Groß- und Kleinschreibung des Textes ändern. Ein Beispiel dafür sehen wir hier:

%ref:word=3>write=uppercase%

Dieser Platzhalter steht für das dritte Wort geschrieben in Großbuchstaben. Bei der Auflösung dieses Platzhalters wird zuerst das dritte Wort über die verwendete Wortreferenz ausgelesen und anschließend werden durch "write=uppercase" alle Buchstaben des ausgelesenen Textes in Großbuchstaben verwandelt.

Im nächsten Beispiel kombinieren wir zwei verschiedene Änderungen der Schreibweise:

%ref:line=7>write=lowercase>write=uppercase_first%

Dieser Platzhalter steht für die siebte Zeile, die bis auf den ersten Buchstaben in Kleinbuchstaben geschrieben ist. Dafür werden die Funktionsplatzhalter write=lowercase (alle Buchstaben klein) und write=uppercase_first (den ersten Buchstaben groß scheiben) hintereinander verwendet. Zuerst wird der Inhalt der Zeile komplett in Kleinbuchstaben verwandelt, danach das erste Zeichen der Zeile in einen Großbuchstaben.

Die weiteren Werte für x bedeuten: "uppercase_words" (alle Wörter sollen mit einem Großbuchstaben beginnen) und "randomcase" (die Groß- und Kleinschreibung aller Buchstaben erfolgt zufällig).

Im Falle des Funktionsplatzhalters write=x kann das x einen der folgenden Werte annehmen: "remove_double_spaces", "remove_double_tabs", "remove_double_linebreaks", "remove_double_whitespace", "replace_diacritics", "remove_diacritics", "separate_camelcase", "encode_url", "decode_url", "encode_htmlentities", "decode_htmlentities", "encode_xmlchars", "decode_xmlchars", "insert_linebreaks_after_breaking_html_tags", "remove_tags", "link_websites" oder "link_emails".

Wieder können wir das "x" in "write=x" einfach durch einen dieser Parameter austauschen, um die Funktion anzuwenden. Das folgende Beispiel steht beispielsweise für den Inhalt der XML-Datei "datei.xml", aus dem alle Tags entfernt wurden:

%ref:file=E:\datei.xml>rewrite=remove_tags%

Das nächste Beispiel steht für den Inhalt der Datei "datei.txt", aus dem alle doppelten Zeilenumbrüche, Leerzeichen und Tabs (also mehr als eines dieser Whitespace-Zeichen hintereinander) entfernt wurden:

%ref:file=E:\datei.txt>rewrite=remove_double_whitespace%

Falls wir nur doppelte Zeilenumbrüche entfernen möchten (und keine doppelten Leerzeichen oder Tabs), könnten wir "rewrite=remove_double_linebreaks" verwenden. Analog funktionieren die Parameter "rewrite=remove_double_spaces" und "rewrite=remove_double_tabs" für die Entfernung doppelter Leerzeichen oder doppelter Tabs.

Mit "rewrite=replace_diacritics" können Umlaute in ihre Alternative verwandelt werden (ä zu ae), mit "rewrite=remove_diacritics" können Akzente von den Zeichen gelöscht werden (äá zu aa), "separate_camelcase" trennt groß und kleingeschriebene zusammenhängende Wörter ("AbcDef" zu "Abc Def") und die restlichen Parameter sollten selbsterklärend sein.

Platzhalter zum Auffüllen des Textes

Mit den beiden Funktionsplatzhaltern lpad=x,y und rpad=x,y lässt sich ein Text linksseitig (lpad) oder rechtsseitig (rpad) mit einem beliebigen Text auf eine gewünschte Länge auffüllen. Innerhalb der Platzhalter steht x für die Länge und y für den Text beziehungsweise das Zeichen, das für die Auffüllung verwendet werden soll.

Im folgenden Beispiel nutzen wir den Funktionsplatzhalter lpad um den Inhalt des CSV-Feldes der zweiten Zeile der ersten Spalte mit führenden Nullen auf eine Länge von insgesamt drei Zeichen zu bringen:

%ref:cell=1:2>lpad=3,0%

In lpad=3,0 ist entsprechend die erste Zahl (3) die gewünschte Länge während die zweite Zahl (0) als Text interpretiert wird. Hat das CSV-Feld beispielsweise den Inhalt "1" sorgt die Verwendung dieses Platzhalters dafür, statt "1" den Text "001" zu erhalten.

Im nächsten Beispiel möchten wir den Inhalt aus der ersten Zeile auf der anderen Seite, also rechtsseitig, auf eine Länge von insgesamt 10 Zeichen auffüllen:

%ref:line=1>rpad=10, -%

Dieses Mal verwenden wir für die Auffüllung kein einzelnes Zeichen sondern den Text " -", aufgefüllt wird also abwechselnd mit einem Leerzeichen und einem Bindestrich. Hat die Zeile beispielsweise den Inhalt "abcdef" erhalten wir mit Verwendung dieses Platzhalters das Ergebnis "abcdef - -".

Platzhalter für die Bearbeitung von Zahlen

Mit dem Funktionsplatzhalter inc=x können Sie alle Zahlen innerhalb des Textes Ihrer Referenz um den Wert x erhöhen. Wenn Sie eine negative Zahl für x verwenden, werden alle Zahlen innerhalb des Textes um den Wert x reduziert.

Als Beispiel für diesen Funktionsplatzhalter möchten wir uns eine Zeilenreferenz ansehen. Die erste Zeile des Textes, die wir mit der Referenz %ref:line=1% auslesen können, enthält den Text "1 abc 2 def 3 ghi 10 jkl". Anschließend ergänzen wir diese Referenz um den Funktionsplatzhalter inc=x um alle Zahlen innerhalb dieser Zeile um 1 oder 2 zu erhöhen sowie um 1 zu reduzieren. Die dafür benötigten Platzhalter sowie das Ergebnis bei Verwendung dieser Platzhalter sehen wir der folgenden Tabelle:

Wenn Sie nicht jede der Zahlen innerhalb des Textes der Referenz bearbeiten möchten, können Sie den Funktionsplatzhalter um einen weiteren Parameter erweitern: Mit inc=x,y können Sie nur diejenige Zahl um x erhöhen oder reduzieren, die sich an Position y innerhalb des Textes Ihrer Referenz befindet. Mit positiven Zahlen für y zählen Sie die Position von vorne, mit negativen Zahlen für y zählen Sie die Position von hinten. Die erste Zahl innerhalb des Textes Ihrer Referenz entspricht dabei Position 1, die zweite Zahl entspricht Position 2 und so weiter.

Auch dafür möchten wir uns ein Beispiel ansehen. Wieder verwenden wir dieselbe Zeilenreferenz, die wir bereits in unseren ersten Beispielen verwendet haben:

In der Tabelle sehen Sie neben der unbearbeiteten Zeile vier verschiedene Bearbeitungen mit dem Funktionsplatzhalter inc=x,y. Im ersten Beispiel erhöhen wir mit inc=1,1 die erste Zahl um 1. im zweiten Beispiel erhöhen wir mit inc=2,2 die zweite Zahl um 2. Obwohl wir in den letzten beiden Beispielen unterschiedliche Parameter verwenden, führen beide Beispiele zum selben Ergebnis. Im ersten Fall zählen wir die Positionen der Zahlen von vorne und reduzieren mit inc=-3,4 die Zahl an der vierten Position um 3. Im zweiten Fall zählen wir die Position der Zahlen von hinten und reduzieren mit inc=-3,-1 die Zahl an der letzten Position (die erste Position von hinten) ebenfalls um 3. Da die erste Position von hinten der vierten Position von vorne entspricht, führen beide Beispiele zum selben Ergebnis.

Zeilenumbrüche und Tabs in den Funktionsplatzhaltern verwenden

Wenn Sie in den Funktionsplatzhaltern "replace=x,y", "replace=x,y,z", "replace_regex=x,y", "delete=x", "delete_regex=x", "delete_chars=x", "append=x", "insert=x,y", "find_text=x", "find_lines=x", "find_lines=x,y", "delete_lines=x" oder "delete_lines=x,y" Zeilenumbrüche oder Tabs verwenden möchten, können Sie dafür die Platzhalter \l, \r, \n sowie \t verwenden. Dabei steht "\l" für den Zeilenumbruchtyp des Systems, "\t" für einen Tab und "\r" sowie "\n" für die Codepoints U+000D sowie U+000A, womit es möglich ist, Zeilenumbruchtypen verschiedener Systeme nachzubilden. Im folgenden möchten wir uns für all diese Platzhaltertypen Beispiele ansehen.

%ref:line=1>replace=\t, %

Dieser Platzhalter steht für die erste Zeile, in der alle Tabs mit Hilfe des Replace-Funktionsplatzhalters durch Leerzeichen ersetzt wurden. Während das Leerzeichen als solches in den Funktionsplatzhalter eingefügt wurde, wurde für den Tab der Platzhalter "\t" verwendet.

%ref:file=E:\file1.txt>append=\l\l>=E:\file2.txt%

Dieser Platzhalter steht für die Inhalte der Dateien "file1.text" sowie "file2.txt", zwischen die zwei Zeilenumbrüche mit Hilfe der Append-Funktion geschrieben wurden. Da der Platzhalter "\l" (Systemzeilenumbruchtyp) verwendet wurde, hängt das Ergebnis davon ab, auf welchem System dieser Platzhalter verwendet wird. Auf Windows-Systemen wird ein Zeilenumbruch durch die beiden Zeichen 0D und 0A hintereinander ausgedrückt, so dass auf Windows-Systemen "\l" für "0D 0A" steht und entsprechend zweimal diese beiden Zeichen zwischen die Dateiinhalte geschrieben werden, sofern der Platzhalter auf einem Windows-System verwendet wird.

Im Gegensatz zu Windows verwendet macOS nur das Zeichen 0A für einen Zeilenumbruch. Auf einem Mac würde der Platzhalter "\l" entsprechend für "0A" stehen. Versucht man eine Datei, die auf einem Mac gespeichert wurde, auf einem Windows-System zu öffnen, kann dies daher in manchen Programmen zu einer falschen Darstellung führen. Dies führt uns zu den Platzhaltern \r und \n, von denen \r für 0D steht und \n für 0A. Mit anderen Worten können wir - unabhängig vom "\l"-Platzhalter - den macOS-Zeilenumbruch mit \n nachbilden und den Windows-Zeilenumbruch mit \r\n. Beide Varianten kommen in der nächsten Referenz vor:

%ref:file=D:\macfile.txt>replace=\n,\r\n%

Dieser Platzhalter referenziert den Inhalt der Datei "macfile.txt", in denen alle macOS-Zeilenumbrüche (\n) durch Windows-Zeilenumbrüche (\r\n) mit Hilfe des Replace-Funktionsplatzhalters ausgetauscht wurden. Diesen Platzhalter kann man also zum Beispiel verwenden, wenn man den Inhalt von Dateien, die auf einem Mac gespeichert wurden, in Windows-Textdateien einfügen möchte, ohne die Mischung aus verschiedenen Zeilenumbruchtypen später reparieren zu müssen.

Bisher haben wir die Platzhalter für Zeilenumbrüche und Tabs nur alleine verwendet. Natürlich ist aber auch eine Kombination mit beliebigen anderen Zeichen möglich. Der folgende Platzhalter hängt zum Beispiel an die ersten drei Zeilen die drei weiteren Zeilen "abc", "def" sowie "ghi" an:

%ref:lines=1-3>append=\labc\ldef\lghi%

Zuletzt möchten wir uns ein letztes Beispiel dafür ansehen, was wir tun können, wenn wir "\r", "n", "\l" oder "\t" als Text verwenden möchten, ohne dass dieser als Zeilenumbruch oder als Tab interpretiert wird. In diesem Fall können wir einfach ein weiteres "\" vor den Platzhalter schreiben und den Platzhalter damit escapen:

%ref:line=1>replace=\\r\\n,\\l%

Dieser Platzhalter steht entsprechend für die erste Zeile, in der der Text "\r\n" durch "\l" ersetzt wurde.

Das ">"-Zeichen in den Funktionsplatzhaltern nutzen

Das Zeichen ">" hat innerhalb von Platzhaltern für Referenzen eine besondere Bedeutung. Es dient als Trennzeichen, mit dem mehrere einzelne Referenzen untereinander sowie mit Funktionsplatzhaltern kombiniert werden können. Aus diesem Grund kann dieses Zeichen nicht einfach als solches innerhalb von Funktionsplatzhaltern verwendet werden, da ansonsten unklar wäre, ob das Zeichen als Text interpretiert werden soll oder als Beginn eines neuen Kettengliedes innerhalb mehrerer verknüpfter Platzhalter. Stattdessen muss das Zeichen doppelt geschrieben werden, wenn es als Text interpretiert werden soll.

Ein Beispiel für beide Fälle ist der folgende Platzhaltzer, der das ">"-Zeichen in seinen beiden Verwendungsformen enthält:

%ref:lines=1-10>find_lines=>>%

Das einfache ">" steht zwischen den beiden Gliedern des Platzhalters und trennt damit die Zeilenreferenz "lines=1-10" von "find_lines=>>". Das doppelte ">>" wird in dem Funktionsplatzhalter "find_lines" verwendet und steht dort für den Text ">". Dieser Platzhalter steht also für diejenigen der ersten 10 Zeilen, die das Zeichen ">" enthalten. Dabei reicht innerhalb der Zeilen ein einfaches ">" für einen Treffer, auch wenn eine Zeile, die ">>" enthält, natürlich auch diesen Zeilenfilter matchen würde. Diese Art der Interpretation verdeutlicht auch das folgende Beispiel:

%ref:line=1>replace=a>>b,a<b%

Dieser Platzhalter steht für die erste Zeile, in der der Text "a>b" durch den Text "a<b" ersetzt wurde.

Kombination verschiedener Referenzen und Funktionsplatzhalter

Wie Sie vielleicht bereits in den zahlreichen Beispielen dieses Tutorials gesehen haben, lassen sich Platzhalter für Referenzen und Funktionsplatzhalter beliebig miteinander und untereinander kombinieren. In diesem Abschnitt möchten wir uns kurz diesem Thema widmen und aufzeigen, was es bei der Verkettung der Platzhalter zu beachten gibt.

Aufbau kombinierter Platzhalter

Zunächst gilt es zu beachten, dass jeder Platzhalter für Referenzen mit "%ref:" beginnt und mit "%" endet. Dazwischen kann entweder eine einzelne Referenz stehen...

%ref: ... %

...oder auch beliebig viele Referenzen und Funktionen, die dann mit einem ">" voneinander getrennt sind:

%ref: ... > ... > ... %

Das ">"-Zeichen deutete dabei nicht ohne Grund einen Pfeil an, der vom ersten Bestandteil des Platzhalters über alle Elemente der Kette hinweg bis hin zum letzten Bestandteil des Platzhalters zeigt, denn genau dies ist der Weg den der TextKonverter bei der Interpretation eines Platzhalters geht: Der TextKonverter beginnt mit einem leeren String, der dann über die einzelnen Teile des Platzhalters hinweg gesetzt, eingegrenzt oder bearbeitet wird.

Beispiel für die Interpretation eines kombinierten Platzhalters

Diese Vorgehensweise möchten wir uns Schritt für Schritt anhand des folgenden Platzhalters ansehen:

%ref:file=E:\text.txt>trim=whitespace>line=1>word=2>chars=1-3>rewrite=uppercase%

Bei der Interpretation dieses Platzhalters wird der TextKonverter folgendermaßen vorgehen:

• Der TextKonverter beginnt beim ersten Glied der Kette. Dies ist eine Datei-Referenz auf die Datei "E:\text.txt". Demnach liest der TextKonverter als erstes diese Datei aus und setzt den Text der Referenz auf den Inhalt der Datei. Wäre der Platzhalter an dieser Stelle vorbei, würde der Platzhalter für den Inhalt der Datei stehen und der Platzhalter entsprechend in den Funktionen des TextKonverters durch den Inhalt der Datei ersetzt. Dies ist aber in unserem Beispiel nicht der Fall, da der Platzhalter mit einem ">" weitergeht und damit auf das nächste Glied der Kette zeigt.
• Das nächste Glied ist keine Referenz, sondern eine Funktion. Genauer gesagt die Trim-Funktion mit dem Parameter "whitespace", die dafür sorgt, dass Leerzeichen, Zeilenumbrüche und anderer Whitespace vorne und hinten vom Text entfernt werden. In diesem Schritt wird also der eben ausgelesene Text aus der Datei genommen und möglicher Whitespace vom Beginn und Ende dieses Textes entfernt.
• Das dritte Glied der Kette ist wieder eine Referenz. Dieses Mal ist es eine Zeilen-Referenz auf die erste Zeile. Das heißt, der TextKonverter nimmt den aktuellen Text der Referenz (den Inhalt der Datei ohne den Whitespace) und liest daraus die erste Zeile aus, um damit weiterzumachen. Den Whitespace haben wir vorher entfernt für den Fall dass die Datei mit leeren Zeilen beginnt und die erste Zeile daher leer sein könnte.
• Das vierte Glied der Kette ist abermals eine Referenz, genauer gesagt eine Wort-Referenz und zwar auf das zweite Wort. Der TextKonverter schränkt den Text aus der Datei also weiter ein und setzt die Referenz auf das zweite Wort der ausgelesenen Zeile.
• Noch weiter eingegrenzt wird der Text im fünften Glied. Dieses Mal extrahieren wir aus dem bis zu diesem Zeitpunkt extrahierten zweiten Wort der ersten Zeile der Datei die ersten 3 Buchstaben mit einer Zeichen-Referenz und machen damit weiter.
• Nun kommen wir zum letzten Glied der Kette. Dieses Mal gibt es wieder eine Funktion. Es ist die Rewrite-Funktion, die mit dem Parameter "uppercase" aufgerufen wird, der dafür sorgt dass alle Buchstaben groß geschrieben werden.

Damit endet unsere Referenz, die zu diesem Zeitpunkt aus 3 groß geschriebenen Buchstaben besteht, die ursprünglich aus der Datei "E:\text.txt" stammen und möglicherweise zunächst klein geschrieben waren. Mit diesen 3 Buchstaben wird der TextKonverter an der Stelle, an der Sie diese Referenz eingefügt haben, arbeiten.

Spezialfälle und Einschränkungen

Grundsätzlich gibt es weder Einschränkungen hinsichtlich der Anzahl kombinierter Platzhalter noch hinsichtlich der Position der einzelnen Bestandteile. Prinzipiell können Sie jeden Platzhalter und jede Funktion also an jeder beliebigen Stelle innerhalb der Kette verwenden. Trotzdem sollen einige Besonderheiten nicht unerwähnt bleiben:

• Funktionsplatzhalter können zwar auch an jeder Position stehen, ergeben aber nur ab der zweiten Position in der Kette einen Sinn. Der Grund dafür ist, dass Funktionsplatzhalter immer den aktuellen Text in der Kette bearbeiten. Zu Beginn ist dieser Text allerdings ein leerer String. Dieser kann zwar auch "bearbeitet" werden (zum Beispiel mit der Auffüllen-Position), dann würde es aber mehr Sinn machen, direkt den gewünschten Text einzufügen anstatt den Platzhalter.
• Referenzen auf Dateien ergeben dagegen nicht nur an der ersten Position der Kette einen Sinn. Man könnte vielleicht annehmen, dass sobald eine Referenz auf eine Datei in der Kette steht, der gesamte bis zu diesem Punkt erzeugte Text durch den Inhalt der Datei überschrieben wird, wodurch die Glieder vor der Datei-Referenz keinerlei Wirkung entfalten könnten und daher auch keinen Einfluss auf das Ergebnis hätten und weggelassen werden könnten. Dies ist aber nicht der Fall. Wenn zum Zeitpunkt des Aufrufs einer Datei-Referenz bereits ein Text innerhalb der Referenz vorhanden ist, wird der Inhalt der Datei an den vorhandenen Text angehängt. So ist es zum Beispiel möglich, mehrere Datei-Referenzen innerhalb eines Platzhalters hintereinander zu schreiben und damit die Inhalte mehrerer Dateien auszulesen und mit einem einzigen Platzhalter einzufügen.
• Die Attribut-Referenz ergibt nur nach einer XML-Referenz einen Sinn, da sie sich immer auf das zuvor ausgewählte Element (oder Elemente) aus einer XML-Struktur bezieht. Wird diese Referenz an einer anderen Position verwendet, hat die Referenz keinerlei Wirkung.
• Kommata innerhalb von Funktionsplatzhaltern mit mehr als einem Parameter müssen in Anführungszeichen gesetzt werden, damit klar ist, ob ein Komma als Text oder als Trennzeichen zwischen den Parametern zu interpretieren ist. Ein Beispiel wäre eine Ersetzung von "a,b" durch "c,d" mit der Replace-Funktion: replace="a,b","c,d" statt replace=a,b,c,d.
• Zeilenumbrüche und Tabs können in den Funktionsplatzhaltern als "\l" oder "\t" geschrieben werden. Mehr dazu im Abschnitt über Zeilenumbrüche und Tabs in Funktionsplatzhaltern.
• Da das ">"-Zeichen als Trennzeichen zwischen den einzelnen Gliedern gilt, darf es nicht alleine innerhalb der Glieder verwendet werden. Wenn Sie das ">"-Zeichen innerhalb der Glieder verwenden möchten und es nicht als Kombination interpretiert werden soll, zum Beispiel in der Ersetzen-Funktion oder als XML-Selektor, müssen Sie das Zeichen doppelt schreiben. Also zum Beispiel "xml=ul>>li" statt "xml=ul>li".

Darüber hinaus gibt es keine weiteren Einschränkungen für die Verwendung kombinierter Referenzen und Funktionsplatzhalter.

Referenzen in Aktionslisten

Referenzen können nicht nur in den Textfeldern einzelner Aktionen verwendet werden, sondern auch in Aktionslisten. Auch in diesem Fall können die Platzhalter einfach in die Aktionen hineingeschrieben werden und wahlweise auch mit anderen Zeichen oder Platzhaltern kombiniert werden.

So können in den Aktionen der Aktionslisten Platzhalter für Referenzen zum Beispiel als alleiniger Parameter verwendet werden wie in dem folgenden Beispiel, das das Zeichen "~" durch den Text aus der ersten Zeile ersetzt:

REPLACE ~ %line=1%

Natürlich ist es auch möglich, in beiden Parametern Platzhalter für Referenzen zu verwenden, wie in dem folgenden Beispiel, das in den Zeilen 3 bis 10 den Text aus der ersten Zeile mit dem Text aus der zweiten Zeile mit der Hilfe von Zeilenreferenzen ersetzt:

REPLACE_IN_LINES 3-10 %line=1% %line=2%

Auch Funktionen können problemlos in den Parametern von Aktionslisten verwendet werden. Im folgenden Beispiel nutzen wir die APPEND-Aktion innerhalb einer Aktionsliste, um den Text aus der ersten Zeile anzuhängen, der vor dem Anhängen mit der Trim-Funktion innerhalb des Platzhalters noch vor dem Einfügen bearbeitet wird:

APPEND %line=1>trim=whitespace%

Ein anderes Beispiel, das den Gebrauch von Funktionen mit der doppelten Verwendung von Platzhaltern kombiniert, ist die folgende Aktion einer Aktionsliste, die mit der Hilfe der FindLines-Funktion den gesamten Inhalt eines Textes nur durch die Zeilen desselben Textes ersetzt, die den Text "abc" enthalten:

REPLACE %ref:file=self% %ref:file=self>find_lines=abc%

Darüber hinaus ist es natürlich auch möglich, die Platzhalter für Referenzen mit anderen Zeichen und Platzhaltern zu kombinieren, wie die folgende Aktionsliste zeigt:

REPLACE -- -%chars=1-3%-
REPLACE " %word=2-4% " " %word=2% %date% %word=4% "
DELETE " %word=3% "

Wie auch in jedem anderen Fall, in dem Text als Parameter von Aktionen innerhalb einer Aktionsliste verwendet wird, ist auch bei der Verwendung von Platzhaltern darauf zu achten, die Parameter in Anführungszeichen zu setzen, falls sie Leerzeichen enthalten sollten. Falls die Parameter keine Leerzeichen enthalten, wie bei der Aktion in der ersten Zeile, sind keine Anführungszeichen nötig. Das Beispiel in der zweiten Zeile zeigt, dass selbstverständlich auch nicht referenzierende Platzhalter wie hier der Platzhalter für das aktuelle Datum (%date%) beliebig mit anderen Zeichen und Platzhaltern für Referenzen kombiniert werden können.

Referenzen in Dateinamen

Im TextKonverter können Referenzen auch dazu verwendet werden, den Speicherort oder den Dateinamen für die Speicherung konvertierter Dateien aus Teilen des Inhaltes der Dateien zu generieren. Dafür können die in diesem Tutorial vorgestellten Platzhalter für Referenzen in den Feldern "Ordner", "Name" und "Dateiendung" der Speicheroptionen des TextKonverters verwendet und mit beliebigen anderen Zeichen und Platzhaltern kombiniert werden.

Wenn Sie zum Beispiel als Ordner "%folder%\%ref:word=1%" angeben, wird in dem Ordner, in dem sich die Originaldatei befindet (%folder%) für die Speicherung der konvertierten Datei ein neuer Ordner angelegt, dessen Name dem ersten Wort aus der Datei (%ref:word=1%) entspricht. Wenn Sie als Name zum Beispiel "%ref:line=1%" angeben, wird als Dateiname die erste Zeile aus der Datei verwendet. Und wenn Sie als Name "%name% (%chars=1-10%)" angeben, werden die ersten 10 Zeichen der Datei in Klammern an den vorhandenen Namen der Datei (%name%) angehängt.

Im Gegensatz zu den Referenzen innerhalb der Aktionen ist es für die Verwendung von Referenzen in Dateinamen nicht erforderlich, die Option "Aktionen > Optionen > Referenzen" zu aktivieren: Referenzen sind innerhalb der Speicheroptionen immer aktiv und werden daher automatisch ersetzt. Dies entspricht dem Verhalten der sonstigen Platzhalter, die in den Speicheroptionen ebenfalls immer aktiv sind.

Natürlich könnten die referenzierten Texte auch Zeichen wie zum Beispiel ":", "\", "<" oder ">" enthalten, die innerhalb von Dateinamen nicht erlaubt sind. Mit der Option "Einstellungen > Allgemein > Dateiname > Ersetzung für unerlaubte Zeichen in Dateinamen" können Sie einen Text festlegen, der statt diesen unerlaubten Zeichen verwendet wird, der die unerlaubten Zeichen also ersetzt. Voreingestellt ist das Zeichen "_", Sie können aber zum Beispiel auch ein Leerzeichen oder jedes beliebige andere Zeichen oder einen anderen Text angeben. Wenn Sie das Feld komplett leer lassen, werden die unerlaubten Zeichen lediglich gelöscht und nicht durch ein anderes Zeichen oder einen anderen Text ersetzt.

Innerhalb der Dateiliste ist die Vorschau für Dateinamen, die Referenzen enthalten, aus Performance-Gründen deaktiviert. Sie können aber einzelne Dateien in der Dateiliste auswählen und damit eine Vorschau des Dateinamens unterhalb des Vorschau-Textes der Datei anzeigen.

Referenzen in Skripts

Auch wenn Sie den TextKonverter über ein Skript steuern, muss die Verwendung von Referenzen aktiviert werden, damit die Platzhalter für Referenzen in den Aktionen ersetzt werden. Andernfalls werden die Platzhalter als normaler Text betrachtet. Das Verhalten ist im Falle einer Skriptsteuerung des TextKonverters also genauso wie bei einer Steuerung über die graphische Benutzeroberfläche (mehr zur Aktivierung und Deaktivierung der Referenz-Platzhalter im Abschnitt über die Grundlagen der Verwendung von Referenzen).

Die Aktivierung von Referenzen können Sie sowohl über Einstellungsdateien als auch über den Parameter "ref=1" vornehmen. Wenn Sie Einstellungsdateien verwenden, achten Sie einfach darauf dass Sie die Option "Aktionen > Optionen > Referenzen" vor der Speicherung der Einstellungsdatei aktivieren. Wenn Sie keine Einstellungsdateien verwenden, zum Beispiel falls Sie Aktionen oder Aktionslisten direkt über Parameter definieren, übergeben Sie einfach zusätzlich den Parameter "ref=1", wie in dem folgenden Beispiel gezeigt, das in der Datei "test.txt" das Zeichen "~" durch den Inhalt der ersten Zeile ersetzt:

TextKonverter.exe -cl C:\test.txt "a=REPLACE ~ %%ref:line=1%%" ref=1

Mehr zu diesem Thema erfahren Sie im Tutorial über die Skriptsteuerung des TextKonverters im Abschnitt über die Parameter für die Aktivierung von Platzhaltern und Referenzen.

Übersicht über alle Platzhalter für Referenzen

In der folgenden Tabelle finden Sie eine Übersicht über alle unkombinierten Platzhalter für Referenzen, die Sie in den Textfeldern des TextKonverters nutzen können. In der ersten Spalte sind die Platzhalter aufgeführt, in den nächsten Spalten finden Sie eine Kurzbeschreibung sowie einen Link zu dem Abschnitt dieses Tutorials, in dem der jeweilige Platzhalter detailliert erklärt wird und Sie darüber hinaus einige Beispiele für die Verwendung des Platzhalter finden.

Alle aufgeführten Platzhalter lassen sich untereinander sowie mit den Funktionsplatzhaltern, die im nächsten Abschnitt aufgeführt sind, beliebig kombinieren. Damit lässt sich der referenzierte Text zum Beispiel vor dem Einfügen bearbeiten oder Sie können zum Beispiel nur bestimmte Zeichen oder nur bestimmte Wörter aus Zeilen oder Dateien übernehmen. Mehr dazu erfahren Sie im Abschnitt über die Kombination von Platzhaltern.

Übersicht über alle Funktionsplatzhalter für Referenzen

In der folgenden Tabelle sehen Sie eine Übersicht über alle im TextKonverter verfügbaren Funktionsplatzhalter, die Sie mit den Platzhaltern für Referenzen aus dem letzten Abschnitt kombinieren können. In der ersten Spalte sind die Platzhalter aufgeführt, in der zweiten Spalte finden Sie deren Beschreibung. In der dritten Spalte befindet sich ein Link zu dem Abschnitt dieses Tutorials, in dem die betreffende Platzhalterfunktion detailliert erklärt und mit Beispielen vorgestellt wird.

Wenn Sie einen oder mehrere dieser Funktionsplatzhalter hinter einem Platzhalter für Referenzen einfügen, wird der Text der Referenz gemäß der Funktion, für die der Funktionsplatzhalter steht, bearbeitet. Beispielsweise steht der kombinierte Platzhalter %ref:line=1>write=uppercase% für den Text aus der ersten Zeile konvertiert in Großbuchstaben. Es können auch mehrere Funktionsplatzhalter gleichzeitig angewendet werden, indem diese einfach hintereinander geschrieben werden. Mehr zu diesem Thema erfahren Sie in den Abschnitten über Funktionsplatzhalter und über die Kombination von Platzhaltern.