Text-Funktionen sind essentielle Werkzeuge für die Manipulation, Formatierung und Transformation von Textinhalten in Ihren Vorlagen. Sie ermöglichen die professionelle Aufbereitung von Kundendaten, Adressen und anderen textbasierten Informationen.

Textmanipulation

Grundlegende Manipulation

Einfache Manipulationen wie das Konvertieren in Klein- oder Großbuchstaben, das Entfernen von Leerzeichen oder das Konvertieren in Satzformat sind die Grundlage für die weitere Verarbeitung von Texten.

Funktion	Beschreibung
`toLowerCase(string)`	Konvertiert Text in Kleinbuchstaben
`toUpperCase(string)`	Konvertiert Text in Großbuchstaben
`titleCase(string)`	Konvertiert ersten Buchstaben jedes Wortes
`toSentence(string)`	Konvertiert Text in Satzformat
`trim(string)`	Entfernt Leerzeichen am Anfang und Ende

Original: [<<{name}>>]
toLowerCase: <<{toLowerCase(name)}>>
toUpperCase: <<{toUpperCase(name)}>>
titleCase: <<{titleCase(name)}>>
trim: [<<{trim(name)}>>]
toSentence: <<{toSentence(text)}>>

Erweiterte Manipulation

Textmanipulation-Funktionen helfen dabei, Zeichen, ganze Wörter oder ganze Textabschnitte in einem Text zu ersetzen.

Funktion	Beschreibung
`replace(string, oldChar, newChar)`	Ersetzt Zeichen in einem Text
`replaceStr(string, search, replace, [ignoreCase])`	Ersetzt Zeichenketten
`replaceFirst(string, search, replace, [ignoreCase])`	Ersetzt erstes Vorkommen
`squote(string)`	Ersetzt doppelte durch einfache Anführungszeichen

Original: <<{text}>>
replace: <<{replace(nummer, '-', '_')}>>
replaceStr: <<{replaceStr(text, 'GmbH', 'AG')}>>
replaceFirst: <<{replaceFirst(doppelt, 'Test', 'Demo')}>>
squote: <<{squote(text)}>>

Textanalyse

Textanalyse-Funktionen ermöglichen die Untersuchung und Auswertung von Textinhalten. Sie helfen dabei, spezifische Informationen aus Texten zu extrahieren, Positionen zu bestimmen und Eigenschaften zu prüfen.

Positionsanalyse

Wichtig - 0-basierte Indexierung: Alle Positionsfunktionen verwenden eine 0-basierte Indexierung. Das bedeutet, das erste Zeichen in einem Text hat die Position 0, das zweite Zeichen die Position 1, usw.

Beispiel: In "STROM" ist:

Position 0 = 'S'
Position 1 = 'T'
Position 2 = 'R'
Position 3 = 'O'
Position 4 = 'M'

Funktion	Beschreibung
`charAt(string, position)`	Zeichen an Position
`indexOf(string, find, [startIdx])`	Position eines Subtextes
`length(string)`	Länge eines Textes

E-Mail: <<{email}>>
Erstes Zeichen: <<{charAt(email, 0)}>>
@ Position: <<{indexOf(email, '@')}>>
- Position: <<{indexOf(zähler, '-')}>>
E-Mail Länge: <<{length(email)}>> Zeichen
Zähler Länge: <<{length(zähler)}>> Zeichen

Textprüfung

Textprüfung-Funktionen helfen dabei, bestimmte Teile von Texten zu prüfen. Sie geben einen boolschen Wert zurück, der angibt, ob der Text bestimmte Bedingungen erfüllt, und können damit in bedingte Verarbeitungsschritte eingesetzt werden.

Funktion	Beschreibung
`startsWith(mainString, subString)`	Prüft Präfix
`endsWith(mainString, subString)`	Prüft Suffix
`equalsIgnoreCase(string1, string2)`	Vergleich ohne Groß-/Kleinschreibung
`countStr(string, searchFor, [ignoreCase])`	Zählt Vorkommen

Vertragsnummer: <<{vertrag}>>
Ist Strom: <<{map(startsWith(vertrag, 'STROM'), true, 'Ja', 'Nein')}>>
Ist PDF: <<{map(endsWith(datei, '.pdf'), true, 'Ja', 'Nein')}>>
Beide Status gleich: <<{map(equalsIgnoreCase(status1, status2), true, 'Ja', 'Nein')}>>
Anzahl 'test' im String: <<{countStr(text, 'test', true)}>>

Textextraktion

Teilstring-Funktionen

Textextraktion-Funktionen geben einen neuen Text zurück, der nur den extrahierten Teil enthält.

Funktion	Beschreibung
`substring(string, start, finish)`	Extrahiert Teilstring
`left(string, finish)`	Extrahiert linken Teil
`right(string, start)`	Extrahiert rechten Teil
`split(string, splitChar, index)`	Teilt Text und gibt Index zurück

Spezialkonvertierung

Spezialkonvertierungen sind nützlich, wenn Sie Sonderzeichen aus dem ASCII-Zeichensatz benötigen oder eine Zahl (zBsp. Fehlercode) in eine Buchstabenfolge umwandeln möchten.

Funktion	Beschreibung
`char(code)`	Zeichen basierend auf Code
`toAlpha(number)`	Zahl zu Buchstabenfolge (a,b,c...aa,bb,cc)
`toAlpha2(number)`	Zahl zu Buchstabenfolge (a,b,c...aa,ab,ac)
`toRoman(number)`	Zahl zu römischen Zahlen

ASCII-Code 169: <<{char(169)}>>
HTML dezimal: <<{char('&#169')}>>
Java/JSON Format: <<{char('\ua9')}>>

