Formelsammlung

Formel	Beispiel	Beschreibung
Logikformeln
`if(condition, then)`	`if(true, "Hello")` ergibt `Hello`	Wenn die Bedingung wahr ist, dann liefere den ‘then’ Wert.
`ifElse(condition, then, else)`	`ifElse(true, "Hello", "World")` ergibt `Hello`	Wenn die Bedingung wahr ist, dann liefere den ‘then’ Wert, ansonsten den ‘else’ Wert.
`empty(value)`	`empty("")` ergibt `true`	Prüft ob value leer ist
`notEmpty(value)`	`notEmpty("Hello World")` ergibt `true`	Prüft ob value nicht leer ist
Zahlenformeln
`ceil(number)`	`ceil(1.5)` ergibt `2`	Aufrunden auf eine ganze Zahl
`floor(number)`	`floor(1.5)` ergibt `1`	Abrunden auf eine ganze Zahl
`round(number)`	`round(1.5)` ergibt `2`	Runden auf die nächstgelegene ganze Zahl
`decimalRound(number, decimalPlaces)`	`decimalRound(1.2345, 2)` ergibt `1.23`	Runden auf bestimmte Anzahl von Nachkommastellen
`power(number1, number2)`	`power(2, 3)` ergibt `8`	Berechnet number1 hoch number2
`abs(number)`	`abs(-5)` ergibt `5`	Betragsfunktion
`toNumber(value)`	`toNumber("123")` ergibt `123`	Wandelt einen Text in eine numerische Darstellung des Wertes um
`textLength(value)`	`textLength("Hello World")` ergibt `11`	Gibt die Textlänge inklusive aller Sonderzeichen und Leerzeichen aus
`formatNumber(number, decimalCount, thousandSeparator)`	`formatNumber(1234.567, 2, true)` ergibt `1.234,57`	Formatiert die Nummer ins gewünschte Format
`range(start, end, [step])`	`range(1, 5)` ergibt `[1, 2, 3, 4, 5]`	Generiere eine Liste an Zahlen, von start bis end mit einer Schrittgröße von step. Standardmäßig ist step=1
Datumsformeln
`formatDate(date, format)`	`formatDate(now(), "dd.MM.yyyy")` ergibt `01.01.2022`	Formatiert ein Datum in die gewählte Formatierung
`date(year, month, day)`	`date(2022, 1, 1)` ergibt `01.01.2022`	Erstellt ein Datum aus gegebenem Jahr, Monat und Tag
`parseDate(text)`	`parseDate("01.01.2022")` ergibt `01.01.2022`	Erstellt Datum aus Text im Format “dd.mm.yy” oder “dd.mm.yyyy”, nur dieses Format ist zulässig
`tryParseDate(value)`	`tryParseDate("01.01.2022")` ergibt `01.01.2022`	Versucht ein Datum aus value zu machen. Tritt ein Fehler auf wird defaultDateTime zurück gegeben
`today()`	`today()` ergibt `01.01.2022 00:00:00.000`	Datum, bestehend aus dem aktuellen Tag um 00:00 Uhr
`now()`	`now()` ergibt `01.01.2022 12:23:57.432`	Datum, bestehend aus dem aktuellen Zeitpunkt
`defaultDateTime`	`defaultDateTime` ergibt `1970-01-01 00:00:00.000`	Gibt das Datum 00:00 01.01.1970. Dieses Datum wird nicht angezeigt
`currentWeek`	`currentWeek` ergibt `2022-W01`	Aktuelle Kalenderwoche
`calendarWeek(date)`	`calendarWeek(now())` ergibt `24`	Kalenderwoche des gegebenen Datums
`startOfWeek([date])`	`startOfWeek(now())` ergibt `14.06.2021 00:00:00.000000`	Start der aktuellen Kalenderwoche
`endOfWeek([date])`	`endOfWeek(now())` ergibt `20.06.2021 00:00:00.000000`	Ende der aktuellen Kalenderwoche
`dateToWeek(date)`	`calendarWeek(parseDate("2025-01-20"))` ergibt `2025-W04`	Kalenderwoche des Datums
`addWeeks(date/week, weeks)`	`addWeeks(today(),1)` ergibt `22.06.2021 8:00:00.000000`	Wochen auf ein Datum oder einen Wochentext addieren
`subtractWeeks(date/week, weeks)`	`subtractWeeks(today(),1)` ergibt `15.06.2021 8:00:00.000000`	Subtrahiere Wochen von einem Datum oder Wochentext
`currentMonth`	`currentMonth` ergibt `2024-06`	Liefert den aktuellen Monat in Form eines Textes
`currentYear`	`currentYear` ergibt `2025`	Aktuelles Jahr als Zahl
`startOfMonth([date])`	`startOfMonth()` ergibt `01.06.2021 00:00:00.000000`	Beginn des aktuellen Monats
`endOfMonth([date])`	`endOfMonth()` ergibt `30.06.2021 00:00:00.000000`	Ende des aktuellen Monats
`dateToMonth(date)`	`dateToMonth(parseDate("2025-01-17"))` ergibt `2025-01`	Jahr und Monat im Format YYYY-MM
`addMonths(date/month, months)`	`addMonths(today(), 1)` ergibt `01.07.2021 00:00:00.000000`	Monate auf ein Datum oder Monatstext addieren
`subtractMonths(date/month, months)`	`subtractMonths(today(), 1)` ergibt `01.05.2021 00:00:00.000000`	Monate von einem Datum oder Monatstext subtrahieren
`addYears(date, years)`	`addYears(today(), 5)` ergibt `20.01.2030 00:00:00.000000`	Addiert eine Anzahl von Jahren zu einem Datum
`subtractYears(date, years)`	`subtractYears(today(), 5)` ergibt `20.01.2020 00:00:00.000000`	Subtrahiert eine Anzahl von Jahren von einem Datum
`startOfQuarter([date])`	`startOfQuarter()` ergibt `01.04.2021 00:00:00.000000`	Beginn des aktuellen Quartals
`endOfQuarter([date])`	`endOfQuarter()` ergibt `30.06.2021 00:00:00.000000`	Ende des aktuellen Quartals
`startOfYear([date])`	`startOfYear()` ergibt `01.01.2021 00:00:00.000000,`	Beginn des aktuellen Jahres
`endOfYear([date])`	`endOfYear()` ergibt `31.12.2021 00:00:00.000000`	Ende des aktuellen Jahres
`addMinutes(date, minutes)`	`addMinutes(now(), 2)` ergibt `01.01.2022 12:23:57.432`	Minuten auf einen Zeitpunkt addieren
`subtractMinutes(date, minutes)`	`subtractMinutes(now(), 2)` ergibt `01.01.2022 12:21:57.432`	Minuten von einem Zeitpunkt subtrahieren
`addHours(date, hours)`	`addHours(now(), 2)` ergibt `01.01.2022 14:23:57.432`	Addiert Stunden auf den gegebenen Zeitpunkt.
`subtractHours(date, hours)`	`subtractHours(now(), 2)` ergibt `01.01.2022 10:23:57.432`	Subtrahiert Stunden von dem gegebenen Zeitpunkt.
`addDays(date, days)`	`addDays(now(), 1)` ergibt `02.01.2022 12:23:57.432`	Addiert Tage auf den gegebenen Zeitpunkt.
`subtractDays(date, days)`	`subtractDays(now(), 1)` ergibt `31.12.2021 12:23:57.432`	Subtrahiert Tage von dem gegebenen Zeitpunkt.
`datesBetween(startDate, endDate, [options])`	`datesBetween(date(2022, 1, 1), date(2022, 1, 5))` ergibt `[01.01.2022, 02.01.2022, 03.01.2022, 04.01.2022, 05.01.2022]`	Daten zwischen den zwei gegebenen Daten. Unter [option] kann optional über den Text “weekdays” angegeben werden, dass nur Werktage angegeben werden sollen.
`daysBetween(startDate, endDate)`	`daysBetween(date(2022, 1, 1), date(2022, 1, 5))` ergibt `4`	Anzahl der Tage zwischen dem startDate und dem endDate
`hoursBetween(startDate, endDate)`	`hoursBetween(parseDate("10.10.2022 06:00:00"), parseDate("10.10.2022 10:00:00"))` ergibt `4`	Anzahl der Stunden zwischen dem startDate und dem endDate
`combineDateAndTime(date, time)`	`combineDateAndTime(now(), "12:00")` ergibt `01.01.2022 12:00:00.000`	combineDateAndTime(today(), “12:00”) liefert das Datum von heute mit der Uhrzeit 12:00
`hours(timeString)`	`hours("16:20")` ergibt `16`	Stunden von einer Uhrzeit
`minutes(timeString)`	`minutes("16:20")` ergibt `20`	Minuten von einer Uhrzeit
`overlapInMinutes(startTime1, endTime1, startTime2, endTime2)`	`overlapInMinutes("17:00","19:00","18:00","20:00")` ergibt `60` `overlapInMinutes("13:00","14:00","17:00","18:00")` ergibt `0`	Überschneidung zweier Uhrzeitspannen in Minuten.
Textformeln
`currentUserName`	`currentUserName` ergibt `John Doe`	Name des aktuellen Benutzers
`currentUserId`	`currentUserId` ergibt `zdxmHQXUMJWsZHKwKInRePrK6Tt2`	ID des aktuellen Benutzers
`currentUserEmail`	`currentUserEmail` ergibt `john.doe@email.com`	E-Mail des aktuellen Benutzers
`currentUserRoleName`	`currentUserRoleName` ergibt `Admin`	Rollenname des aktuellen Benutzers
`currentUserRoleId`	`currentUserRoleId` ergibt `87898ob2`	Rollen-Id des aktuellen Benutzers
`toText(value)`	`toText(123)` ergibt `123`	Wandelt einen nicht textuellen Wert (Zahlen, dynamische Werte, Datum, Objekte) in eine textuelle Darstellung des Wertes um
`contains(text, sub)`	`contains("Hello World", "World")` ergibt `true` `contains("Hello World", "Sun")` ergibt `false`	Gibt true/false abhängig davon zurück, ob sub in text vorhanden ist.
`replace(text, find, sub)`	`replace("Hello World", "World", "Universe")` ergibt `Hello Universe`	Ersetzt jedes vorkommen von find in text mit sub
`replaceRegExp(text, regexpText, sub)`	`replaceRegExp("Hello World", "W.*d", "Universe")` ergibt `Hello Universe`	Ersetzt jedes vorkommen von regexpText in text mit sub
`substring(text, start, [end])`	`substring("Hello World", 6)` ergibt `World`	Liefert den Ausschnitt aus text, welcher an Zeichen start - 1 beginnt und an end endet. Wird end nicht angegeben, so wird der Text ab start bis zum Ende zurückgegeben
`trim(text)`	`trim(" Hello World ")` ergibt `Hello World`	Entfernt Leerzeichen am Anfang und Ende eines Textes
`basicAuth(username, password)`	`basicAuth("Univelop","uni123!")` ergibt `VW5pdmVsb3A6dW5pMTIzIQ==`	Verschlüsselt username und password
`randomString(length)`	`randomString(10)` ergibt `f49gf623bk`	Erzeugt eine zufällige Zeichenkette mit der Länge length (bestehend aus Kleinbuchstaben und Zahlen)
`firstLetters(value, count)`	`firstLetters("Hello World", 5)` ergibt `Hello`	Gibt count Zeichen von Beginn an zurück
`lastLetters(value, count)`	`lastLetters("Hello World", 5)` ergibt `World`	Liefert die Anzahl an count Zeichen vom Ende des Textes
`firstWords(value, count)`	`firstWords("Hello World", 1)` ergibt `Hello`	Gibt count Worte von Beginn an zurück. Als Worte zählen solche, die durch mindestens ein Leerzeichen getrennt sind.
`lastWords(value, count)`	`lastWords("Hello World", 1)` ergibt `World`	Liefert die Anzahl an count Wörtern vom Ende des Textes. Als Wörter zählen solche, die durch mindestens ein Leerzeichen getrennt sind.
`getFirst(regexpText, text, [groupIndexOrName])`	`getFirst("(d+)", "abc 123 def", 1)` ergibt `123` `getFirst("(?<letters>[a-z]+)` ergibt `abc123`	Sucht in text nach dem ersten Treffer von regexText. Mit groupIndexOrName kann eine spezifische Capture Group zurückgegeben werden, andernfalls wird der gesamte Treffer zurückgegeben. Wenn kein Treffer gefunden wird, gibt es einen leeren String zurück.
`getAll(regexpText, text)`	`getAll("([a-z]+)(\d+)", "abc123abc123")` ergibt `[{full: abc123, 1: abc, 2: 123}, {full: abc123, 1: abc, 2: 123}]`	Durchsucht text nach allen Vorkommen von regexText und gibt eine Liste von Maps zurück, in denen der Key die jeweilige Capture Group repräsentiert.
`toUpperCase(text)`	`toUpperCase("Hello World")` ergibt `HELLO WORLD`	Konvertiert text zu Großbuchstaben
`toLowerCase(text)`	`toLowerCase("Hello World")` ergibt `hello world`	Konvertiert text zu Kleinbuchstaben
`base64Encode(value)`	`base64Encode("Hello World")` ergibt `SGVsbG8gV29ybGQ=`	Kodiert den gegebenen Text mithilfe des base64 Verfahrens
`base64Decode(value)`	`base64Decode("SGVsbG8gV29ybGQ=")` ergibt `Hello World`	Dekodiert einen mit dem base64 kodierten Text zurück in den Ursprung
`parseJson(jsonText)`	`parseJson('{"name":"John"}')` ergibt `{name: John}`	Konvertiert einen Json-String zu einem Json-Objekt
`jsonEncode(value)`	`jsonEncode({name: "John"})` ergibt `{"name":"John"}`	Wandelt value in einen JSON String um.
`toCharCode(text)`	`toCharCode("a")` ergibt `97`	Wandelt das angegebene Zeichen in dessen numerischen Zeichencode um
`fromCharCode(number)`	`fromCharCode(97)` ergibt `a`	Wandelt den angegebenen numerischen Zeichencode in das entsprechende Zeichen um
`toRadixString(number, radix)`	`toRadixString(10, 2)` ergibt `1010`	Wandelt die angegebene Zahl, dargestellt als Zeichenkette in der entsprechenden Basis, zurück in den numerischen Wert um.(2: Binär, 16: Hexadezimal, 8: Oktal, 36: Base36)
`fromRadixString(text, radix)`	`fromRadixString("1010", 2)` ergibt `10`	Wandelt die angegebene Zahl in eine Zeichenkettendarstellung der entsprechenden Basis um.(2: Binär, 16: Hexadezimal, 8: Oktal, 36: Base36)
`base64ToBinary(text)`	`base64ToBinary("SGVsbG8gV29ybGQ=")` ergibt `01001000 01100101 01101100 01101100 01101111 00100000 01010111 01101111 01110010 01101100 01100100`	Konvertiert einen Base64-String in eine Binäre Liste.
`binaryToBase64(text)`	`binaryToBase64("01001000 01100101 01101100 01101100 01101111 00100000 01010111 01101111 01110010 01101100 01100100")` ergibt `SGVsbG8gV29ybGQ=`	Konvertiert eine Binäre Liste in einen Base64-String.
`split(text, delimiter)`	`split("Hello World", " ")` ergibt `["Hello", "World"]`	Teilt text and jedem delimiter
`urlEncode(text)`	`urlEncode("Hello World")` ergibt `Hello%20World`	Kodiert einen Text ins URL-Format
Listenformeln
`get(map/list, key, [defaultValue])`	`get({name: "John", age: 30}, "name")` ergibt `John` `get([0,1,2,3], 2)` ergibt `2`	Holt den Wert von key aus map/list. defaultValue kann optional angegeben werden und wird zurück gegeben wenn ein Fehler auftritt
`toMap(object)`	`toMap(file).name` ergibt `Report.txt` `toMap(null)` ergibt `{}`	Konvertiert ein Objekt in eine Map.
`count(list)`	`count([1,2,2,3])` ergibt `4`	Zählt die Elemente einer Liste/eines dynamischen Wertes
`listToText(list, separator)`	`listToText([1,2,3], "-")` ergibt `1-2-3` `listToText(["Peter","Mark","David"], ", ")` ergibt `Peter, Mark, David`	Listet alle Elemente einer Liste auf, getrennt durch einen optionalen Separator (wenn nicht angegeben, wird standardmäßig ‘,’ genommen).
`addToList(list, element)`	`addToList([1,2,3], 4)` ergibt `[1,2,3,4]` `addToList(["Peter","Mark"], "Alan")` ergibt `["Peter", "Mark", "Alan"]`	Fügt einer Liste ein Element hinten an.
`removeFromList(list, element)`	`removeFromList([1,2,3], 2)` ergibt `[1,3]` `removeFromList(["Peter","Mark","David"], "Mark")` ergibt `["Peter", "David"]`	Entfernt ein Element aus einer Liste.
`joinLists(list, list2)`	`joinLists([1,2], [3,4])` ergibt `[1,2,3,4]`	Verbindet zwei Listen, indem die zweite Liste der ersten angehängt wird.
`parseList(value, [separator])`	`parseList("1,2,3", ",")` ergibt `[1, 2, 3]`	Parst einen String in eine Liste, getrennt durch einen optionalen Separator.
`listIntersection(list1, list2)`	`listIntersection([1,2], [2,3])` ergibt `[2]`	Gibt die Schnittmenge zweier Listen zurück.
`listUnion(list1, list2)`	`listUnion([1,2,3], [2,3,4])` ergibt `[1,2,3,4]`	Gibt die Vereinigung zweier Listen zurück.
`listEquals(list1, list2)`	`listEquals([1,2,3], [1,2,3])` ergibt `true`	Prüft, ob sich zwei Listen gleichen.
`listDifference(list1, list2)`	`listDifference([1,2,3], [2,3])` ergibt `[1]`	Gibt die Differenz zweier Listen zurück.
`listSymmetricDifference(list1, list2)`	`listSymmetricDifference([1,2,3], [2,3,4])` ergibt `[1,4]`	Berechnet die symmetrische Differenz zweier Listen.
`contains(list, item)`	`contains([1,2,3], 2)` ergibt `true` `contains(["Peter","Mark","David"], "Mark")` ergibt `true`	Gibt true/false abhängig davon zurück, ob sub in text vorhanden ist.
`indexOf(list/text, value)`	`indexOf([1,2,3], 2)` ergibt `1`	Gibt den index von value in list/text zurück
`removeDuplicates(list)`	`removeDuplicates([1,2,2,3,4,4])` ergibt `[1,2,3,4]`	removeDuplicates([1,2,3,1,1,3]) liefert [1,2,3]
`fileNames(list)`	`fileNames(files)` ergibt `["Report.txt", "Invoice.pdf"]`	Liste der Dateinamen für eine Liste von Dateien
`fileUrls(list)`	`fileUrls(files)` ergibt `["url1", "url2"]`	Liste der Download-URLs für eine Liste von Dateien
`fileHashes(list)`	`fileHashes(files)` ergibt `["ee6748d5b2b6db8b51380cedce2cb0dd"]`	Liste der Datei-Hashes für eine Liste von Dateien

Inhalt

Weiterlesen: Logikformeln