ApptiveScript-Funktionen

Vollständige Liste der Funktionen, die in einem Ausdruck zur Verfügung stehen — in Formelspalten, in der bedingten Sichtbarkeit von Blöcken, in Flow-Bedingungen und in Filtern.

Diese Seite ist zum Nachschlagen gedacht. Wenn Sie zum ersten Mal einen Ausdruck schreiben, fangen Sie bei Was ist ApptiveScript an.

So lesen Sie die Tabellen

Ein Ausdruck ist immer Wert, Punkt, Funktion:

fieldValue('preis').multiplyBy(1.19)

Links vom Punkt steht ein Wert, rechts eine Funktion aus der Tabelle seines Typs. Das Ergebnis hat wieder einen Typ — und darauf können Sie erneut eine Funktion anwenden:

fieldValue('nachname').concat(fieldValue('vorname'), ', ').isNotEmpty()

Spalte	Bedeutung
Funktion	Der Name, so wie er geschrieben wird. Einträge mit vorangestelltem Punkt und ohne Klammern — etwa `.email` — sind Eigenschaften und brauchen keine Argumente.
Argumente	Was in die Klammern gehört, in dieser Reihenfolge: `name: Typ`.
Ergebnis	Der Typ des Ergebnisses. Er entscheidet, welche Tabelle für den nächsten Punkt gilt. `Any` heißt: ein Wert, dessen Typ erst beim Auswerten feststeht — etwa bei einem Wert aus JSON-Daten.

Funktionsnamen sind englisch und bleiben es auch in der deutschen Oberfläche. Groß- und Kleinschreibung ist verbindlich.

Der Typ steht im Editor

Der Dialog Einen Ausdruck bearbeiten zeigt über dem Beispielergebnis den ermittelten Typ an — Typ: String, Typ: Number und so weiter. Damit finden Sie die Tabelle, die für den nächsten Punkt gilt. Der Reiter Search im Editor führt ohnehin nur die Funktionen des gerade ermittelten Typs.

Mit oder ohne geschweifte Klammern

Wo Sie schreiben	Schreibweise
Formeleditor, Sichtbarkeit, erweiterte Flow-Logik	nur der Ausdruck: `fieldValue('preis').multiplyBy(1.19)`
normales Textfeld in einem Flow-Schritt	in Klammern: `Ihre Rechnung über {{ fieldValue('betrag') }} Euro`

Ein Ausdruck ohne Klammern behält seinen Typ. Sobald Sie ihn in einen Text einbauen, ist das Ergebnis Text — und lässt sich nicht mehr weiterrechnen.

Werte in den Ausdruck holen

Womit ein Ausdruck anfängt, hängt davon ab, wo er steht:

Einstieg	Bedeutung	Verwendet in
`fieldValue('<Feld-Id>')`	ein Feld des aktuellen Eintrags	Formelspalten, Filter
`formValues.get('<Key>')`	ein Eingabewert der Seite	bedingte Sichtbarkeit
`step('<Schritt-Id>').output`	das Ergebnis eines früheren Flow-Schritts	Flows
`today()`	das heutige Datum	überall
`now()`	der aktuelle Zeitpunkt	überall
`true`, `false`	feste Wahrheitswerte	überall

Feld-Ids und Schritt-Ids tippt niemand von Hand — der Editor fügt sie über den Picker ein. Der Key eines Eingabeblocks ist dagegen selbst gewählt; er steht unter Keys verwalten.

Ids sind keine Namen

fieldValue('…') verweist auf die Id einer Spalte, nicht auf ihren Namen. Das ist gewollt: Eine Formel überlebt damit das Umbenennen der Spalte. Umgekehrt heißt es aber auch, dass sich ein Ausdruck nicht durch Lesen der Feldnamen prüfen lässt.

Leere Werte

Ein Feld, das nicht gefüllt ist, liefert keinen Fehler, sondern einen leeren Wert. Zwei Funktionen fangen das ab:

Funktion	Wirkung
`ifUndefined(<Ersatzwert>)`	setzt einen Ersatzwert ein, wenn der Wert fehlt
`isEmpty()` / `isNotEmpty()`	prüft, ob ein Wert fehlt