Aufzählung (wiederholend):
Punkt <<{zahl1}>>: <<{toAlpha(zahl1)}>>
Punkt <<{zahl27}>>: <<{toAlpha(zahl27)}>>
Punkt <<{zahl28}>>: <<{toAlpha(zahl28)}>>

Excel-Spalten (fortlaufend):
Spalte <<{zahl1}>>: <<{toAlpha2(zahl1)}>>
Spalte <<{zahl27}>>: <<{toAlpha2(zahl27)}>>
Spalte <<{zahl28}>>: <<{toAlpha2(zahl28)}>>

Römische Zahlen:
Kapitel <<{kapitel}>>: <<{toRoman(kapitel)}>>

Die char()-Funktion unterstützt verschiedene Eingabeformate für Zeichencodes:

Dezimal: char(169) für ©
HTML Dezimal: char('&#169') für ©
Java/JSON: char('\ua9') für © (Unicode-Escape-Sequenz)

Externe Referenzen:

ASCII-Zeichentabelle - Vollständige ASCII-Zeichentabelle mit dezimalen, oktalen, hexadezimalen und HTML-Codes
HTML Character Entities (W3C) - Offizielle W3C-Spezifikation für HTML-Character-Entities
Java Unicode Escapes (Oracle) - Oracle Java Language Specification für Unicode-Escape-Sequenzen

Unterschied zwischen toAlpha() und toAlpha2():

toAlpha(): Wiederholende Buchstaben → a, b, c, ... z, aa, bb, cc, ... zz, aaa, bbb
toAlpha2(): Excel-Spalten-Logik → a, b, c, ... z, aa, ab, ac, ... az, ba, bb

Beispiel bei Zahl 28:

toAlpha(28) → bb (28. Buchstabe = b wiederholt)
toAlpha2(28) → ab (wie Excel-Spalte AB)

Anwendungsszenarien

Vertragsnummer-Validierung

Vertragsnummer: <<{vertragsnummer}>>
Typ: <<{map(startsWith(vertragsnummer, 'STROM'), true, 'Stromvertrag', 'Anderer Vertrag')}>>
Jahr: <<{substring(vertragsnummer, indexOf(vertragsnummer, '-') + 1, indexOf(vertragsnummer, '-') + 5)}>>
Laufende Nummer: <<{right(vertragsnummer, 6)}>>

E-Mail-Normalisierung mit Validierung

<<$cleanEmail=toLowerCase(trim(email))>>
<<$domain=substring($cleanEmail, indexOf($cleanEmail, '@') + 1, length($cleanEmail))>>
<<$hasValidDomain={map(indexOf($domain, '.'), -1, false, true)}>>

Original: [<<{email}>>]
Normalisiert: <<{$cleanEmail}>>
Domain: <<{$domain}>>
Gültige Domain: <<{map($hasValidDomain, true, 'Ja', 'Nein')}>>

Automatische Buchstaben-Aufzählung

<<rs_tarife>>
Tarifgruppe <<{toAlpha($itemnum)}>>: <<{name}>> - <<{grundpreis}>> €
<<es_>>

Vertragsklauseln mit römische Zahlen

<<rs_klauseln>>
§ <<{toRoman($itemnum)}>>. <<{titel}>>
<<es_>>

Lesbarkeit mit Teilstring-Extraktion

Vertragsnummer-Analyse:
Vertragsnummer: <<{vertrag}>>
substring (5-9): <<{substring(vertrag, 5, 9)}>>
left (5): <<{left(vertrag, 5)}>>
right (6): <<{right(vertrag, 6)}>>

Adress-Aufspaltung:
Adresse: <<{adresse}>>
Name: <<{split(adresse, ';', 0)}>>
Straße: <<{split(adresse, ';', 1)}>>
Ort: <<{split(adresse, ';', 2)}>>

Zählernummer-Codierung:
Zählernummer: <<{zaehlerNr}>>
Präfix: <<{left(zaehlerNr, 2)}>>
Jahr: <<{substring(zaehlerNr, 3, 7)}>>
Laufnummer: <<{right(zaehlerNr, 5)}>>

Performance und Best Practices

Zwischenvariablen nutzen: Bei komplexen String-Operationen verwenden Sie Variablen für bessere Lesbarkeit:

<<$cleanText=toLowerCase(trim($rawText))>>
<<$processedText=replaceStr($cleanText, 'alt', 'neu')>>

String-Syntax beachten: Verwenden Sie immer einfache Anführungszeichen (') in Funktionsparametern:

✅ Richtig: titleCase('text')
❌ Falsch: titleCase("text")

E-Mail-Normalisierung

Bereinigung: trim() für Leerzeichen
Normalisierung: toLowerCase() für einheitliche Schreibweise
Validierung: indexOf('@') für Grundvalidierung
Extraktion: substring() für Domain-Analyse

Adressformatierung

Segmentierung: split() für mehrzeilige Adressen
Formatierung: titleCase() für Eigennamen
Bereinigung: trim() für jeden Adressteil
Konditionierung: map() für optionale Adresszusätze

Technische Code-Auflösung

Präfix-Prüfung: startsWith() für Typenbestimmung
Segmentierung: split() oder substring() für Teilbereiche
Extraktion: right() oder left() für spezifische Teile
Validierung: length() für Formatprüfung

Cross-Referenzen

Logische Funktionen - Für bedingte Text-Verarbeitung
Numerische Funktionen - Für Zahlen-zu-Text Konvertierung
Datum-Funktionen - Für Datums-Formatierung
Bedingte Abschnitte - Für if-then-else Logik mit Texten
Variablen - Für Zwischenspeicherung von verarbeiteten Texten