# Text und Strings Textwerte sind zentral für viele Ninox Apps. Du nutzt sie für Namen und Adressen, Bezeichnungen auf Buttons, Meldungen in Hinweisen, IDs und Codes sowie für Daten, die du mit anderen Systemen austauschst. Dieses Kapitel zeigt dir, wie du Text erstellst, bereinigst, durchsuchst und formatierst, damit er in deiner Logik, in Ansichten und in Integrationen zuverlässig funktioniert. In diesem Kapitel lernst du: * Textwerte für Bezeichnungen, Meldungen und IDs zu erstellen und zu ändern * Teile eines Strings zu suchen, zu extrahieren und zu bereinigen * Zahlen, Datumswerte und Uhrzeiten als lesbaren Text zu formatieren * mit Textformaten wie CSV, JSON und XML für Integrationen zu arbeiten
Funktion (A-Z)Aufgabe
chosen()Wertet ausgewählte Werte in einem Mehrfachauswahlfeld aus
concat()Gibt Text aus einer Liste als kommagetrennten String zurück
contains()Prüft, ob Text oder eine Liste einen exakten Wert enthält
extractx()Extrahiert Text mit einem regulären Ausdruck
format()Formatiert Zahlen, Datumswerte und Uhrzeiten als Text
formatJSON()Konvertiert ein JSON-Objekt in Text
formatXML()Konvertiert JSON in XML-Text
html()Gibt die Rich-Text-Darstellung eines Werts zurück
icon()Gibt einen Symbolwert zurück
index()Gibt die erste passende Position in Text oder Arrays zurück
join()Gibt Text aus einer Liste zurück, getrennt durch ein eigenes Trennzeichen
length()Misst die Länge von Text oder Listen
lpad()Füllt Text links bis zu einer festen Länge auf
parseCSV()Konvertiert CSV-Text in Zeilen und Spalten
parseJSON()Konvertiert einen JSON-String in ein JSON-Objekt
parseXML()Konvertiert XML-Text in ein JSON-Objekt
replace()Ersetzt einen String durch einen anderen
replacex()Ersetzt Text mit einem regulären Ausdruck
rpad()Füllt Text rechts bis zu einer festen Länge auf
split()Teilt Text in einzelne Teile und gibt ein Array zurück
string()
text()		Konvertiert Werte in einfachen Text
styled()
color()
icon()
html()		Formatiert Text, gibt Symbolwerte zurück und rendert Rich-Text
substr()
substring()		Extrahiert einen Teil eines Texts
testx()Prüft Text mit einem regulären Ausdruck
trim()Entfernt zusätzliche Leerzeichen
upper()
lower()
capitalize()		Ändert die Groß- und Kleinschreibung von Text
## Werte als kommagetrennten Text zurückgeben Nutze `concat()`, um Werte als einen Textstring mit Kommas als Trennzeichen zurückzugeben. Die Funktion arbeitet mit Arrays, Tabellenergebnissen, Mehrfachauswahlfeldern und direkten Werten. Nutze sie, wenn du: * ausgewählte Optionen aus einem Mehrfachauswahlfeld als Fließtext anzeigen willst * Array- oder Tabellenwerte für ein Formular oder Print-Layout in Text umwandeln willst * ein kommagetrenntes Ergebnis in einem Textfeld oder einer Textvariablen speichern willst `concat([any])`\ `concat(value1, value2, ...)` * `[any]`: ein Array, ein Tabellenergebnis oder ein Mehrfachauswahlfeld * `value1, value2, ...`: einzelne Werte, die du als einen Textstring zurückgeben willst #### Schauen wir uns einige Beispiele an: ``` concat(select members.first_name) ``` Gibt alle Werte des Felds "First name" aus der Tabelle "Members" als einen String zurück, getrennt durch Kommas.\ Das Skript gibt zum Beispiel `"Max, Mary, Kim"` zurück, wenn drei verknüpfte Datensätze Inhalte im Feld "First name" haben.\
``` concat(interests) ``` Gibt alle ausgewählten Einträge aus dem Mehrfachauswahlfeld `interests` als einen String zurück.\ Wenn die ausgewählten Optionen `Marketing`, `Sales` und `Support` sind, gibt das Skript `"Marketing, Sales, Support"` zurück. Tipps: * Nutze [`join()`](#combine-a-list-of-text-values-into-one-string), wenn du ein anderes Trennzeichen als ein Komma brauchst. ## Ausgewählte Werte in Mehrfachauswahlfeldern auswerten Nutze `chosen()`, wenn du die ausgewählten Werte eines Mehrfachauswahlfelds lesen oder prüfen willst. ### Ausgewählte Werte mit `chosen()` prüfen oder zurückgeben Nutze `chosen()`, um alle ausgewählten Optionen aus einem Mehrfachauswahlfeld zurückzugeben oder zu prüfen, ob ein bestimmter Wert oder eine bestimmte ID Teil der Auswahl ist. Nutze die Funktion, wenn du: * die ausgewählten Werte aus einem Mehrfachauswahlfeld zurückgeben willst * prüfen willst, ob eine bestimmte Option ausgewählt ist * prüfen willst, ob mehrere Options-IDs ausgewählt sind * Datensätze filtern willst, bei denen genau ein bestimmter Wert ausgewählt ist `chosen(multi)`\ `chosen(multi, string)`\ `chosen(multi, number)`\ `chosen(multi, [number])`
* `multi`: ein Mehrfachauswahlfeld * `string`: eine ausgewählte Bezeichnung, die du prüfen willst * `number`: eine ausgewählte Options-ID oder Datensatz-ID, die du prüfen willst * `[number]`: eine Liste ausgewählter Options-IDs oder Datensatz-IDs, die du prüfen willst `chosen()` gibt je nach Aufruf einen booleschen Wert oder ein Array von Strings zurück. #### Schauen wir uns einige Beispiele an: Angenommen, `favorite_sports` hat diese ausgewählten Werte: * `Basketball` mit ID `1` * `Dancing` mit ID `3` * `Sailing` mit ID `4` * `Soccer` mit ID `5` ``` chosen(favorite_sports) ``` Gibt die ausgewählten Werte als Array zurück. ```ninox ["Basketball", "Dancing", "Sailing", "Soccer"] ``` ``` chosen(favorite_sports, [1, 3, 5]) ``` Gibt `true` zurück, weil alle aufgeführten IDs ausgewählt sind. ``` chosen(favorite_sports, 4) ``` Gibt `true` zurück, weil die Option mit ID `4` ausgewählt ist. ``` chosen(favorite_sports, "Dancing") ``` Gibt `true` zurück, weil `Dancing` ausgewählt ist. ``` chosen(favorite_sports, "Climbing") ``` Gibt `false` zurück, weil `Climbing` nicht ausgewählt ist. ``` chosen(favorite_sports) = "Dancing" ``` Gibt nur dann `true` zurück, wenn `Dancing` der einzige ausgewählte Wert ist. Tipps: * Nutze `numbers()`, wenn du die ausgewählten IDs als Array für die weitere Verarbeitung brauchst. ## Eine Liste von Textwerten zu einem String zusammenfügen Nutze `join()`, um aus allen Einträgen in einem String-Array oder Tabellenergebnis einen String zu erzeugen. Du legst selbst fest, welches Trennzeichen zwischen den Einträgen steht. Anders als `concat()` lässt dich `join()` genau festlegen, was zwischen den Einträgen steht, zum Beispiel Kommas, Leerzeichen oder Zeilenumbrüche. `join()` hat nichts mit dem SQL-Statement mit demselben Namen zu tun. Nutze die Funktion, wenn du: * mehrere Tags in einer Zeile anzeigen willst * Text im CSV-Stil zum Kopieren und Einfügen erstellen willst * Werte zeilenweise in einem mehrzeiligen Textfeld ausgeben willst `join([string], string)` * `separator`: der Text, den Ninox zwischen die Einträge einfügt, zum Beispiel `","`, `" | "` oder `"\n"` #### Schauen wir uns einige Beispiele an: ``` join(["A", "B", "C"], " ") ``` Fügt das Array zu einem mehrzeiligen String mit einem Zeilenumbruch zwischen den Einträgen zusammen. Das Ergebnis ist: ``` A B C ``` ``` join((select customer where sales > 10000).name, "; ") ``` Gibt die Namen aller Kunden mit einem Umsatz über `10000` zurück, getrennt durch Semikolons.\ Für eine bessere Lesbarkeit fügt das Skript nach jedem Semikolon ein Leerzeichen ein.
``` let names := (select products).name; join(names, " | ") ``` Wählt alle Produktnamen aus und fügt sie mit dem Trennzeichen `|` zusammen.\ Für eine bessere Lesbarkeit fügt das Skript vor und nach dem Trennzeichen ein Leerzeichen ein. Tipps: * Nutze `join()`, wenn du ein anderes Trennzeichen als ein Komma brauchst. Nutze `concat()`, wenn Kommas ausreichen. * Nutze einen Zeilenumbruch als Trennzeichen für mehrzeilige Ausgaben, wie im Beispiel oben. ## Einen Text in Teile zerlegen, die du durchlaufen oder auswerten kannst Nutze `split()`, um einen String an jedem Trennzeichen in ein Array aufzuteilen. Das Trennzeichen markiert die Stellen, an denen Ninox trennt, und ist im Ergebnis nicht enthalten. Nutze `splitx()` für komplexere Fälle oder für Texte mit mehreren Trennzeichen.\ Nutze die Funktion, wenn du: * eine kommagetrennte Liste aus einem Textfeld einzeln verarbeiten willst * importierten Text verarbeiten willst, der mehrere Informationen in einem Feld kombiniert * strukturierte Werte wie Namen, Adressen oder Codes in einzelne Teile aufteilen willst `split(text, separator)` * `text`: der ursprüngliche String, den du aufteilen willst * `separator`: der exakte Text, an dem getrennt wird, zum Beispiel `","` oder `"|"`. Jedes Vorkommen dieses Trennzeichens startet ein neues Element in der Ergebnisliste `splitx(text, regex)` * `text`: der ursprüngliche String, den du aufteilen willst * `regex`: ein "*regulärer Ausdruck*", der alle möglichen Trennzeichen definiert {% hint style="info" %} Reguläre Ausdrücke erfordern oft etwas zusätzliche Recherche. Wir empfehlen dir [https://regex101.com/](https://regex101.com/ "mention") (externer Link), um deine regulären Ausdrücke zu testen. {% endhint %} #### Schauen wir uns einige Beispiele an: ``` split("Company Mainroad 5 10213 City", " ") ``` Teilt den Text an jedem Leerzeichen. Das Skript gibt ein Array mit `Company`, `Mainroad`, `5`, `10213` und `City` zurück.
``` item(split("Company, Mainroad 5, 10213 City", ","), 0) ``` Teilt den Text an jedem Komma und gibt dann das erste Element aus dem Array zurück. Das Skript gibt `"Company"` zurück.\ Mit `1` würde es `"Mainroad 5"` zurückgeben.
``` splitx("333A111&777-666", "\D") ``` Teilt überall dort, wo der Text ein nicht numerisches Zeichen enthält. Das Skript gibt die Liste `"333"`, `"111"`, `"777"`, `"666"` zurück. Tipps: * Kombiniere `split()` mit `item()`, wenn du die Reihenfolge der aufgeteilten Daten kennst und nur einen bestimmten Teil brauchst. * Muster können mehr trennen, als du erwartest. Teste sie zuerst mit einigen Beispielwerten. ## Einen String suchen und durch einen anderen ersetzen Nutze `replace()` für ein einfaches Suchen und Ersetzen in einem String. Die Funktion sucht nach einem festen String und ersetzt jede Übereinstimmung durch einen anderen String. Beide Strings können unterschiedlich lang sein und jedes darstellbare Zeichen enthalten. Nutze die Funktion zum Beispiel, wenn du: * in einem Text nach einem bestimmten String suchen und ihn ersetzen willst * Platzhalter in Textfeldern setzen willst, die du später durch personalisierte Inhalte ersetzt, zum Beispiel beim Drucken oder Senden von E-Mails * unerwünschte Zeichen aus einem Text entfernen willst `replace(text, search, replacement)` * `text`: der ursprüngliche String, in dem du suchen willst * `search`: der exakte Teilstring, den du finden willst * `replacement`: der Text, der jedes Vorkommen von `search` ersetzt Die Suche beachtet die Groß- und Kleinschreibung. #### Schauen wir uns einige Beispiele an: ``` replace("Hello world!", "o", "a") ``` Ersetzt jedes `"o"` durch `"a"`.\ Das Skript gibt `"Hella warld!"` zurück.
``` replace(MyText, " ", " ") ``` Ersetzt alle doppelten Leerzeichen in `MyText` durch ein einzelnes Leerzeichen.
``` replace("Hello ##FNAME##!", "##FNAME##", first_name) ``` Der Platzhalter-String `"##FNAME##"` wird durch den Inhalt des Felds oder der Variablen `first_name` ersetzt. Wenn `first_name` `Jimmy` ist, gibt das Skript `"Hello Jimmy!"` zurück. Tipp: Wenn du unerwünschte Zeichen entfernen willst, nutze einen leeren String `""` als Ersetzung. ## Mit Mustern suchen und ersetzen Nutze `replacex()`, wenn du mit *regulären Ausdrücken* suchen und ersetzen willst und nicht nur mit exaktem Text. Die Funktion erweitert `replace()` und gibt dir deutlich mehr Kontrolle, wenn der Text einem Muster folgt statt einem festen Wert. Nutze `replacex()` dann, wenn `replace()` viele einzelne Aufrufe bräuchte oder wenn der zu ändernde Text nicht immer identisch ist. Nutze `replacex()`, wenn du: * alle Ziffern oder Sonderzeichen entfernen oder vereinheitlichen willst * Formate wie Telefonnummern, IDs oder Codes bereinigen willst * mehrere unterschiedliche Trennzeichen durch ein einheitliches ersetzen willst * importierte Daten mit unerwünschten Zeichen bereinigen willst `replacex(text, regex, replacement)`\ `replacex(text, regex, flags, replacement)` * `text`: der ursprüngliche String, in dem du suchen willst * `regex`: ein regulärer Ausdruck, der beschreibt, was gefunden werden soll * `flags`: optionale Flags für den regulären Ausdruck * `replacement`: der Text, der jede Übereinstimmung des Musters ersetzt Wenn du Zeichen entfernen willst, nutze einen leeren String `""` als Ersetzung. #### Schauen wir uns einige Beispiele an: ``` replacex(phone_no, "\D", " ") ``` Ersetzt alle Nicht-Ziffern in `phone_no` durch Leerzeichen.\ `\D` steht für jedes Zeichen, das keine Ziffer ist.
``` replacex("A--B==C", "--|==", "|") ``` Vereinheitlicht mehrere Trennzeichen zu einem einzigen. Die Funktion ersetzt jedes Vorkommen von `--` oder `==` durch `|`.\ Das Skript gibt `"A|B|C"` zurück.
``` replacex(MyText, "^ *", "g", "") ``` Entfernt führende Leerzeichen aus der Textvariablen `MyText`. {% hint style="info" %} Reguläre Ausdrücke erfordern oft etwas zusätzliche Recherche. Wir empfehlen dir [https://regex101.com/](https://regex101.com/ "mention") (externer Link), um deine regulären Ausdrücke zu testen. {% endhint %} ### Text mit einem regulären Ausdruck über `extractx()` extrahieren Nutze `extractx()`, um auf Basis eines regulären Ausdrucks den ersten Treffer aus einem Text zurückzugeben. Nutze die Funktion, wenn du: * einen Dateinamen, Code oder eine ID aus einem längeren Text extrahieren willst * strukturierte Werte aus importierten Daten herausziehen willst * einen Teil eines Texts wiederverwenden willst, der einem Muster folgt * einen Regex-Treffer vor der Rückgabe weiterverarbeiten willst `extractx(string, string)`\ `extractx(string, string, string)`\ `extractx(string, string, string, string)` * erstes `string`: der Text, in dem du suchen willst * zweites `string`: das Muster des regulären Ausdrucks * drittes `string`: optionale Flags * viertes `string`: optionaler Extraktionsausdruck wie `$1` oder `$2` `extractx()` gibt einen String zurück. #### Schauen wir uns einige Beispiele an: ```ninox extractx(text(my_attachment), "(.+)\/(.+)", "i", "$2") ``` Extrahiert den Dateinamen aus dem Anhangspfad und gibt `ImportantDocument.pdf` zurück. Tipps: * Nutze `extractx()`, wenn du den ersten passenden Teil brauchst und keinen vollständigen Ersatz. * Nutze Capture Groups wie `$1` oder `$2`, wenn nur ein Teil des Treffers relevant ist. * Nutze `testx()`, um zuerst zu prüfen, ob ein Muster passt. {% hint style="info" %} Reguläre Ausdrücke erfordern oft etwas zusätzliche Recherche. Wir empfehlen dir [https://regex101.com/](https://regex101.com/ "mention") (externer Link), um deine regulären Ausdrücke zu testen. {% endhint %} ## Einen bestimmten Teil eines Texts extrahieren Nutze `substr()` oder `substring()`, um nur einen Teil eines längeren Texts zu extrahieren. Das ist nützlich, wenn dein Text eine feste Struktur hat, zum Beispiel Rechnungsnummern oder Codes, und du einen bestimmten Abschnitt wie ein Präfix, ein Jahr oder einen Kurzcode brauchst.\ Beide Funktionen extrahieren einen Teil eines Texts, arbeiten aber leicht unterschiedlich: `substr()` startet an einer Position und nimmt optional eine bestimmte Anzahl von Zeichen. `substring()` startet an einer Position und nimmt alles bis zu einer angegebenen Endposition. Nutze sie zum Beispiel, wenn du: * Teile gleich aufgebauter Daten extrahieren willst, zum Beispiel das Präfix einer Rechnungsnummer * Werte für Vergleiche abkürzen willst, zum Beispiel `"Yes"` und `"No"` zu `"Y"` und `"N"` `substr(text, start)`\ `substr(text, start, length)` * `text`: der ursprüngliche String, aus dem du einen Teil extrahieren willst * `start`: die Position, an der der Ausschnitt beginnt. Die Zählung startet bei `0` * `length` (optional): wie viele Zeichen ab `start` zurückgegeben werden. Wenn du `length` weglässt, reicht der Ausschnitt bis zum Ende von `text` `substring(text, start, end)` * `text`: der ursprüngliche String, aus dem du einen Teil extrahieren willst * `start`: die Position, an der der Ausschnitt beginnt. Die Zählung startet bei `0` * `end`: die Position nach dem letzten Zeichen, das du einschließen willst. Die Endposition ist exklusiv Hinweis: Wenn `end` kleiner als `start` ist, tauscht Ninox die Werte automatisch. Die kleinere Zahl wird zum Startwert und die größere zur Endposition. #### Schauen wir uns einige Beispiele an: ``` substr(ninox_example, 11) ``` Gibt einen neuen String aus dem angegebenen Text ab einer bestimmten Startposition zurück.\ Wenn das Feld `ninox_example` den Text `"Hello world!"` enthält, gibt dieses Skript `"!"` zurück.\ Das Ausrufezeichen steht an Position 11, wenn du bei 0 zählst: `H=0, e=1, l=2, l=3, o=4, Leerzeichen=5, w=6, o=7, r=8, l=9, d=10, !=11`.
``` substr(ninox_example, 0, 5) ``` Gibt einen neuen String mit der angegebenen Länge ab Position 0 zurück.\ Wenn das Feld `ninox_example` den Text `"Hello world!"` enthält, gibt dieses Skript `"Hello"` zurück: `H=0, e=1, l=2, l=3, o=4, ...`.
``` substring(ninox_example, 4, 7) ``` Gibt einen neuen String aus dem angegebenen Text mit einer Start- und Endposition zurück.\ Wenn das Feld `ninox_example` den Text `"Hello world!"` enthält, gibt dieses Skript `"o w"` zurück.\ Das sind die Zeichen an den Positionen 4, 5 und 6: `H=0, e=1, l=2, l=3, o=4, Leerzeichen=5, w=6`. Das Zeichen an Position 7 ist nicht enthalten. ## Die Länge von Text oder Listen messen Nutze `length()`, um die Anzahl der Zeichen in einem String oder die Anzahl der Einträge in einem Array zurückzugeben. Leerzeichen zählen als Zeichen. In Arrays zählt jeder Eintrag, auch leere Strings und `null`. Nutze die Funktion, wenn du: * die Größe eines Arrays berechnen willst * Stringlängen vergleichen willst * prüfen willst, ob ein Feld eine bestimmte Anzahl von Zeichen enthält * zusammen mit `substr()` oder `index()` die verbleibenden Zeichen ab einer bestimmten Position zählen willst `length(string)`\ `length([any])` * `string`: der Text, dessen Zeichen du zählen willst * `[any]`: das Array, dessen Einträge du zählen willst #### Schauen wir uns einige Beispiele an: ``` length("Ninox is great!") ``` Zählt alle Zeichen im Text, einschließlich Leerzeichen.\ Das Skript gibt `"15"` zurück.
``` length(["A", "B", "", "D", null]) ``` Zählt alle Einträge im Array. Leere Strings und `null` werden trotzdem mitgezählt.\ Das Skript gibt `"5"` zurück. Tipps: * Wenn du nur passende Datensätze oder nicht leere Werte zählen willst, nutze eine speziellere Funktion wie `count()`. * Wenn du die Anzahl der Zeichen ab einer bestimmten Position brauchst, kombiniere `length()` mit `substr()` oder `index()`. ## Die Position von Text in anderem Text finden Nutze `index()`, um die Startposition des ersten Treffers in einem String oder Array zurückzugeben. Anders als `contains()` sagt dir die Funktion nicht nur, ob ein Treffer existiert. Sie gibt die numerische Position dieses Treffers zurück. Die Zählung startet bei `0`. `index(text, search)` `index([any], any)` * `text`: der ursprüngliche String, in dem du suchen willst * `[any]`: das Array, in dem du suchen willst * `search` / `any`: der gesuchte Wert Bei Strings gibt `index()` die Position des ersten Zeichens des ersten Treffers zurück. Bei Arrays gibt die Funktion die Position des ersten identischen Eintrags zurück. #### Schauen wir uns einige Beispiele an: ``` index("Ninox is great!", "ox") ``` Gibt die Position des ersten Treffers im String zurück.\ Das Skript gibt `3` zurück.
``` index("Ninox is great!", "N") ``` Das erste Zeichen passt direkt am Anfang des Strings.\ Das Skript gibt `0` zurück.
``` index("Ninox is great!", "oX") ``` Es gibt keinen Treffer, weil die Groß- und Kleinschreibung beachtet wird.\ Das Skript gibt `-1` zurück.
``` let myItems := [1, 2, 3, 4]; index(myItems, 3) ``` Gibt die Position des passenden Array-Eintrags zurück.\ Das Skript gibt `2` zurück.
``` let myItems := ["A", "C", "D", "E", "F", "B"]; index(myItems, "D") ``` Gibt die Position von `"D"` im Array zurück.\ Das Skript gibt `2` zurück.
``` index(["Ninox is great!"], "ox") ``` Gibt `-1` zurück, weil das Array keinen Eintrag enthält, der exakt `"ox"` entspricht. Tipps: * `index()` gibt `-1` zurück, wenn kein exakter Treffer gefunden wird. * Bei Strings beachtet `index()` die Groß- und Kleinschreibung. Nutze `lower()` oder `upper()`, wenn du ohne Berücksichtigung der Groß- und Kleinschreibung prüfen willst. ## Prüfen, ob Text oder eine Liste einen exakten Wert enthält Nutze `contains()`, um zu prüfen, ob ein String oder ein Array den gesuchten exakten Wert enthält. Das Ergebnis ist immer boolesch: `true` bei einem Treffer und `false`, wenn kein Treffer gefunden wird. Nutze die Funktion, wenn du: * nach Schlüsselwörtern in einem Textfeld suchen willst * prüfen willst, ob ein Array einen bestimmten Wert enthält `contains(string, string)`\ `contains([any], any)` * `string`: der Text, in dem du suchen willst * `[any]`: das Array, in dem du suchen willst * `string` / `any` (zweites Argument): der Wert, den du suchst Bei Strings beachtet `contains()` die Groß- und Kleinschreibung. Bei Arrays bedeutet ein exakter Treffer, dass der gesuchte Wert einem der Einträge entspricht. Wenn du zusätzlich die Position eines Treffers brauchst, nutze stattdessen `index()`. #### Schauen wir uns einige Beispiele an: ``` contains("Hello world!", "Hello") ``` Prüft, ob `"Hello world!"` den Text `"Hello"` enthält.\ Das Skript gibt `true` zurück.
``` contains("Hello world!", "hello") ``` Die Großschreibung stimmt nicht überein und `contains()` beachtet die Groß- und Kleinschreibung.\ Das Skript gibt `false` zurück. Wenn du die Groß- und Kleinschreibung ignorieren willst, formatiere den Text zuerst mit `lower()`: ``` contains(lower("Hello world!"), "hello") ``` Sowohl der Text als auch der Suchwert sind in Kleinbuchstaben. Deshalb gibt die Funktion `true` zurück.
``` contains(["A", "B", "C"], "B") ``` Prüft, ob `"B"` im Array `["A", "B", "C"]` vorkommt.\ Das Skript gibt `true` zurück.
``` contains(["A", "B", "C"], "D") ``` `"D"` ist nicht im Array enthalten.\ Das Skript gibt `false` zurück.
``` contains([{ name: "Sam" }], { name: "Sam" }) ``` Gibt `false` zurück. JSON-Objekte werden nicht über ihren Inhalt verglichen, sondern über ihre Identität. ## Die Groß- und Kleinschreibung von Text ändern Nutze `upper()`, `lower()` und `capitalize()`, um die Schreibweise von Buchstaben in einem Text zu ändern. So bereinigst du uneinheitliche Eingaben, vereinheitlichst Werte vor Vergleichen und formatierst Namen, Bezeichnungen und Meldungen konsistent für Print-Layouts, Berichte und E-Mails. * `upper()` wandelt Kleinbuchstaben in Großbuchstaben um * `lower()` wandelt Großbuchstaben in Kleinbuchstaben um * `capitalize()` setzt den ersten Buchstaben jedes Worts auf Großschreibung und den Rest auf Kleinschreibung `upper(string)`\ `lower(string)`\ `capitalize(string)` * `string`: der Text, den du ändern willst #### Schauen wir uns einige Beispiele an: ``` upper("upPer") ``` Wandelt Kleinbuchstaben in Großbuchstaben um. Andere Zeichen bleiben unverändert.\ Das Skript gibt `"UPPER"` zurück.
``` contains(upper("With Ninox you can build great databases"), upper("database")) ``` Das ist nützlich für Vergleiche ohne Berücksichtigung der Groß- und Kleinschreibung.\ Das Skript gibt `true` zurück.
``` lower("LOwER") ``` Wandelt Großbuchstaben in Kleinbuchstaben um. Andere Zeichen bleiben unverändert.\ Das Skript gibt `"lower"` zurück.
``` contains(lower("With Ninox you can build great databases"), lower("DATABASE")) ``` Das ist nützlich für Vergleiche ohne Berücksichtigung der Groß- und Kleinschreibung.\ Das Skript gibt `true` zurück.
``` capitalize(last_name) ``` Wenn das Feld "Last name" den Wert `"doe"` enthält, gibt das Skript `"Doe"` zurück.
``` capitalize("John doe") ``` Schreibt den ersten Buchstaben jedes Worts groß und gibt `"John Doe"` zurück.
``` last_name := capitalize(last_name) ``` Aktualisiert den Feldwert direkt.\ Wenn das Feld `"roe"` enthält, lautet das Ergebnis `"Roe"`. Tipps: * Wenn du Text vergleichst und die Großschreibung egal ist, nutze `lower()` oder `upper()` auf beiden Seiten des Vergleichs. * Nutze `capitalize()` nur für Daten, die wie Namen geschrieben werden sollen. Für Codes wie `AB-123` oder Abkürzungen wie `HR` oder `IT` ist die Funktion nicht geeignet. * Füge `capitalize()` in der Automatisierung "After Update" hinzu, wenn Namen oder Bezeichnungen immer mit einem Großbuchstaben beginnen sollen. ## Textwerte formatieren, bereinigen und gestalten Nutze diese Funktionen, wenn du bereits Text hast und ihn bereinigen, auffüllen oder für die Anzeige gestalten willst. Damit passt du an, wie Text in deiner App aussieht und sich verhält. Nutze sie, um: * zusätzliche Leerzeichen zu entfernen * Zeichen hinzuzufügen, damit Text eine feste Länge hat * Werte in Text zu konvertieren * Text mit Farben und Symbolen zu gestalten Diese Funktionen sind besonders nützlich, wenn du Daten für Druck, Exporte oder Dashboards mit einem einheitlichen Erscheinungsbild vorbereitest. ### Zusätzliche Leerzeichen mit `trim()` entfernen Nutze `trim()`, um führende und nachgestellte Leerzeichen aus einem Text zu entfernen. Das ist besonders nützlich, wenn Text aus anderen Quellen kopiert wird und am Anfang oder Ende unerwünschte Leerzeichen enthält. `trim()` verändert keine Leerzeichen innerhalb des Texts. `trim(string)` * `string`: der Text, aus dem du Leerzeichen am Anfang oder Ende entfernen willst #### Schauen wir uns ein Beispiel an: ``` last_name := trim(last_name) ``` Entfernt führende und nachgestellte Leerzeichen aus dem Feld `last_name`.\ Wenn das Feld `" Doe "` enthält, lautet das Ergebnis `"Doe"`. Tipp: Füge das im Trigger nach einer Aktualisierung eines Textfelds hinzu, wenn neue oder geänderte Werte automatisch bereinigt werden sollen. ### Text mit `lpad()` und `rpad()` auf eine feste Länge auffüllen Nutze `lpad()` und `rpad()`, um einen String auf eine bestimmte Gesamtlänge zu bringen, indem fehlende Zeichen am Anfang oder Ende ergänzt werden. Das ist nützlich, wenn Codes eine feste Länge haben müssen oder wenn du Werte in Berichten und Print-Layouts ausrichten willst. `lpad()` fügt am Anfang eines Strings links Füllzeichen hinzu. Die Zeichen wiederholen sich, bis die Gesamtlänge erreicht ist. `rpad()` fügt Füllzeichen am Ende eines Strings rechts hinzu. Auch hier wiederholen sich die Zeichen bis zur gewünschten Länge. `lpad(string, length, padding)`\ `rpad(string, length, padding)` * `string`: der ursprüngliche Text * `length`: die gewünschte Gesamtlänge des Ergebnisses * `padding`: die Zeichen, mit denen der fehlende Platz gefüllt wird Wenn der ursprüngliche Text `length` bereits erreicht oder überschreitet, bleibt er unverändert. #### Schauen wir uns einige Beispiele an: ``` lpad("A text", 20, "+ ") ``` Füllt `"A text"` links mit `"+ "` auf, bis der Text insgesamt 20 Zeichen lang ist.\ Das Skript gibt `"+ + + + + + + A text"` zurück.
``` lpad(text(123), 8, "0") ``` Konvertiert zuerst die Zahl `123` in Text und füllt dann links mit Nullen auf, bis Länge 8 erreicht ist.\ Das Skript gibt `"00000123"` zurück.
``` rpad("A text", 20, " +") ``` Füllt `"A text"` rechts mit `" +"` auf, bis der Text insgesamt 20 Zeichen lang ist.\ Das Skript gibt `"A text + + + + + + +"` zurück.
``` rpad(text(123), 8, "0") ``` Füllt rechts mit Nullen auf, bis Länge 8 erreicht ist.\ Das Skript gibt `"12300000"` zurück. ### Werte mit `string()` und `text()` in einfachen Text konvertieren Nutze `string()` und `text()`, um Ninox Werte in Text umzuwandeln, den du anzeigen, zusammenfügen oder exportieren kannst. Das ist nützlich, wenn du lesbare Bezeichnungen bauen, Werte mit Text kombinieren oder Text an E-Mails, Print-Layouts oder externe Tools übergeben willst.\ `string()` konvertiert einen Wert in seine rohe Stringform und berücksichtigt keine Formatierung.\ `text()` konvertiert einen Wert in einen lesbaren String und kann Formatoptionen wie Datums-, Zeit- oder Zahlenformate berücksichtigen. `string(value)`\ `text(value)` * `value`: ein beliebiger Ninox Wert, den du als Text brauchst, zum Beispiel eine Zahl, ein Datum, eine Auswahl oder ein Array #### Schauen wir uns einige Beispiele an: ``` alert("Today is " + text(today())) ``` Zeigt eine Meldung, in der das Datum als lesbarer Text ausgegeben wird.\ Das Skript gibt je nach Datumsformat einen Dialog wie `"Today is 10/25/2026"` zurück.
``` text(status) ``` Wenn das Auswahlfeld `status` aktuell `In progress` zeigt, gibt das Skript den Text `"In progress"` zurück.
``` string(new_year_s_eve) ``` Wenn das Datumsfeld "New Year's Eve" auf den 31. Dez. 2026 gesetzt ist, gibt das den internen numerischen Wert für dieses Datum zurück.
``` string(favorite_sports) ``` Wenn `favorite_sports` ein Mehrfachauswahlfeld ist, gibt die Funktion den internen Code wie `"d1"` zurück und nicht die sichtbaren Bezeichnungen. Tipps: * Nutze `string()`, wenn du den rohen gespeicherten Wert brauchst. * Nutze `text()`, wenn du lesbare Ausgaben brauchst, die die Anzeigeformatierung berücksichtigen. * Bei Mehrfachauswahlfeldern gibt `text()` die sichtbaren Bezeichnungen zurück, während `string()` den internen hexadezimalen Wert liefern kann. ### Text mit Farben und Symbolen über `styled()`, `color()`, `icon()` und `html()` gestalten Nutze `color()`, um einen Farbwert zurückzugeben, `icon()`, um einen Symbolwert zurückzugeben, `html()`, um Rich-Text zurückzugeben, und `styled()`, um Farben und optional ein Symbol auf Text anzuwenden. Durch die Gestaltung wird das Ergebnis in den Datentyp `styled` konvertiert. `color(name)`\ `color(r, g, b)`\ `color(r, g, b, a)`\ `color(choice)`\ `icon(choice)`\ `icon(string)`\ `html(any)` * `name`: ein Farbname oder Code wie `"blue"` oder `"#4970FF"` * `r, g, b`: Rot-, Grün- und Blauwerte als Zahlen * `a`: optionale Deckkraft zwischen 0 und 1 * `choice`: ein Auswahlfeld, dessen ausgewählte Option eine definierte Farbe hat * `string`: der Symbolname, den du zurückgeben willst * `any`: der Wert, den du mit HTML-Rendering als Rich-Text zurückgeben willst `color()` akzeptiert jeden gültigen Farbbezeichner wie Namen, Hex-Werte, RGB- oder RGBA-Werte. `icon()` gibt einen Symbolwert für ein Symbol- oder Logikfeld zurück. Du kannst auch das Symbol einer ausgewählten Option in einem Auswahlfeld zurückgeben. `html()` gibt einen Rich-Text-Wert zurück. Einfache HTML-Tags, Listen, Tabellen und Inline-Styles werden dort gerendert, wo Rich-Text unterstützt wird. `styled()` gibt ein gestaltetes Objekt zurück. In einem Logikfeld zeigt Ninox den gestalteten Text statt reinem Text. `styled(text, background)`\ `styled(text, background, icon)`\ `styled(text, background, fontColor, icon)` Nutze diese Datentypen für die Parameter oben:\ `styled(text, color)`\ `styled(text, color, icon)`\ `styled(text, color, color, icon)`\ `styled(text, JSON)` * `text`: der anzuzeigende Text * `background`: eine Farbe oder ein Farbname für den Hintergrund * `fontColor`: eine Farbe für den Text selbst * `icon`: der Symbolname, der neben dem Text angezeigt wird * `JSON`: ein JSON-Objekt wie `{ color: "black", background: "orange", icon: "warn" }` Wenn du einen oder mehrere Parameter überspringen willst, ohne die Reihenfolge zu ändern, übergib für jeden ausgelassenen Parameter einen leeren String `""`. Ninox nutzt dann den Standardwert für diesen Parameter.\ Wenn du zum Beispiel die Schriftfarbe auslässt, verwendet Ninox automatisch Schwarz oder Weiß, damit der Kontrast zum Hintergrund ausreichend bleibt. #### Schauen wir uns einige Beispiele an: ``` color("blue") ``` Gibt eine blaue Farbe zurück, aber nicht das Ninox Blau.
``` color("#4970FF") ``` Gibt die Farbe mit dem Hex-Code `#4970FF` zurück, also Blau.
``` color(73, 112, 255) ``` Gibt das Ninox Blau als RGB-Farbwert zurück.
``` color(73, 112, 255, 0.5) ``` Gibt eine Farbe aus den RGB-Werten `73`, `112` und `255` mit 50 % Deckkraft zurück.
``` color(status) ``` Gibt die Farbe der ausgewählten Option im Auswahlfeld "Status" zurück.
``` styled("Warning!", "", "red", "warn") ``` Zeigt `Warning!` in Rot mit einem Warnsymbol links vom Text.\ Durch den leeren Hintergrund nutzt Ninox den Standardhintergrund. Nur Schriftfarbe und Symbol sind gesetzt.
``` styled("Warning!", background, font_color, icon) ``` Nutzt die Werte aus den Feldern `background`, `font_color` und `icon`, um den Text zu gestalten und das gewählte Symbol links anzuzeigen.
``` styled(text(balance), if balance < 0 then "lightred" else "lightgreen" end) ``` Zeigt den Kontostand mit rotem Hintergrund, wenn er unter null liegt, oder mit grünem Hintergrund, wenn er null oder höher ist.
``` styled("Info", { background: "#4970FF", color: "white", icon: "info" }) ``` Nutzt ein JSON-Objekt, um Hintergrundfarbe, Schriftfarbe und Symbol an einer Stelle festzulegen. ``` icon(my_choice_field) ``` Gibt das Symbol der ausgewählten Option im Auswahlfeld zurück. ``` icon("heart") ``` Gibt das Symbol `heart` zurück. ```ninox html("Ninox is great!") ``` Gibt einen Rich-Text-Wert zurück, der die fette und kursive Formatierung dort rendert, wo Rich-Text unterstützt wird. ```ninox rich_text := html("
Ninox is great
!") ``` Schreibt formatierten Rich-Text in das Feld `rich_text`. Tipps: * Nutze `html()` nur dort, wo Rich-Text unterstützt wird. * In einem normalen Textfeld werden HTML-Tags als Text angezeigt. In einem Rich-Text-Feld wird das HTML gerendert. ## Zahlen, Datumswerte und Uhrzeiten in Text umwandeln und formatieren Nutze `format()`, wenn du Zahlen, Datumswerte, Uhrzeiten und Termine in Text umwandeln und ihr Aussehen genau steuern willst.\ Das ist nützlich, wenn du: * Werte in Print-Layouts oder E-Mails anzeigen willst * einer Zahl Währung oder Einheiten hinzufügen willst, die nicht aus einem Zahlenfeld mit gesetzter Währung kommen * Datums- und Uhrzeitdarstellungen in deiner App vereinheitlichen willst `format()` gibt einen Textwert zurück. Die Funktion ändert weder die ursprüngliche Zahl noch das ursprüngliche Datum. `format(number, pattern)`\ `format(date, pattern)`\ `format(date, pattern, language)`\ `format(appointment, pattern)`\ `format(appointment, pattern, language)`\ `format(timestamp, pattern)`\ `format(timestamp, pattern, language)`\ `format(time, pattern)` * `number` / `date` / `time` / `appointment` / `timestamp`: der Wert, den du in Text umwandeln willst * `pattern`: ein Textausdruck, der das gewünschte Ausgabeformat beschreibt * `language`: der Sprachcode für das Ergebnis, zum Beispiel `"en"` oder `"de"` Alle Teile des Format-Ausdrucks sind optional. Wenn du ein leeres Muster wie `""` nutzt, bleibt der Wert unformatiert. ### Zahlen mit `format()` formatieren Nutze `format()`, um eine Zahl mit Präfix, Suffix, exakten Trennzeichen, Dezimalstellen und Einheiten als Text auszugeben. Wenn du ein Zahlenformat aufbaust, definierst du diese Teile in dieser Reihenfolge: * optionales Präfix, zum Beispiel `$` * ob ein Tausendertrennzeichen angezeigt wird * wie viele Dezimalstellen angezeigt werden * optionales Suffix oder eine Einheit, zum Beispiel `€` * Stil des Dezimaltrennzeichens * Stil des Tausendertrennzeichens {% hint style="info" %} Die Ergebnisse können je nach Gebietsschema und Formateinstellungen unterschiedlich aussehen. Dasselbe Muster kann Punkte oder Kommas je nach Region anders anzeigen. {% endhint %} #### Schauen wir uns einige Beispiele an: ``` format(238597, "") ``` Zeigt die Zahl ohne besondere Formatierung: `"238597"`. ``` format(238597, ".00") ``` Zeigt zwei Dezimalstellen: `"238597.00"` oder `"238597,00"`. Je nach Gebietsschema nutzt Ninox Punkt oder Komma. ``` format(2385.97, "0.000#,#") ``` Zeigt drei erforderliche Dezimalstellen und optional eine weitere Ziffer.\ Je nach Gebietsschema gibt das Skript `"2387,970"` oder `"2387.970"` zurück.
``` format(2385.97, "$#,.#0,0") ``` Fügt ein Dollarzeichen, ein Tausendertrennzeichen und zwei Dezimalstellen hinzu: `"$2,385.97"`. ``` format(2385.97, "#,##0.00 €#,#0.0") ``` Nutzt ein in Europa häufiges Format mit Komma als Dezimaltrennzeichen und Punkt als Tausendertrennzeichen: `"2.385,97 €"`. ``` format(12345, "0000000000") ``` Füllt eine Zahl mit führenden Nullen auf, bis eine feste Länge erreicht ist: `0000012345`. ### Datumswerte und Uhrzeiten mit `format()` formatieren Nutze `format()`, um Datumswerte, Uhrzeiten und Zeitstempel als lesbaren Text auszugeben. Du kannst: * Tages- und Monatsnamen ausschreiben * die Reihenfolge von Tag, Monat und Jahr steuern * Zeitteile ein- oder ausblenden * eine bestimmte Sprache für Monats- und Wochentagsnamen nutzen #### **Schauen wir uns einige Beispiele an:** ``` format(date, "ddd, Do MMMM YYYY") ``` Formatiert das Datum in einer langen, gut lesbaren Form.\ `ddd` steht für den Wochentagsnamen wie `Mon` oder `Wed`. `Do` steht für den Tag des Monats `D` mit Ordnungszahl wie `1st` oder `23rd`.\ Wenn das Datum `05/31/2026` ist, gibt das Skript im US-Format `"Mon, May 31, 2026"` oder im UK-Format `"Mon, 31st May 2026"` zurück.
``` format(date, "YYYY-MM-DD") ``` Zeigt das Datum im ISO-Stil. Für den 31. Mai 2026 gibt das Skript `"2026-05-31"` zurück.
``` format(date, "ddd, Do MMMM YYYY", "us") ``` Zeigt das Datum im US-Stil mit englischen Wochentags- und Monatsnamen. Für den 25. Mai 2026 gibt das Skript `"Mon, May 25, 2026"` zurück.
``` format(myTime, "HH:mm") ``` Formatiert einen Zeitwert mit Stunden und Minuten, zum Beispiel `"09:30"`.
``` format(now(), "YYYY-MM-DD HH:mm:ss") ``` Formatiert das aktuelle Datum und die aktuelle Uhrzeit aus `now()` in einem üblichen Log-Format: `"2026-05-31 15:06:27"`.
``` format(now(), "X") ``` Zeigt das aktuelle Datum und die aktuelle Uhrzeit als Unix-Zeit ohne Millisekunden. Das ist eine einfache, zeitzonenunabhängige Darstellung eines Zeitpunkts als einzelne Ganzzahl. Wenn das Datum der 26. Mai 2026 ist, gibt das Skript den Zeitstempel ohne Millisekunden `"1774479600"` zurück.
``` format(now(), "x") ``` Zeigt das aktuelle Datum und die aktuelle Uhrzeit als Unix-Zeit mit Millisekunden. Wenn das Datum der 17. Mai 2026 ist und die Uhrzeit `09:32:41 am`, gibt das Skript den Zeitstempel inklusive Millisekunden `"1779010361000"` zurück.
``` format(myAppointment, "YYYY-MM-DD HH:mm") ``` Formatiert Startdatum und Startuhrzeit einer Terminvariablen als Text.
``` format(myAppointment, "dddd, D. MMMM YYYY, HH:mm", "fr") ``` Formatiert Startdatum und Startuhrzeit des Termins auf Französisch mit lokalisierten Wochen- und Monatsnamen. Tipps: * Deine Gebiets- und Spracheinstellungen beeinflussen Monatsnamen und einige Standardtrennzeichen. Dasselbe Format kann je nach Region unterschiedlich aussehen, zum Beispiel `$2,385.97` oder `2.385,97 €`. ## Mit JSON und XML für fortgeschrittene Integrationen arbeiten Nutze `formatJSON()` und `formatXML()`, um JSON-Daten in einen String umzuwandeln. Das ist nützlich, wenn du: * mit APIs arbeitest, die JSON oder XML zurückgeben oder erwarten * ein eingehendes JSON-Objekt prüfen willst * JSON in XML-Text umwandeln willst Diese Funktionen richten sich an fortgeschrittene Nutzer, die mit JSON und XML vertraut sind. Die Ergebnisse sind einfache Textwerte. Ninox interpretiert sie nicht automatisch. ### Ein JSON-Objekt mit `formatJSON()` in Text umwandeln Nutze `formatJSON()`, um ein gültiges JSON-Objekt in einen JSON-String zu konvertieren. Das ist nützlich, wenn du den Inhalt eines eingehenden JSON-Objekts prüfen oder mit anderen Textfunktionen weiterverarbeiten willst. `formatJSON(JSON)` * `JSON`: ein JSON-Objekt #### Schauen wir uns ein Beispiel an: {% code overflow="wrap" %} ``` let databaseURL := "https://api.ninoxdb.de/v1/teams/" + teamId() + "/databases/" + databaseId() + "/tables/" + tableId(this); let myAPIKey := "Bearer abcd1234-0000-xxxx-zzzz-1a1aa1aaa1a111"; let response := http("GET", databaseURL, { Authorization: myAPIKey }, null); 'Text' := formatJSON(response) ``` {% endcode %} Dieses Skript: * ruft die Ninox API mit einer `GET`-Anfrage auf * nutzt einen API-Key. Ersetze den Beispielschlüssel durch deinen eigenen persönlichen API-Key * erhält eine JSON-Antwort als JSON-Objekt * konvertiert dieses JSON-Objekt mit `formatJSON()` in einen JSON-String * speichert den JSON-Text im Feld `Text`, damit du die Antwort prüfen kannst Ohne `formatJSON()` ist das Ergebnis in einem Textfeld nicht sinnvoll lesbar. Du erhältst zum Beispiel einen JSON-String mit den Daten deiner aktuellen Tabelle: {% code overflow="wrap" %} ```json {"result":{"id":"I","name":"Table1","fields":[{"id":"A","name":"Text","type":"string"},{"id":"B","name":"Number","type":"number"},{"id":"D","name":"Text 2","type":"string"}]}} ``` {% endcode %} ### JSON mit `formatXML()` in XML-Text konvertieren Nutze `formatXML()`, um ein JSON-Objekt in XML-Text umzuwandeln. XML gehört neben JSON zu den häufigsten Formaten für den Datenaustausch. Deshalb ist `formatXML()` besonders nützlich, wenn du Ninox per API mit externen Servern verbindest. `formatXML(JSON)`\ `formatXML(JSON, pretty)` * `JSON`: ein JSON-Objekt, das du in einen XML-String umwandeln willst * `pretty`: `true` oder `false`. Mit `true` wird der XML-String mit Einrückungen und Zeilenumbrüchen besser lesbar formatiert #### Schauen wir uns ein Beispiel an: {% code overflow="wrap" %} ``` formatXML({ contact: { @type: "Person", firstName: { @: 'First Name' }, lastName: { @: 'Last Name' }, phone: [{ @type: "Mobile", @: Mobile }, { @type: "Phone", @: Phone }] } }, true) ``` {% endcode %} Das konvertiert das JSON-Objekt in einen XML-String. Mit `pretty` auf `true` ist das Ergebnis leichter lesbar formatiert: {% code overflow="wrap" %} ```xml Steve Rogers (+1) (202) 123 45 67 +1.151.11 ++66 14 66 ``` {% endcode %} Du kannst diesen XML-Text dann an ein anderes System senden oder für einen Export speichern. Tipps: * Nutze `formatJSON()`, wenn du JSON-Daten als String sehen oder speichern willst oder wenn du sie mit Textfunktionen wie `replace()` oder `split()` weiterverarbeiten willst. ## Text mit regulären Ausdrücken prüfen Nutze `testx()`, wenn eine normale Suche nach exaktem Text nicht flexibel genug ist. ### Prüfen, ob Text mit einem regulären Ausdruck übereinstimmt, mit `testx()` Nutze `testx()`, um `true` zurückzugeben, wenn ein Text zu einem regulären Ausdruck passt. Nutze die Funktion, wenn du: * prüfen willst, ob ein Text einen Wert enthält, der einem Muster folgt * importierten Text validieren willst, bevor du ihn weiterverarbeitest * Platzhalter, IDs oder codierte Werte in Freitext erkennen willst `testx(string, string)`\ `testx(string, string, string)` * erstes `string`: der Text, den du prüfen willst * zweites `string`: der *reguläre Ausdruck* * drittes `string`: optionale Flags `testx()` gibt einen booleschen Wert zurück. #### Schauen wir uns einige Beispiele an: ```ninox testx("Hello [username]! You have [number of messages] messages!", "\[(\w|\s)*\]") ``` Gibt `true` zurück, weil der Text Inhalt in eckigen Klammern enthält, der zum Muster passt. Tipps: * Nutze `testx()`, wenn du nur ein Ja-oder-Nein-Ergebnis brauchst. Andernfalls nutze `extractx()` oder `replacex()`. {% hint style="info" %} Reguläre Ausdrücke erfordern oft etwas zusätzliche Recherche. Wir empfehlen dir [https://regex101.com/](https://regex101.com/ "mention") (externer Link), um deine regulären Ausdrücke zu testen. {% endhint %} ## CSV-, JSON- und XML-Text in Daten umwandeln, mit denen du arbeiten kannst Nutze `parseCSV()`, `parseJSON()` und `parseXML()`, um Text in strukturierte Daten umzuwandeln, mit denen Ninox arbeiten kann. Das ist nützlich, wenn du: * Daten als Text importierst oder empfängst, sie aber in einem strukturierten Datenformat weiterverarbeiten willst * deine Ninox Daten als CSV, JSON oder XML exportieren willst, zum Beispiel für die Kommunikation mit anderen Integrationen per API `parseCSV()` arbeitet mit CSV-Text.\ `parseJSON()` konvertiert einen JSON-String in ein JSON-Objekt.\ `parseXML()` konvertiert einen XML-String in ein JSON-Objekt. ### CSV-Text mit `parseCSV()` in Zeilen und Spalten umwandeln Nutze `parseCSV()`, um CSV-Text in strukturierte Daten umzuwandeln, die du durchlaufen kannst. Die Funktion eignet sich für eingefügte Tabellenkalkulationsdaten, importierte Dateien oder CSV-Text aus Integrationen. `parseCSV(string, options)` * `string`: der CSV-Text, den du parsen willst, zum Beispiel {% code overflow="wrap" %} ``` "Name,Age Kiran,42 Lisa,27" ``` {% endcode %} * `options`: optionales JSON-Objekt: * `firstLineIsHeader` (boolean, Standard `false`): Wenn `true`, nutzt Ninox die erste Zeile als Spaltennamen und gibt JSON-Objekte zurück. Wenn `false`, gibt Ninox jede Zeile als Liste von Textwerten zurück. * `separator` (string, optional): das Zeichen zwischen den Feldern, zum Beispiel `","` oder `";"`. Wenn du es weglässt, versucht Ninox es automatisch zu erkennen. * `textQuote` (string, optional): das Zeichen, mit dem Textfelder in Anführungszeichen gesetzt werden. Standard ist `"`. `parseCSV()` gibt eine dieser Strukturen zurück: * eine Liste von JSON-Objekten, wenn `firstLineIsHeader: true` * eine Liste von Text-Arrays, wenn `firstLineIsHeader: false` #### Schauen wir uns einige Beispiele an: Standardverhalten: ``` parseCSV("Name,Age Kiran,42 Lisa,27", {}) ``` Gibt eine Liste zurück, in der jede Zeile eine Liste von Textwerten ist: ```json [ ["Name", "Age"], ["Kiran", "42"], ["Lisa", "27"] ] ``` \ Die erste Zeile als Header nutzen: ``` parseCSV("Name,Age Kiran,42 Lisa,27", { firstLineIsHeader: true }) ``` Gibt eine Liste von JSON-Objekten mit Schlüsseln aus der Header-Zeile zurück: ```json [ { Name: "Kiran", Age: "42" }, { Name: "Lisa", Age: "27" } ] ``` \ Eigenes Trennzeichen: ``` parseCSV("Name;Age Kiran;42 Lisa;27", { separator: ";", firstLineIsHeader: true }) ``` Liest `;` als Trennzeichen und gibt zurück: ```json [ { Name: "Kiran", Age: "42" }, { Name: "Lisa", Age: "27" } ] ``` \ Eigenes Quote-Zeichen: Du kannst ein `textQuote`-Zeichen wie ein einfaches Anführungszeichen `'` setzen, um Felder mit speziell gequotetem Text zu verarbeiten. ``` parseCSV("Name,Note Kiran,'Team lead, Berlin' Lisa,'Works remote, Lisbon'", { firstLineIsHeader: true, textQuote: "'" }) ``` Behandelt `'` als Quote-Zeichen. Dadurch bleiben Kommas innerhalb der Notiz im selben Feld: ```json [ { Name: "Kiran", Note: "Team lead, Berlin" }, { Name: "Lisa", Note: "Works remote, Lisbon" } ] ``` Ohne passende `textQuote`-Einstellung bleiben gequotete Werte exakt so erhalten, wie sie in der Eingabe stehen. Zum Beispiel: ``` parseCSV("Name,Age Kiran,42 'Lisa',27", { firstLineIsHeader: true }) ``` gibt zurück: ```json [ { Name: "Kiran", Age: "42" }, { Name: "'Lisa'", Age: "27" } ] ``` Tipps: * Setze `firstLineIsHeader: true`, wenn du auf Werte per Name zugreifen willst, zum Beispiel `row.Name`. * Lass die Option auf `false`, wenn du nur rohe Zeilen und Spalten brauchst. * Wenn du `separator` nicht setzt, erkennt Ninox gängige Trennzeichen wie Kommas oder Tabs automatisch. * `textQuote` ist optional. Nicht gequotete Felder werden trotzdem normal geparst. ### Einen JSON-String mit `parseJSON()` in ein JSON-Objekt umwandeln Nutze `parseJSON()`, um einen JSON-String in ein JSON-Objekt umzuwandeln, mit dem du in Ninox arbeiten kannst. Das ist nützlich für API-Antworten, importierte Dateien oder JSON, das in einem Textfeld gespeichert ist. `parseJSON(string)` * `string`: ein gültiger JSON-String Der String muss gültiges JSON sein. Andernfalls ist das Ergebnis nicht verwendbar. #### Schauen wir uns ein Beispiel an: ``` parseJSON("{ ""test"": 123 }") ``` Konvertiert den JSON-Text in ein JSON-Objekt: ```json { "test": 123 } ``` Danach kannst du auf Werte aus dem JSON in deiner Logik zugreifen. Das ist zum Beispiel nützlich, wenn du: * JSON mit `http()` von einer API erhältst * Werte aus einem JSON-String in einem Feld lesen willst * ein JSON-Objekt ändern und in `http()` weitergeben willst Tipps: * Nutze doppelte Anführungszeichen `""` für Anführungszeichen innerhalb des JSON-Strings. ### Einen XML-String mit `parseXML()` in ein JSON-Objekt umwandeln Nutze `parseXML()`, um einen XML-String in ein JSON-Objekt umzuwandeln, mit dem du in Ninox arbeiten kannst. Das ist besonders nützlich, wenn du externe Services per API anbindest und eingehende XML-Daten verarbeiten musst. XML ist neben JSON ein gängiges Austauschformat. `parseXML(string)` * `string`: ein gültiger XML-String #### Schauen wir uns ein Beispiel an: ```ninox let xml := " John Doe Ninox Contact request Please contact me! "; parseXML(xml) ``` Gibt ein JSON-Objekt ähnlich diesem zurück: ```json {"note":{"to":{"@":"John Doe"},"from":{"@":"Ninox"},"heading":{"@":"Contact request"},"body":{"@":"Please contact me!"}}} ``` Danach kannst du Werte aus diesem JSON-Objekt in deiner Logik lesen. Tipps: * Für den umgekehrten Weg von strukturierten Daten zurück zu Text nutzt du `formatJSON` für JSON und `formatXML` für XML. * Wenn du ein XSD-Schema hast, validiere das XML vor dem Parsen. * Ein ungültiger XML-String führt zu einem Parse-Fehler. Siehe auch: * [Zahlen und Mathematik](/ninox-scripting/de/automate-your-workflows/work-with-functions/numbers-and-math.md) für die Konvertierung von Text in Zahlen und die Vorbereitung von Werten für Berechnungen * [Datum und Uhrzeit](/ninox-scripting/de/automate-your-workflows/work-with-functions/dates-and-time.md) für die Formatierung von Datumswerten, Uhrzeiten und Zeitstempeln als lesbaren Text * [Integration und HTTP](/ninox-scripting/de/automate-your-workflows/work-with-functions/integration-and-http.md) für das Senden von Text-Payloads, das Parsen von Antworten und die Arbeit mit XML in Integrationen * [Standort und Geräte](/ninox-scripting/de/automate-your-workflows/work-with-functions/location-and-devices.md) für das Erstellen sicherer URLs und das Kodieren von Abfragewerten --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.ninox.com/ninox-scripting/de/automate-your-workflows/work-with-functions/text-and-strings.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.