RESPONSUM verfügt über eine Expression Engine mit einer Reihe von Ausdrücken (vergleichbar mit Funktionen in Excel), die verwendet werden können für:
- Geschäftsregeln (Öffnen Sie ein Element in dem Untermodul, auf das Sie eine Geschäftsregel anwenden möchten >> Klicken Sie auf „Drei Punkte“ >> Wählen Sie „Untermodul anpassen“): Ermöglicht es Ihnen, Felder in RESPONSUM-Untermodulen basierend auf Werten anderer Felder und Ausdrücken auszublenden.


- Formulare/Assessments (Einstellungen >> Setup >> Formular): Ermöglicht es Ihnen, Logik zu Feldern in einem Formular (Fragebogen) hinzuzufügen, um sie auszublenden, Berechnungen auf Basis eingegebener Feldwerte zu erstellen usw.

Verwendbare Ausdrücke
Eine vollständige Liste der unterstützten Ausdrücke finden Sie unten mit Anwendungsbeispielen.
Schlüsselnotationen:
[]: steht für eine leere Liste (einige Optionen sollten zuerst ausgewählt und dann wieder abgewählt werden. Wenn zuvor keine ausgewählt war, ist der Wert undefiniert)
undefined: eine Option ist nicht ausgewählt (Ja/Nein-Frage, Multiple-Choice-Frage)
Leere Listen und undefinierte Werte funktionieren in Ausdrücken nicht, sie repräsentieren jedoch bestimmte Zustände von Eingaben.
Hinweis zur Spalte „Use case in Responsum“: <Feld-ID 1>, <Feld-ID 2> und <Bedingung 1> sind Platzhalter. Ersetzen Sie sie durch die ID Ihrer eigenen Frage bzw. Ihres eigenen Feldes:
In einem Formular: die „Element ID“ der Frage, die angezeigt wird, wenn Sie die Frage im Form Builder öffnen.
In einer Geschäftsregel: die „Field ID“, die oben im Panel „Edit field“ angezeigt wird.
Innerhalb der Klammern können Sie auch feste Zahlen (10), festen Text in Anführungszeichen („Closed“) oder andere Funktionen (count(…)) verwenden.
| Funktion | Verwendung | Ergebnis | Beispiele | Anwendungsfall in Responsum |
|---|---|---|---|---|
| Addieren | add(1; 2; 3; …) | Die Summe aller numerischen Werte, die in den eingegebenen Elementen gefunden werden. | – add(1; 2) = 3 – add(1; undefined; „foo“; 4) = 5 – add(1; „two“; [3, 4]) = 8 – add(-1; 1) = 0 – add(undefined; „text“; []) = undefined | Eine Gesamtpunktzahl automatisch berechnen. Setzen Sie in einem Formular den Standardwert einer Zahlenfrage auf: add(<Feld-ID 1>; <Feld-ID 2>): addiert zwei Antworten add(<Feld-ID 1>; 10): addiert eine feste Zahl zu einer Antwort add(<Feld-ID 1>; <Feld-ID 2>; <Feld-ID 3>; 5): addiert so viele Antworten und Zahlen, wie Sie benötigen |
| Subtrahieren | subtract(1; 2; 3; …) | Die erste Zahl in den eingegebenen Elementen minus alle anderen gefundenen numerischen Werte. | – subtract(1; 2) = -1 – subtract(1; undefined; „foo“; 4) = -3 – subtract(1; „text“; [3, 4]) = -6 – subtract(-1; 1) = -2 – subtract(undefined; „text“; []) = undefined | Das Risiko berechnen, das nach Sicherheitsmaßnahmen verbleibt. Setzen Sie in einem Formular den Standardwert einer Zahlenfrage auf: subtract(<Feld-ID 1>; <Feld-ID 2>): subtrahiert die zweite Antwort von der ersten subtract(<Feld-ID 1>; 1): subtrahiert eine feste Zahl von einer Antwort subtract(100; <Feld-ID 1>): subtrahiert eine Antwort von einer festen Zahl |
| Multiplizieren | multiply(1; 2; 3; …) | Die Multiplikation aller gefundenen numerischen Werte. | – multiply(1; 2) = 2 – multiply(1; undefined; „foo“; 4) = 4 – multiply(1; „two“; [3, 4]) = 12 – multiply(-1; 1) = -1 – multiply(undefined; „text“; []) = undefined | Einen Risikoscore aus Wahrscheinlichkeit und Auswirkung berechnen. Setzen Sie in einem Formular den Standardwert einer Zahlenfrage auf: multiply(<Feld-ID 1>; <Feld-ID 2>): multipliziert zwei Antworten, z. B. Wahrscheinlichkeit × Auswirkung multiply(<Feld-ID 1>; 2): verdoppelt eine Antwort multiply(<Feld-ID 1>; <Feld-ID 2>; 0.5): multipliziert zwei Antworten und eine feste Zahl |
| Dividieren | divide(1; 2; 3; …) | Die Division des ersten numerischen Werts durch die übrigen numerischen Werte nacheinander. | – divide(1; 2) = 0.5 – divide(1; undefined; „text“; 4) = 0.25 – divide(1; „two“; [3, 4]) = 0.083333333333 – divide(-1; 1) = -1 – divide(undefined; „fish“; []) = undefined – divide(1; 2; 3; 0) = undefined | Den Prozentsatz der umgesetzten Sicherheitskontrollen anzeigen. Setzen Sie in einem Formular den Standardwert einer Zahlenfrage auf: divide(<Feld-ID 1>; <Feld-ID 2>): teilt eine Antwort durch eine andere divide(<Feld-ID 1>; 2): teilt eine Antwort durch eine feste Zahl multiply(divide(<Feld-ID 1>; <Feld-ID 2>); 100): wandelt das Ergebnis in einen Prozentsatz um |
| Gleich | equals(item1; item2) | Gibt TRUE zurück, wenn beide eingegebenen Werte gleich sind. Elemente sind gleich, wenn sie denselben Typ und denselben Wert haben. HINWEIS: – Der Vergleich ist groß-/kleinschreibungssensitiv; – Arrays (z. B. Multi-Select-Dropdowns) können mit anderen Arrays verglichen werden; – Ein leeres Array gilt als gleich wie undefined; – Ein Array, das nur 1 Element enthält, gilt als das einzelne Element/der einzelne Wert, den es enthält. | – equals(undefined; false) ⇒ false – equals(„Cat“; „cat“) ⇒ false – equals(„cat“; „cat“ ⇒ true – equals(true; 1) ⇒ false – equals(false; false) ⇒ true – equals([]; undefined) ⇒ true – equals([]; „“) ⇒ false – equals([„Sam“], [„Sam“]) ⇒ true – equals ([„Sam“]; „Sam“) ⇒ true – equals(„0“, 0) ⇒ false | Das Feld „Closure date“ ausblenden, bis der Vorfall geschlossen ist. Setzen Sie in der Geschäftsregel des Feldes „Hide field when“ auf: not(equals(<Feld-ID 1>; „Closed“)): vergleicht eine Antwort mit einem festen Text (groß-/kleinschreibungssensitiv) equals(<Feld-ID 1>; 0): vergleicht eine Antwort mit einer Zahl equals(<Feld-ID 1>; <Feld-ID 2>): prüft, ob zwei Antworten gleich sind |
| Ist größer | islarger(1; 2) | Gibt TRUE zurück, wenn 1 größer als 2 ist. HINWEIS: Wenn das Ergebnis nicht nachvollziehbar ist, geben wir FALSE zurück. | – isLarger(1;2) ⇒ false – isLarger(2;1) ⇒ true – isLarger(2;-1) ⇒ true – isLarger(2;“one“) ⇒ false – isLarger(2; 2) ⇒ false – isLarger(2; undefined) ⇒ false – isLarger(undefined; 2) ⇒ false – isLarger(undefined; undefined) ⇒ false | Nur dann nach einer Begründung fragen, wenn mehr als 10.000 Personen betroffen sind. Setzen Sie in einem Formular „Is Visible?“ auf Logik mit: islarger(<Feld-ID 1>; 10000): vergleicht eine Antwort mit einer festen Zahl islarger(<Feld-ID 1>; <Feld-ID 2>): vergleicht zwei Antworten islarger(count(<Feld-ID 1>); 3): vergleicht das Ergebnis einer anderen Funktion |
| Ist kleiner | issmaller(1; 2) | Gibt TRUE zurück, wenn 1 kleiner als 2 ist. HINWEIS: Wenn das Ergebnis nicht nachvollziehbar ist, geben wir FALSE zurück. | – isSmaller(1;2) ⇒ true – isSmaller(2;1) ⇒ false – isSmaller(2;-1) ⇒ false – isSmaller(2;“three“) ⇒ false – isSmaller(2; 2) ⇒ false – isSmaller(2; undefined) ⇒ false – isSmaller(undefined; 2) ⇒ false – isSmaller(undefined; undefined) ⇒ false | Nur dann nach elterlicher Zustimmung fragen, wenn Nutzer jünger als 16 sein können. Setzen Sie in einem Formular „Is Visible?“ auf Logik mit: issmaller(<Feld-ID 1>; 16): vergleicht eine Antwort mit einer festen Zahl issmaller(<Feld-ID 1>; <Feld-ID 2>): vergleicht zwei Antworten issmaller(count(<Feld-ID 1>); 2): vergleicht das Ergebnis einer anderen Funktion |
| Ist größer oder gleich | islargerorequal(1; 2) | Gibt TRUE zurück, wenn 1 größer als ODER gleich 2 ist. HINWEIS: Wenn das Ergebnis nicht nachvollziehbar ist, geben wir FALSE zurück. | – isLargerOrEqual(1;2) ⇒ false – isLargerOrEqual(2;1) ⇒ true – isLargerOrEqual(2;-1) ⇒ true – isLargerOrEqual(2;“one“) ⇒ false – isLargerOrEqual(2; undefined) ⇒ false – isLargerOrEqual(undefined; 2) ⇒ false – isLargerOrEqual(undefined; undefined) ⇒ false | Den vollständigen DPIA-Abschnitt anzeigen, wenn mindestens 2 Hochrisiko-Kriterien ausgewählt sind. Setzen Sie in einem Formular „Is Visible?“ des Abschnitts auf Logik mit: islargerorequal(count(<Feld-ID 1>); 2): mindestens 2 Optionen angekreuzt islargerorequal(<Feld-ID 1>; 15): eine Antwort von 15 oder mehr islargerorequal(<Feld-ID 1>; <Feld-ID 2>): eine Antwort ist gleich oder größer als eine andere |
| Ist kleiner oder gleich | issmallerorequal(1; 2) | Gibt TRUE zurück, wenn 1 größer als oder gleich 2 ist. HINWEIS: Wenn das Ergebnis nicht nachvollziehbar ist, geben wir FALSE zurück. | – isSmallerOrEqual(1;2) ⇒ true – isSmallerOrEqual(2;1) ⇒ false – isSmallerOrEqual(2;-1) ⇒ false – isSmallerOrEqual(2;“three“) ⇒ false – isSmallerOrEqual(2; undefined) ⇒ false – isSmallerOrEqual(undefined; 2) ⇒ false – isSmallerOrEqual(undefined; undefined) ⇒ false | Das Feld „Escalation to management“ bei niedrigen Risiken ausblenden. Setzen Sie in der Geschäftsregel des Feldes „Hide field when“ auf: issmallerorequal(<Feld-ID 1>; 4): eine Antwort von 4 oder weniger issmallerorequal(<Feld-ID 1>; <Feld-ID 2>): eine Antwort ist gleich oder kleiner als eine andere issmallerorequal(count(<Feld-ID 1>); 1): eine Option oder keine angekreuzt |
| Verketten | concatenate(item1; item2) | Fügt jeden gefundenen TEXT in den Eingabewerten zusammen. Funktioniert auch mit Arrays (z. B. Multiple-Choice-Felder mit mehreren ausgewählten Werten) aus Texten HINWEIS: Ignoriert alles, was kein TEXT oder keine Arrays aus Text ist (z. B. Zahlen, Ja/Nein-Werte usw.) | – concatenate(„John“, [„Doe“, „is“], [„a“, „legend“], [„:-)“], undefined, [], 3, true) ⇒ „JohnDoeisalegend:-)“ | Einen Assessment-Titel automatisch erstellen, z. B. „DPIA – New HR tool“. Setzen Sie in einem Formular den Standardwert einer Textfrage auf: concatenate(„DPIA – „; <Feld-ID 1>): ein fester Text, gefolgt von einer Antwort concatenate(<Feld-ID 1>; “ – „; <Feld-ID 2>): zwei Antworten mit einem Trennzeichen concatenate(„Risk score: „; txt(<Feld-ID 1>)): ein Text, gefolgt von einer Zahl |
| Enthält | contains(item1; item2) | Gibt TRUE zurück, wenn der erste eingegebene TEXT den zweiten eingegebenen TEXT enthält. HINWEIS: – Dieser Ausdruck ist NICHT groß-/kleinschreibungssensitiv – Alles, was nicht „undefined“ ist, wird vor dem Vergleich in TEXT umgewandelt. | – contains(„foo“; „bar“) ⇒ false – contains(„foo“;“o“) ⇒ true – contains(undefined;undefined) ⇒ false – contains(„5“, 5) ⇒ true – contains(55, 5) ⇒ true – contains (false, „false“) ⇒ true – contains(„Sam“;“sam“) ⇒ true | Nur dann nach Marketing-Einwilligung fragen, wenn der Zweck Marketing erwähnt. Setzen Sie in einem Formular „Is Visible?“ auf Logik mit: contains(<Feld-ID 1>; „marketing“): sucht nach einem Wort in einer Textantwort (nicht groß-/kleinschreibungssensitiv) contains(<Feld-ID 1>; <Feld-ID 2>): sucht eine Antwort innerhalb einer anderen or(contains(<Feld-ID 1>; „marketing“); contains(<Feld-ID 1>; „newsletter“)): sucht nach mehreren Wörtern |
| Wenn | if(condition; item1; item2) | If-Anweisung, mit der Sie zuerst eine Bedingung eingeben können (z. B. einen anderen Ausdruck). Wenn die Bedingung TRUE ist, wird der erste Wert zurückgegeben. Wenn die Bedingung FALSE ist, wird der zweite Wert zurückgegeben. | – if(true;1;2) ⇒ 1 – if(false;1;2) ⇒ 2 – if(undefined;1;2) ⇒ 2 – if(„flar“;1;2) ⇒ 2 | Je nach Antwort ein anderes Ergebnis ausgeben. Setzen Sie in einem Formular den Standardwert einer Frage auf: if(yesno(<Feld-ID 1>); 10; 0): gibt 10 Punkte, wenn die Antwort Ja ist, sonst 0 if(islarger(<Feld-ID 1>; 10); „High“; „Low“): gibt je nach Zahl einen Text aus if(islargerorequal(<Feld-ID 1>; 15); „High“; if(islargerorequal(<Feld-ID 1>; 8); „Medium“; „Low“)): drei Stufen in einem Ausdruck |
| Und | and(conditon1; condition2; …) | Gibt TRUE zurück, wenn ALLE angegebenen Bedingungen TRUE zurückgeben. | – and(true; true) ⇒ true – and(false; false) ⇒ false – and(true; false) ⇒ false – and(„foo“; „bar“) ⇒ undefined – and(true; „flar“) ⇒ undefined – and(„true“) ⇒ undefined – and(1) ⇒ undefined – and(undefined) ⇒ undefined | Einen Abschnitt nur anzeigen, wenn mehrere Bedingungen alle wahr sind. Setzen Sie in einem Formular „Is Visible?“ auf Logik mit: and(yesno(<Feld-ID 1>); yesno(<Feld-ID 2>)): beide Antworten sind Ja and(yesno(<Feld-ID 1>); islarger(<Feld-ID 2>; 100)): eine Antwort ist Ja und eine Zahl ist größer als 100 and(<Bedingung 1>; <Bedingung 2>; <Bedingung 3>): Sie können mehr als zwei Bedingungen prüfen |
| Oder | or(condition1; condition2; …) | Gibt TRUE zurück, wenn IRGENDEINE der angegebenen Bedingungen TRUE zurückgibt. | – or(true; true) ⇒ true – or(false; false) ⇒ false – or(true; false- ⇒ true – or(„foo“; „bar“) ⇒ undefined – or(true; „flar“) ⇒ undefined – or(„true“) ⇒ undefined – or(1) ⇒ undefined – or(undefined) ⇒ undefined | Eine Frage anzeigen, wenn mindestens eine Bedingung wahr ist. Setzen Sie in einem Formular „Is Visible?“ auf Logik mit: or(yesno(<Feld-ID 1>); yesno(<Feld-ID 2>)): mindestens eine Antwort ist Ja or(includes(<Feld-ID 1>; „Health data“); includes(<Feld-ID 1>; „Biometric data“)): eine von zwei Optionen ist angekreuzt or(<Bedingung 1>; <Bedingung 2>; <Bedingung 3>): Sie können mehr als zwei Bedingungen prüfen |
| Nicht | not(condition) | Gibt TRUE zurück, wenn die Bedingung FALSE zurückgibt. | – not(true) ⇒ false – not(false) ⇒ true – not(undefined) ⇒ undefined – not(„flar“) ⇒ undefined – not(1) ⇒ undefined | Eine Bedingung umkehren: true wird false, false wird true. Setzen Sie in der Geschäftsregel eines Feldes „Hide field when“ auf: not(yesno(<Feld-ID 1>)): blendet das Feld aus, wenn die Antwort Nein ist not(isempty(<Feld-ID 1>)): blendet das Feld aus, sobald ein anderes Feld ausgefüllt ist not(includes(<Feld-ID 1>; „Other“)): blendet das Feld aus, sofern nicht „Other“ angekreuzt ist |
| IsEmpty | isempty(item) | Gibt TRUE zurück, wenn das eingegebene Element leer ist (keine Werte enthält). HINWEIS: Funktioniert für TEXT und Arrays (z. B. Multiple-Choice-Felder mit mehreren ausgewählten Werten). | – isEmpty(„“) ⇒ true – isEmpty([]) ⇒ true – isEmpty(undefined) ⇒ true – isEmpty([undefined; „“]) ⇒ true – isEmpty(„“;““;[];undefined;[undefined]) ⇒ true – isEmpty(„I am a mighty warrior!“) ⇒ false – isEmpty(false) ⇒ false – isEmpty(0) ⇒ false | Ein Feld ausblenden, bis ein anderes Feld ausgefüllt ist. Setzen Sie in der Geschäftsregel des Feldes „Hide field when“ auf: isempty(<Feld-ID 1>): blendet das Feld aus, solange das andere Feld leer ist and(isempty(<Feld-ID 1>); isempty(<Feld-ID 2>)): blendet es aus, solange beide Felder leer sind or(isempty(<Feld-ID 1>); isempty(<Feld-ID 2>)): blendet es aus, solange mindestens ein Feld leer ist |
| Enthält (Includes) | includes(list; item) | Gibt TRUE zurück, wenn das Element einem der Elemente im Array entspricht. HINWEIS: – Dieser Ausdruck ist groß-/kleinschreibungssensitiv und prüft die IDs der Optionen (nicht deren Labels) | – includes(multi-select; „option-id“) – includes([„Option 1“]; [„Option 1“]) ⇒ true – includes(false; false) ⇒ true – includes(„Option 1“; „Option 2“) ⇒ false – includes(„Option 1“; „option 1“) ⇒ false | Eine „Please specify“-Frage nur anzeigen, wenn „Other“ ausgewählt ist. Setzen Sie in einem Formular „Is Visible?“ auf Logik mit: includes(<Feld-ID 1>; „Other“): prüft, ob eine Option angekreuzt ist (groß-/kleinschreibungssensitiv) includes(<Feld-ID 1>; <Feld-ID 2>): prüft, ob die Antwort einer Frage in der Liste einer anderen enthalten ist includes(flatlist(„Belgium“; „France“; „Netherlands“); <Feld-ID 1>): prüft, ob eine Antwort in einer festen Liste enthalten ist |
| Zahl interpretieren | num(item) | Versucht, den eingegebenen Wert als Zahl zu interpretieren. HINWEIS: – Gibt den Standardwert zurück, wenn es nicht funktioniert; – Gibt immer eine Zahl zurück: – true/false → 1 / 0 – Text → versucht, als Zahl zu interpretieren; – Gibt 0 zurück, wenn nicht interpretierbar oder leer – undefined/null → leer | Beispielausdruck: add(num(<input>); 10) Eingabe und Ergebnis: – 3 => 13 – „3“ => 13 – „“ => 10 – “ “ => 10 – „/“ => 10 – „a“ => 10 – TRUE => 11 – FALSE => 10 | Stellen Sie sicher, dass eine Antwort als Zahl behandelt wird, bevor Sie sie vergleichen oder damit rechnen. Verwenden Sie es innerhalb einer anderen Funktion: num(<Feld-ID 1>): wandelt eine Antwort in eine Zahl um islarger(num(<Feld-ID 1>); 250): true, wenn die Antwort größer als 250 ist add(num(<Feld-ID 1>); 1): addiert 1 zur Antwort |
| Text interpretieren | txt(item) | Gibt eine TEXT-Darstellung eines eingegebenen Elements zurück. HINWEIS: – Dezimalzahl → auf 2 Stellen nach dem Komma gerundet, Boolean (true & false) → verwendet Übersetzungen, um „Yes“ (True) und „No“ (False) zurückzugeben – undefined/null → gibt leeren Text zurück; – Array (z. B. Liste ausgewählter Optionen) → erstellt eine kommagetrennte Liste. | Beispielausdruck: concatenate(txt(<input>); „_test“) Eingabe und Ergebnis: – 3 => 3_test – 3.567 => 3.56_test – true => yes_test – false => no_test – „“ => _test – [„Option 1“, „Option 2“, „Option 3“] => Option 1, Option 2, Option 3_test | Wandeln Sie eine Zahl oder eine Auswahl in Text um, damit Sie sie mit anderem Text kombinieren können. Verwenden Sie es innerhalb von concatenate: txt(<Feld-ID 1>): wandelt eine Antwort in Text um concatenate(„Risk score: „; txt(<Feld-ID 1>)): ergibt z. B. „Risk score: 12“ concatenate(txt(<Feld-ID 1>); “ people affected“): ergibt z. B. „500 people affected“ |
| Ja/Nein interpretieren | yesno(item) | Gibt eine Boolean-Darstellung (TRUE/FALSE) eines eingegebenen Elements zurück. HINWEIS: – Interpretiert jede Zahl außer 0 als „Yes“ – Interpretiert alles andere als „No“ | – „any-text“ => false – 3 -> true – 0 -> false – true -> true – false -> false – „yes“ -> true – „no“ -> false – „nope“ -> false – „yessir“ -> false | Eine Folgefrage nur anzeigen, wenn die vorherige Antwort Ja ist. Setzen Sie in einem Formular „Is Visible?“ auf Logik mit: yesno(<Feld-ID 1>): true, wenn eine Ja/Nein-Frage mit Ja beantwortet wurde yesno(<Feld-ID 1>): bei einer Zahlenfrage true, wenn die Zahl nicht 0 ist not(yesno(<Feld-ID 1>)): true, wenn die Antwort Nein ist |
| Attribut | attribute(relation_item; „attributeName“) | Ruft ein „Attribut“ (Feld) eines in RESPONSUM registrierten Elements in einem Untermodul ab. (z. B. die „Email“ eines Benutzerkontos) HINWEIS: – Funktioniert auch mit Arrays (z. B. Mehrfachauswahl von Elementen). Gibt ein Array mit dem Wert jedes Objekts zurück. – Der Wert eines Objekts kann wiederum ein Objekt sein. (Zum Beispiel könnte ich attribute(processing-activity, „owner“) verwenden, was etwas vom Typ „user“ zurückgeben würde. Ich könnte dann attribute(attribute(processing-activity, „owner“), „name“) verwenden, um den Namen des Owners der Verarbeitungstätigkeit zu erhalten. | – attribute(responsible_user; „name“) ⇒ „John“ – attribute(responsible_users; „email“) ⇒ [„john@responsum.eu“, „jeff@responsum.eu“] | Ein Feld eines verknüpften Elements auslesen, z. B. das Land eines verknüpften Vendors. Setzen Sie in der Geschäftsregel eines Feldes „Hide field when“ auf: attribute(<Feld-ID 1>; „name“): gibt den Namen des verknüpften Elements zurück, wobei <Feld-ID 1> die ID des Relationsfeldes ist not(equals(attribute(<Feld-ID 1>; „country“); „United States“)): blendet das Feld aus, sofern der verknüpfte Vendor nicht in den United States ist not(includes(attribute(<Feld-ID 1>; „country“); „United States“)): dasselbe, wenn mehrere Elemente verknüpft sind |
| Durchschnitt | avg(items, more_items) | Berechnet den Durchschnitt einer Reihe von bereitgestellten Parametern. Ignoriert alles, was keine Zahl ist. | – avg(1) = 1 avg(1;2) = 1.5 – avg(1;2;undefined;undefined)=1.5 – avg(undefined;“fish“;true)=undefined – avg(1;2;3;[1;2;3];undefined;“duckface“;-12)=0/7=0 | Den Durchschnitt mehrerer Scores berechnen. Setzen Sie in einem Formular den Standardwert einer Zahlenfrage auf: avg(<Feld-ID 1>; <Feld-ID 2>; <Feld-ID 3>): Durchschnitt mehrerer Antworten avg(<Feld-ID 1>; <Feld-ID 2>; 5): Durchschnitt aus Antworten und einer festen Zahl round(1; avg(<Feld-ID 1>; <Feld-ID 2>)): Durchschnitt auf eine Dezimalstelle gerundet |
| Maximum (höchste Zahl) | max(items, more_items) | Findet die höchste Zahl in einer Reihe und überspringt alles, was keine Zahl ist. | – max(1) = 1 – max(undefined) = undefined – max(undefined;1) = 1 – max(1; 2; [3; 4];“text“;-6) = 4 | Den höchsten von mehreren Scores beibehalten, z. B. als Gesamtrisiko. Setzen Sie in einem Formular den Standardwert einer Zahlenfrage auf: max(<Feld-ID 1>; <Feld-ID 2>; <Feld-ID 3>): die höchste Antwort max(<Feld-ID 1>; 1): die Antwort, aber nie kleiner als 1 max(multiply(<Feld-ID 1>; <Feld-ID 2>); <Feld-ID 3>): das Maximum aus einer Berechnung und einer Antwort |
| Minimum (niedrigste Zahl) | min(items, more_items) | Findet die niedrigste Zahl in einer Reihe und überspringt alles, was keine Zahl ist. | – min(1) = 1 – min(undefined;true;“text“) = undefined – min(undefined;1) = 1 – min(1; 2; [3; 4];“text“;-6) = -6 | Den niedrigsten von mehreren Scores beibehalten, z. B. die schwächste Kontrolle. Setzen Sie in einem Formular den Standardwert einer Zahlenfrage auf: min(<Feld-ID 1>; <Feld-ID 2>; <Feld-ID 3>): die niedrigste Antwort min(<Feld-ID 1>; 100): die Antwort, aber nie größer als 100 min(add(<Feld-ID 1>; <Feld-ID 2>); 10): eine Summe, gedeckelt auf 10 |
| Zählen | count(items, more_items) | Zählt Elemente, die innerhalb der Parameter definiert sind. Dazu gehören ausgewählte Optionen in Multiple-Choice-Fragen und die Anzahl der Elemente in einem wiederholbaren Abschnitt. | Nützlich zum Zählen z. B. der Anzahl ausgewählter Elemente in einem Dropdown oder der Anzahl von Objekten, die in einem Relationsfeld ein bestimmtes Attribut definiert haben (in Kombination mit attribute) – count(„my_option_field“) → 3 (vorausgesetzt, im Feld mit der ID „my_option_field“ sind 3 Optionen ausgewählt) – count([50, 3]) → 2 – count(undefined) → 0 count([„foo“, undefined]) → 1 – count(50) → 1 – count(false) → 1 – count(1, 2, undefined, [3, 4, undefined], „two apples“) → 5 – count(section_id) → 1 (vorausgesetzt, es handelt sich um einen nicht wiederholbaren Abschnitt) | Zählen, wie viele Optionen angekreuzt sind oder wie viele Einträge ein wiederholbarer Abschnitt hat. Setzen Sie in einem Formular „Is Visible?“ auf Logik mit: count(<Feld-ID 1>): Anzahl angekreuzter Optionen in einer Multiple-Choice-Frage count(<Feld-ID 2>): Anzahl der Einträge in einem wiederholbaren Abschnitt, wobei <Feld-ID 2> die ID des Abschnitts ist islarger(count(<Feld-ID 2>); 5): true, wenn es mehr als 5 Einträge gibt |
| Runden | roundup(decimals, numbers) rounddown(decimals, numbers) round(decimals, numbers) | Rundet die Zahl (auf, ab oder auf die nächste), bis zu einer Anzahl von Dezimalstellen, die im ersten Argument angegeben ist. Ignoriert alles, was keine Zahl ist. | Aufrunden: – roundup(0; 2) = 2 – roundup(0; 2.00001) = 3 roundup(0; [2.1; 3.1; 4]; 5; „text“; 99) = [3, 4, 4, 5, 99] – roundup(0; „text“) = undefined – roundup(„text“, 1) = undefined – roundup(2; 5,7777) = 5,78 Abrunden: – rounddown(2; 5,7777) = 5,77 Runden (nächster Wert): – round(0; 5.1) = 5 – round(0; 5.6) = 6 | Runden Sie eine Zahl auf die von Ihnen gewählte Anzahl an Dezimalstellen. Der erste Wert ist die Anzahl der Dezimalstellen. Setzen Sie in einem Formular den Standardwert einer Zahlenfrage auf: round(0; <Feld-ID 1>): rundet eine Antwort auf eine ganze Zahl round(2; divide(<Feld-ID 1>; <Feld-ID 2>)): rundet eine Berechnung auf 2 Dezimalstellen roundup(0; <Feld-ID 1>) oder rounddown(0; <Feld-ID 1>): rundet immer auf oder immer ab |
| Liste erstellen | flatlist(item_1, item_2, item_3) | Fasst alle Eingaben zu einer Liste zusammen. | – flatlist(1; 2; 3; – flatlist(4; 5;flatlist(6))) = [1, 2, 3, 4, 5, 6] – flatlist(undefined; 1; „flar“) = [undefined, 1, „flar“] | Mehrere Antworten oder Werte zu einer Liste kombinieren. Verwenden Sie es innerhalb einer anderen Funktion, z. B. includes: flatlist(<Feld-ID 1>; <Feld-ID 2>): kombiniert die Antworten zweier Fragen flatlist(„Health data“; „Biometric data“): erstellt eine feste Liste includes(flatlist(<Feld-ID 1>; <Feld-ID 2>); „Health data“): prüft, ob „Health data“ in einer der beiden Fragen angekreuzt ist |
Da dies Ihre Formulare/Fragebögen erheblich komplexer machen kann, wenden Sie sich bei Bedarf bitte über support@responsum.eu an uns.
Wir haben Consultants, die Sie dabei begleiten oder diese Aufgabe vollständig übernehmen können, damit Ihr Formular/Fragebogen das erwartete Verhalten zeigt.