fieldValue('spitzname').ifUndefined('unbekannt')

ifUndefined gibt es auf jedem Typ, isEmpty() und isNotEmpty() auf fast jedem — bei Zahl, allgemein nicht. Die Tabellen weiter unten sagen es genau.

Aus einer Liste einen Wert holen

Einige Funktionen liefern eine Liste statt eines einzelnen Wertes — etwa match(), das alle Treffer eines Suchmusters sammelt. An einen einzelnen Eintrag kommen Sie mit at():

'a,b,c'.match('[a-z]').at(1)

Das ergibt a — der erste Eintrag hat die Nummer 1, nicht 0. Wie viele es sind, sagt size().

Eine Liste ist kein anzeigbarer Wert

Eine Formelspalte muss auf einem einzelnen Wert enden. Hört der Ausdruck bei der Liste auf, kann die Spalte ihn nicht darstellen — hängen Sie at() an.

Erzeugt aus ApptiveScript 0.4.13 mit npm run apptivescript:reference.

Auf jedem Typ verfügbar

Diese Funktionen gibt es unabhängig davon, was links vom Punkt steht. In den Tabellen der einzelnen Typen sind sie deshalb nicht wiederholt.

Funktion	Argumente	Ergebnis
`ifUndefined(…)`	default: Any	`Any`
`isEqualTo(…)`	other: gleicher Typ	`Boolean`
`isNotEqualTo(…)`	other: gleicher Typ	`Boolean`

Text

Text (String)

Funktion	Argumente	Ergebnis
`asDateAndTime()`	—	`DateAndTime`
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`asNumber()`	—	`Number`
`beginsWith(…)`	prefix: String	`Boolean`
`concat(…)`	string: String, separator: String	`String`
`contains(…)`	substring: String	`Boolean`
`endsWith(…)`	postfix: String	`Boolean`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`match(…)`	pattern: String	`Collection`
`parseJSON()`	—	`KeyValueObject`
`sha256()`	—	`String`
`substring(…)`	from: Number, to: Number	`String`

Einzelauswahl (Enum)

Funktion	Argumente	Ergebnis
`asDateAndTime()`	—	`DateAndTime`
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`asNumber()`	—	`Number`
`beginsWith(…)`	prefix: String	`Boolean`
`concat(…)`	string: String, separator: String	`String`
`contains(…)`	substring: String	`Boolean`
`endsWith(…)`	postfix: String	`Boolean`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`match(…)`	pattern: String	`Collection`
`parseJSON()`	—	`KeyValueObject`
`substring(…)`	from: Number, to: Number	`String`

E-Mail (String)

Funktion	Argumente	Ergebnis
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`beginsWith(…)`	prefix: String	`Boolean`
`concat(…)`	string: String, separator: String	`String`
`contains(…)`	substring: String	`Boolean`
`endsWith(…)`	postfix: String	`Boolean`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`match(…)`	pattern: String	`Collection`
`parseJSON()`	—	`KeyValueObject`
`substring(…)`	from: Number, to: Number	`String`

Zahlen

Zahl, allgemein (Number)

Funktion	Argumente	Ergebnis
`asString()`	—	`String`
`divideBy(…)`	number: Number	`Number`
`greaterThan(…)`	number: Number	`Boolean`
`greaterThanOrEqual(…)`	number: Number	`Boolean`
`minus(…)`	number: Number	`Number`
`multiplyBy(…)`	number: Number	`Number`
`plus(…)`	number: Number	`Number`
`round(…)`	number: Number	`Number`
`roundDown(…)`	number: Number	`Number`
`roundUp(…)`	number: Number	`Number`
`smallerThan(…)`	number: Number	`Boolean`
`smallerThanOrEqual(…)`	number: Number	`Boolean`

Zahl (Integer)

Funktion	Argumente	Ergebnis
`asDateAndTime()`	—	`String`
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`asString()`	—	`String`
`divideBy(…)`	number: Number	`Number`
`greaterThan(…)`	number: Number	`Boolean`
`greaterThanOrEqual(…)`	number: Number	`Boolean`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`minus(…)`	number: Number	`Number`
`multiplyBy(…)`	number: Number	`Number`
`plus(…)`	number: Number	`Number`
`round(…)`	number: Number	`Decimal`
`roundDown(…)`	number: Number	`Decimal`
`roundUp(…)`	number: Number	`Decimal`
`second()`	—	`Duration`
`seconds()`	—	`Duration`
`smallerThan(…)`	number: Number	`Boolean`
`smallerThanOrEqual(…)`	number: Number	`Boolean`

Kommazahl und Währung (Decimal)

Funktion	Argumente	Ergebnis
`asDateAndTime()`	—	`String`
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`asString()`	—	`String`
`divideBy(…)`	number: Number	`Decimal`
`greaterThan(…)`	number: Number	`Boolean`
`greaterThanOrEqual(…)`	number: Number	`Boolean`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`minus(…)`	number: Number	`Decimal`
`multiplyBy(…)`	number: Number	`Decimal`
`plus(…)`	number: Number	`Decimal`
`round(…)`	number: Number	`Decimal`
`roundDown(…)`	number: Number	`Decimal`
`roundUp(…)`	number: Number	`Decimal`
`smallerThan(…)`	number: Number	`Boolean`
`smallerThanOrEqual(…)`	number: Number	`Boolean`

Datum und Zeit

Datum (Date)

Funktion	Argumente	Ergebnis
`add(…)`	amount: Number, unit: String	`DateAndTime`
`addDays(…)`	numberOfDays: Number	`Date`
`after(…)`	date: Date	`Boolean`
`before(…)`	date: Date	`Boolean`
`difference(…)`	date: Date	`Duration`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`isoString()`	—	`String`
`minus(…)`	date: Date	`Duration`
`plus(…)`	duration: Duration	`Duration`
`subtract(…)`	amount: Number, unit: String	`DateAndTime`
`subtractDays(…)`	numberofDays: Number	`Date`

Datum und Uhrzeit (DateAndTime)

Funktion	Argumente	Ergebnis
`add(…)`	amount: Number, unit: String	`DateAndTime`
`after(…)`	dateAndTime: DateAndTime	`Boolean`
`before(…)`	dateAndTime: DateAndTime	`Boolean`
`date()`	—	`Date`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`isoString()`	—	`String`
`minus(…)`	dateAndTime: DateAndTime	`Duration`
`plus(…)`	dateAndTime: DateAndTime	`Duration`
`subtract(…)`	amount: Number, unit: String	`DateAndTime`
`toTimezoneString(…)`	timezone: String	`String`

Zeitspanne (Duration)

Funktion	Argumente	Ergebnis
`asDays()`	—	`Decimal`
`asHours()`	—	`Decimal`
`asMinutes()`	—	`Decimal`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`

Wahrheitswerte

Häkchen und Entscheidung (Boolean)

Funktion	Argumente	Ergebnis
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`if(…)`	if: Any, else: Any	`Any`
`isEmpty()`	—	`Boolean`
`isFalse()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`isTrue()`	—	`Boolean`
`logicalAnd(…)`	other: Boolean	`Boolean`
`logicalOr(…)`	other: Boolean	`Boolean`

Listen

Liste, allgemein (Collection)

Funktion	Argumente	Ergebnis
`add(…)`	element: Any	`Collection`
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`asList()`	—	`Collection`
`asString()`	—	`String`
`at(…)`	index: Integer	`Any`
`includesAllOf(…)`	entities: Collection	`Boolean`
`includesAnyOf(…)`	entities: Collection	`Boolean`
`includesNoneOf(…)`	entities: Collection	`Boolean`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`size()`	—	`Integer`

Mehrfachauswahl (EnumCollection)

Funktion	Argumente	Ergebnis
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`asString()`	—	`String`
`at(…)`	index: Integer	`Any`
`includes(…)`	entity: Boolean	`EnumCollection`
`includesAll(…)`	entities: Collection	`EnumCollection`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`size()`	—	`Integer`

Mehrere Einträge verknüpfen (EntityCollection)

Funktion	Argumente	Ergebnis
`add(…)`	element: String	`EntityCollection`
`addEntity(…)`	element: String	`EntityCollection`
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`asString()`	—	`String`
`at(…)`	index: Integer	`Any`
`includes(…)`	entity: Boolean	`EntityCollection`
`includesAll(…)`	entities: Collection	`EntityCollection`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`size()`	—	`Integer`

Zusammengesetzte Werte

JSON-Objekt (KeyValueObject)

Funktion	Argumente	Ergebnis
`asJSONString()`	—	`String`
`asJSONStringContent()`	—	`String`
`asJSONStringPretty()`	—	`String`
`get(…)`	key: String	`Any`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`

Dateien (Attachment)

Funktion	Argumente	Ergebnis
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`largeThumbnail()`	—	`String`
`smallThumbnail()`	—	`String`
`url()`	—	`String`

Geolokalisierung (GeoCoordinate)

Funktion	Argumente	Ergebnis
`asJSONString()`	—	`String`
`asString()`	—	`String`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`
`lat()`	—	`Number`
`latitude()`	—	`Number`
`lon()`	—	`Number`
`longitude()`	—	`Number`

Benutzer (User)

Funktion	Argumente	Ergebnis
`.email`	—	`String`
`.firstName`	—	`String`
`.id`	—	`String`
`.lastName`	—	`String`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`

Erstellt von (CreatedByValue)

Funktion	Argumente	Ergebnis
`.email`	—	`String`
`.id`	—	`String`
`.type`	—	`String`
`displayValue()`	—	`String`
`isEmpty()`	—	`Boolean`
`isNotEmpty()`	—	`Boolean`

Beispiele

Eine Auswahl häufig gebrauchter Funktionen mit Wirkung und Beispiel. Die vollständige Signatur steht in den Tabellen oben — hier geht es darum, was die Funktion tut.

add(amount: Number, unit: String) → DateAndTime

Zählt eine Menge in der angegebenen Einheit zu einem Datum hinzu. Bestätigt funktionieren 'day', 'week', 'year', 'hour' und 'minute' (Singular) — 'month'/'months' dagegen nicht; für Monate gibt es keinen Ersatz, für Tage addDays().

fieldValue('start').add(1, 'week')

Ergebnis: das Datum eine Woche später

addDays(numberOfDays: Number) → Date

Zählt Tage zu einem Datum hinzu.

fieldValue('liefertermin').addDays(7)

Ergebnis: das Datum eine Woche später

addEntity(element: String) → EntityCollection

Verknüpft einen weiteren Eintrag über seine Id.

fieldValue('verknuepft').addEntity(fieldValue('neuerEintrag'))

Ergebnis: die Liste mit dem zusätzlichen Eintrag

after(date: Date) → Boolean

Prüft, ob das Datum nach dem Argument liegt.

fieldValue('start').after(fieldValue('ende'))

Ergebnis: true, wenn start nach ende liegt

asDateAndTime() → DateAndTime

Liest Text im ISO-Format als Datum mit Uhrzeit.

'2026-08-18T10:00:00Z'.asDateAndTime()

Ergebnis: derselbe Zeitpunkt als DateAndTime

asDays() → Decimal

Die Zeitspanne als Anzahl Tage.

fieldValue('ende').difference(fieldValue('start')).asDays()

Ergebnis: die Zeitspanne in Tagen, z. B. 2.5

asHours() → Decimal

Die Zeitspanne als Anzahl Stunden.

fieldValue('ende').difference(fieldValue('start')).asHours()

Ergebnis: die Zeitspanne in Stunden

asJSONStringContent() → String

Die JSON-Darstellung des Werts, ohne die äußeren Anführungszeichen bei Text.

'abc'.asJSONStringContent()

Ergebnis: 'abc'

asJSONStringPretty() → String

Die JSON-Darstellung des Werts, mit Anführungszeichen bei Text.

'abc'.asJSONStringPretty()

Ergebnis: "abc"

asList() → Collection

Liefert eine leere Liste statt nichts, wenn kein Wert vorhanden ist — das Pendant zu ifUndefined() für Listen.

fieldValue('verknuepft').asList()

Ergebnis: die Liste, oder eine leere Liste, wenn das Feld leer ist

asMinutes() → Decimal

Die Zeitspanne als Anzahl Minuten.

fieldValue('ende').difference(fieldValue('start')).asMinutes()

Ergebnis: die Zeitspanne in Minuten

asNumber() → Number

Wandelt Text in eine Zahl um.

'42'.asNumber()

Ergebnis: 42

asString() → String

Wandelt die Zahl in Text um.

fieldValue('menge').asString()

Ergebnis: die Zahl als Text, z. B. für concat()

at(index: Integer) → Any

Liest einen Eintrag aus einer Liste heraus — der erste Eintrag hat die Nummer 1, nicht 0.

'a,b,c'.match('[a-z]').at(1)

Ergebnis: 'a'

before(date: Date) → Boolean

Prüft, ob das Datum vor dem Argument liegt.

fieldValue('start').before(fieldValue('ende'))

Ergebnis: true, wenn start vor ende liegt

beginsWith(prefix: String) → Boolean

Prüft, ob der Text mit der Zeichenfolge beginnt.

'Hallo Welt'.beginsWith('Hallo')

Ergebnis: true

concat(string: String, separator: String) → String

Hängt einen weiteren Text an, getrennt durch das zweite Argument.

'Müller'.concat('Anna', ', ')

Ergebnis: 'Müller, Anna'

contains(substring: String) → Boolean

Prüft, ob der Text die Zeichenfolge enthält.

'Hallo Welt'.contains('Welt')

Ergebnis: true

date() → Date

Der Datumsanteil eines Zeitpunkts, ohne Uhrzeit.

fieldValue('erstellt').date()

Ergebnis: das Datum ohne Uhrzeit

difference(date: Date) → Duration

Berechnet die Zeitspanne zwischen zwei Daten.

fieldValue('ende').difference(fieldValue('start'))

Ergebnis: eine Duration — etwa mit .asDays() weiterverwenden

displayValue() → String

Eine lesbare Kurzform, wer oder was den Eintrag angelegt hat.

fieldValue('erstelltVon').displayValue()

Ergebnis: ein lesbarer Name oder eine E-Mail-Adresse

divideBy(number: Number) → Number

Teilt die Zahl durch das Argument.

fieldValue('gesamtpreis').divideBy(fieldValue('menge'))

Ergebnis: der Preis pro Einheit

endsWith(postfix: String) → Boolean

Prüft, ob der Text mit der Zeichenfolge endet.

'Hallo Welt'.endsWith('Welt')

Ergebnis: true

get(key: String) → Any

Liest einen Wert aus einem JSON-Objekt anhand seines Schlüssels.

'{"stadt":"Berlin"}'.parseJSON().get('stadt')

Ergebnis: 'Berlin'

greaterThan(number: Number) → Boolean

Prüft, ob die Zahl größer als das Argument ist.

3.greaterThan(2)

Ergebnis: true

greaterThanOrEqual(number: Number) → Boolean

Prüft, ob die Zahl größer oder gleich dem Argument ist.

3.greaterThanOrEqual(3)

Ergebnis: true

if(if: Any, else: Any) → Any

Wählt zwischen zwei Werten, je nachdem ob der Wahrheitswert zutrifft.

fieldValue('aktiv').if('aktiv', 'inaktiv')

Ergebnis: 'aktiv', wenn das Feld angehakt ist, sonst 'inaktiv'

ifUndefined(default: Any) → Any

Setzt einen Ersatzwert ein, wenn der Wert fehlt.

fieldValue('spitzname').ifUndefined('unbekannt')

Ergebnis: der Feldwert, oder 'unbekannt', wenn das Feld leer ist

includesAllOf(entities: Collection) → Boolean

Prüft, ob alle angegebenen Einträge in der Liste vorkommen.

fieldValue('tags').includesAllOf(fieldValue('erforderlicheTags'))

Ergebnis: true, wenn jeder gesuchte Eintrag enthalten ist

includesAnyOf(entities: Collection) → Boolean

Prüft, ob mindestens einer der angegebenen Einträge in der Liste vorkommt.

fieldValue('tags').includesAnyOf(fieldValue('gesuchteTags'))

Ergebnis: true, wenn sich beide Listen überschneiden

includesNoneOf(entities: Collection) → Boolean

Prüft, ob keiner der angegebenen Einträge in der Liste vorkommt.

fieldValue('tags').includesNoneOf(fieldValue('ausgeschlosseneTags'))

Ergebnis: true, wenn sich die Listen nicht überschneiden

isEmpty() → Boolean

Prüft, ob kein Wert vorhanden ist.

fieldValue('spitzname').isEmpty()

Ergebnis: true, wenn das Feld leer ist

isEqualTo(other: String) → Boolean

Prüft, ob zwei Werte gleich sind.

'a'.isEqualTo('a')

Ergebnis: true

isFalse() → Boolean

Prüft, ob der Wert falsch ist.

false.isFalse()

Ergebnis: true

isNotEmpty() → Boolean

Prüft, ob ein Wert vorhanden ist.

fieldValue('spitzname').isNotEmpty()

Ergebnis: true, wenn das Feld gefüllt ist

isNotEqualTo(other: String) → Boolean

Prüft, ob zwei Werte verschieden sind.

'a'.isNotEqualTo('b')

Ergebnis: true

isTrue() → Boolean

Prüft, ob der Wert wahr ist.

true.isTrue()

Ergebnis: true

isoString() → String

Das Datum als Text im ISO-Format.

fieldValue('liefertermin').isoString()

Ergebnis: das Datum als Text, z. B. '2026-08-18'

largeThumbnail() → String

Die Adresse einer großen Vorschau der Datei.

fieldValue('anhang').largeThumbnail()

Ergebnis: die Adresse der großen Vorschau

lat() → Number

Der Breitengrad einer Geolokalisierung — wie latitude().

fieldValue('standort').lat()

Ergebnis: der Breitengrad als Zahl

latitude() → Number

Der Breitengrad einer Geolokalisierung.

fieldValue('standort').latitude()

Ergebnis: der Breitengrad als Zahl

logicalAnd(other: Boolean) → Boolean

Wahr, wenn beide Werte wahr sind.

fieldValue('geprüft').logicalAnd(fieldValue('freigegeben'))

Ergebnis: true, nur wenn beide Felder angehakt sind

logicalOr(other: Boolean) → Boolean

Wahr, wenn mindestens einer der beiden Werte wahr ist.

fieldValue('dringend').logicalOr(fieldValue('überfällig'))

Ergebnis: true, wenn mindestens eines der Felder angehakt ist

lon() → Number

Der Längengrad einer Geolokalisierung — wie longitude().

fieldValue('standort').lon()

Ergebnis: der Längengrad als Zahl

longitude() → Number

Der Längengrad einer Geolokalisierung.

fieldValue('standort').longitude()

Ergebnis: der Längengrad als Zahl

match(pattern: String) → Collection

Sammelt alle Treffer eines Suchmusters als Liste.

'a,b,c'.match('[a-z]')

Ergebnis: eine Liste mit 3 Treffern: 'a', 'b', 'c'

minus(number: Number) → Number

Subtrahiert das Argument von der Zahl.

fieldValue('brutto').minus(fieldValue('rabatt'))

Ergebnis: die Differenz beider Felder

multiplyBy(number: Number) → Number

Multipliziert die Zahl mit dem Argument.

fieldValue('preis').multiplyBy(1.19)

Ergebnis: der Preis inklusive 19 % Aufschlag

parseJSON() → KeyValueObject

Liest Text als JSON und macht seine Felder mit get() zugänglich.

'{"stadt":"Berlin"}'.parseJSON()

Ergebnis: ein JSON-Objekt — weiter mit .get('stadt')

plus(number: Number) → Number

Addiert zwei Zahlen.

fieldValue('grundpreis').plus(fieldValue('versand'))

Ergebnis: die Summe beider Felder

round(number: Number) → Number

Rundet kaufmännisch auf die angegebene Anzahl Nachkommastellen.

fieldValue('preis').round(2)

Ergebnis: der Preis mit 2 Nachkommastellen

roundDown(number: Number) → Number

Rundet auf die angegebene Anzahl Nachkommastellen — immer abwärts.

fieldValue('preis').roundDown(0)

Ergebnis: die nächstkleinere ganze Zahl

roundUp(number: Number) → Number

Rundet auf die angegebene Anzahl Nachkommastellen — immer aufwärts.

fieldValue('preis').roundUp(0)

Ergebnis: die nächstgrößere ganze Zahl

second() → Duration

Baut aus einer Zahl eine Zeitspanne in Sekunden.

fieldValue('wartezeit').second()

Ergebnis: eine Zeitspanne, z. B. 5 Sekunden

seconds() → Duration

Baut aus einer Zahl eine Zeitspanne in Sekunden — wie second().

fieldValue('wartezeit').seconds()

Ergebnis: eine Zeitspanne, z. B. 5 Sekunden

sha256() → String

Bildet den SHA-256-Hashwert des Texts — 64 Hexadezimalzeichen in Kleinschreibung, gerechnet über den Text als UTF-8. Derselbe Text ergibt immer denselben Hashwert; zurückrechnen lässt er sich nicht.

'Hallo Welt'.sha256()

Ergebnis: '2d2da19605a34e037dbe82173f98a992a530a5fdd53dad882f570d4ba204ef30'

size() → Integer

Zählt die Einträge einer Liste.

'a,b,c'.match('[a-z]').size()

Ergebnis: 3

smallThumbnail() → String

Die Adresse einer kleinen Vorschau der Datei.

fieldValue('anhang').smallThumbnail()

Ergebnis: die Adresse der kleinen Vorschau

smallerThan(number: Number) → Boolean

Prüft, ob die Zahl kleiner als das Argument ist.

2.smallerThan(3)

Ergebnis: true

smallerThanOrEqual(number: Number) → Boolean

Prüft, ob die Zahl kleiner oder gleich dem Argument ist.

2.smallerThanOrEqual(2)

Ergebnis: true

substring(from: Number, to: Number) → String

Schneidet einen Ausschnitt aus dem Text — der erste Buchstabe hat die Nummer 1, wie bei at().

'Hallo Welt'.substring(1, 5)

Ergebnis: 'Hallo'

subtract(amount: Number, unit: String) → DateAndTime

Zieht eine Menge in der angegebenen Einheit ab. Wie bei add() funktionieren 'day', 'week', 'year', 'hour' und 'minute', 'month'/'months' nicht — für Tage subtractDays() verwenden.

fieldValue('start').subtract(1, 'week')

Ergebnis: das Datum eine Woche früher

subtractDays(numberofDays: Number) → Date

Zieht Tage von einem Datum ab.

fieldValue('liefertermin').subtractDays(7)

Ergebnis: das Datum eine Woche früher

toTimezoneString(timezone: String) → String

Formatiert Datum und Uhrzeit für eine andere Zeitzone.

fieldValue('zeitstempel').toTimezoneString('Europe/Berlin')

Ergebnis: der Zeitstempel in der angegebenen Zeitzone

url() → String

Die Adresse, unter der die Datei heruntergeladen werden kann.

fieldValue('anhang').url()

Ergebnis: die Download-Adresse als Text

add(element: Any) → Collection — auf Collection

Hängt einen Eintrag ans Ende der Liste an. Nicht zu verwechseln mit add() auf einem Datum, das eine Zeitmenge addiert.

'a,b,c'.match('[a-z]').add('d')

Ergebnis: die Liste a, b, c, d

minus(date: Date) → Duration — auf Date

Zieht ein Datum von einem Datum ab und liefert die Zeitspanne dazwischen — nicht zu verwechseln mit minus() auf Zahlen. Für Tage oder Stunden mit asDays(), asHours() weiterrechnen.

fieldValue('ende').minus(fieldValue('start'))

Ergebnis: die Zeitspanne von start bis ende als Duration

plus(duration: Duration) → Duration — auf Date

Addiert eine Zeitspanne zu einem Datum. Das Ergebnis ist ein Zeitpunkt mit Uhrzeit, auch wenn die Signatur Duration nennt. Für ganze Tage ist addDays() der einfachere Weg.

fieldValue('start').plus(fieldValue('wartezeit').seconds())

Ergebnis: der Zeitpunkt um wartezeit Sekunden nach start

minus(dateAndTime: DateAndTime) → Duration — auf DateAndTime

Zieht einen Zeitpunkt von einem Zeitpunkt ab und liefert die Zeitspanne dazwischen — nicht zu verwechseln mit minus() auf Zahlen. Mit asHours() oder asMinutes() weiterrechnen.

fieldValue('ende').minus(fieldValue('start'))

Ergebnis: die Zeitspanne von start bis ende als Duration

plus(dateAndTime: DateAndTime) → Duration — auf DateAndTime

Addiert eine Zeitspanne zu einem Zeitpunkt. Das Ergebnis ist wieder ein Zeitpunkt, auch wenn die Signatur Duration als Ergebnis und einen DateAndTime als Argument nennt.

fieldValue('start').plus(fieldValue('wartezeit').seconds())

Ergebnis: der Zeitpunkt um wartezeit Sekunden nach start

add(element: String) → EntityCollection — auf EntityCollection

Verknüpft einen weiteren Eintrag über seine Id — dasselbe wie addEntity().

fieldValue('verknuepft').add(fieldValue('neuerEintrag'))

Ergebnis: die Liste mit dem zusätzlichen Eintrag

Weiter

Schreibweise — Punkt, Klammern, Anführungszeichen
Werte referenzieren — womit ein Ausdruck anfängt
Berechnete Felder — Formelspalten anlegen
Bedingte Sichtbarkeit — Blöcke abhängig von Eingaben zeigen
Filterbedingungen — dieselben Vergleiche über die Oberfläche
Glossar

ApptiveScript-Funktionen ​

So lesen Sie die Tabellen ​

Mit oder ohne geschweifte Klammern ​

Werte in den Ausdruck holen ​

Leere Werte ​

Aus einer Liste einen Wert holen ​

Auf jedem Typ verfügbar ​

Text ​

Text (String) ​

Einzelauswahl (Enum) ​

E-Mail (String) ​

Zahlen ​

Zahl, allgemein (Number) ​

Zahl (Integer) ​

Kommazahl und Währung (Decimal) ​

Datum und Zeit ​

Datum (Date) ​

Datum und Uhrzeit (DateAndTime) ​

Zeitspanne (Duration) ​

Wahrheitswerte ​

Häkchen und Entscheidung (Boolean) ​

Listen ​

Liste, allgemein (Collection) ​

Mehrfachauswahl (EnumCollection) ​

Mehrere Einträge verknüpfen (EntityCollection) ​

Zusammengesetzte Werte ​

JSON-Objekt (KeyValueObject) ​

Dateien (Attachment) ​

Geolokalisierung (GeoCoordinate) ​

Benutzer (User) ​

Erstellt von (CreatedByValue) ​

Beispiele ​

Weiter ​

ApptiveScript-Funktionen

So lesen Sie die Tabellen

Mit oder ohne geschweifte Klammern

Werte in den Ausdruck holen

Leere Werte

Aus einer Liste einen Wert holen

Auf jedem Typ verfügbar

Text

Text (String)

Einzelauswahl (Enum)

E-Mail (String)

Zahlen

Zahl, allgemein (Number)

Zahl (Integer)

Kommazahl und Währung (Decimal)

Datum und Zeit

Datum (Date)

Datum und Uhrzeit (DateAndTime)

Zeitspanne (Duration)

Wahrheitswerte

Häkchen und Entscheidung (Boolean)

Listen

Liste, allgemein (Collection)

Mehrfachauswahl (EnumCollection)

Mehrere Einträge verknüpfen (EntityCollection)

Zusammengesetzte Werte

JSON-Objekt (KeyValueObject)

Dateien (Attachment)

Geolokalisierung (GeoCoordinate)

Benutzer (User)

Erstellt von (CreatedByValue)

Beispiele

Weiter