JSONArray.addAll(JSONArray)

Diese Methode hängt ein Array an ein anderes an.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "toppings_array": ["onion", "olives"],
    "more_toppings": ["mushroom","pepperoni"]
  }
}

Nehmen Sie die folgende Aktualisierung vor:

{
  "context": {
    "toppings_array": "<? $toppings_array.addAll($more_toppings) ?>"
  }
}

Ergebnis: Die Methode selbst gibt null zurück. Das erste Array wird jedoch aktualisiert, um die Werte aus dem zweiten Array einzuschließen.

{
  "context": {
    "toppings_array": ["onion", "olives", "mushroom", "pepperoni"]
  }
}

JSONArray.append(object)

Diese Methode hängt einen neuen Wert an das JSON-Array an und gibt das geänderte JSON-Array zurück.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "toppings_array": ["onion", "olives"]
  }
}

Nehmen Sie die folgende Aktualisierung vor:

{
  "context": {
    "toppings_array": "<? $toppings_array.append('ketchup', 'tomatoes') ?>"
  }
}

Ergebnis:

{
  "context": {
    "toppings_array": ["onion", "olives", "ketchup", "tomatoes"]
  }
}

JSONArray.clear()

Diese Methode löscht alle Werte in dem Array und gibt null zurück.

Verwenden Sie den folgenden Ausdruck in der Ausgabe, um ein Feld zu definieren, das den Inhalt eines Arrays löscht, in dem Sie die Werte einer Kontextvariablen ($toppings_array) gespeichert haben.

{
  "output": {
    "array_eraser": "<? $toppings_array.clear() ?>"
  }
}

Wenn Sie dann auf die Kontextvariable $toppings_array verweisen, wird nur " [] " zurückgegeben.

JSONArray.contains(Object value)

Diese Methode gibt 'true' zurück, wenn das eingegebene JSON-Array den Eingabewert enthält.

Für diesen Dialog-Laufzeitkontext, der von einem vorherigen Knoten oder einer externen Anwendung festgelegt wurde:

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Dialogmodulknoten oder Antwortbedingung:

$toppings_array.contains('ham')

Ergebnis: true, da das Array das Element hamenthält.

JSONArray.containsIgnoreCase(Object value)

Diese Methode gibt true zurück, wenn das eingegebene JSON-Array den Eingabewert enthält, unabhängig davon, ob der Wert in Groß-oder Kleinbuchstaben angegeben ist.

Für diesen Dialog-Laufzeitkontext, der von einem vorherigen Knoten oder einer externen Anwendung festgelegt wurde:

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Dialogmodulknoten oder Antwortbedingung:

$toppings_array.containsIgnoreCase('HAM')

Ergebnis: true, da das Array das Element ham enthält und die Groß-/Kleinschreibung ignoriert wird.

JSONArray.containsIntent(String intent_name, Double min_score, [Integer top_n])

Diese Methode gibt true zurück, wenn das JSON-Array intents die angegebene Absicht enthält und der Konfidenzwert dieser Absicht größer-gleich dem angegebenen Mindestwert ist. Sie können optional eine Zahl angeben, um festzulegen, dass die Absicht innerhalb dieser Anzahl der ranghöchsten Elemente im Array enthalten sein muss. Der Parameter top_n wird ignoriert, wenn Sie eine negative Zahl angeben.

Diese Methode gibt false zurück, wenn die angegebene Absicht nicht im Array enthalten ist, keinen Konfidenzwert größer-gleich dem Mindestkonfidenzwert aufweist oder der Array-Index der Absicht niedriger als die angegebene Indexposition ist.

Sobald eine Benutzereingabe übergeben wird, generiert der Service automatisch ein Array intents mit einer Liste der in der Eingabe erkannten Absichten. In dem Array werden alle vom Service erkannten Absichten in absteigender Reihenfolge ihrer Konfidenzwerte aufgelistet.

Sie können diese Methode in einer Knotenbedingung verwenden, um das Vorhandensein einer Absicht zu prüfen und um einen Grenzwert für die Konfidenzbewertung festzulegen, der eingehalten werden muss, damit der Knoten verarbeitet und die zugehörige Antwort zurückgegeben wird.

Sie können beispielsweise den folgenden Ausdruck in einer Knotenbedingung verwenden, damit der Dialogmodulknoten nur ausgelöst wird, wenn die folgenden Bedingungen zutreffen:

• Die Absicht #General_Ending ist vorhanden.
• Der Konfidenzwert der Absicht #General_Ending beträgt über 80%.
• Die Absicht #General_Ending ist eine der beiden am häufigsten vorkommenden Absichten im Array 'intents'.

intents.containsIntent("General_Ending", 0.8, 2)

JSONArray.filter(temp, "temp.property operator comparison_value")

Filtert ein Array, indem der Wert jedes Array-Elements mit einem von Ihnen angegebenen Wert verglichen wird. Diese Methode entspricht weitgehend einer Erfassungsprognose. Eine Erfassungsprognose gibt ein gefiltertes Array zurück, basierend auf dem Namen aus einem Name/Wert-Paar in einem Array-Element. Die Filtermethode gibt ein gefiltertes Array zurück, basierend auf dem Wert aus einem Name/Wert-Paar in einem Array-Element.

Der Filterausdruck besteht aus den folgenden Werten:

• temp: Der Name einer temporären Variablen, die beim Auswerten der einzelnen Array-Elemente verwendet wird. Beispiel: city.

• property: Die Elementeigenschaft, mit der comparison_value verglichen werden soll. Geben Sie die Eigenschaft als Eigenschaft der temporären Variablen an, die Sie im ersten Parameter angegeben haben. Verwenden Sie die Syntax temp.property. Beispiel: Wenn latitude ein gültiger Elementname für ein Name/Wert-Paar in dem Array ist, geben Sie city.latitude als Eigenschaft an.

• operator: Der Operator, der zum Vergleichen des Eigenschaftswerts mit dem Vergleichswert (comparison_value) verwendet werden soll.

  Die folgenden Operatoren werden unterstützt:

  Unterstützte Filteroperatoren

  Operator	Beschreibung
  ==	Entspricht
  >	Ist größer als
  <	Ist kleiner als
  >=	Größer-gleich
  <=	Kleiner-gleich
  !=	Ist nicht gleich

• comparison_value: Der Wert, mit dem der Eigenschaftswert jedes Array-Elements verglichen werden soll. Wenn Sie einen Wert angeben möchten, der je nach Benutzereingabe variieren kann, verwenden Sie eine Kontextvariable oder Entität als Wert. Wenn Sie einen Wert angeben, der variieren kann, fügen Sie Logik hinzu, um sicherzustellen, dass der Wert comparison_value zum Auswertungszeitpunkt gültig ist oder ein Fehler auftritt.

[
   {
      "name":"Tokyo",
      "population":9273000
   },
   {
      "name":"Rome",
      "population":2868104
   },
   {
      "name":"Beijing",
      "population":20693000
   },
   {
      "name":"Paris",
      "population":2241346
   }
]

$cities.filter("city", "city.population > 5000000")

[
   {
      "name":"Tokyo",
      "population":9273000
   },
   {
      "name":"Beijing",
      "population":20693000
   }
]

The cities with more than 5 million people include <?  T(String).join(", ",($cities.filter("city", "city.population > 5000000")).![name]) ?>.

$cities.filter("city", "city.population > $population_min")

[
   {
      "name":"Tokyo",
      "population":9273000
   },
   {
      "name":"Beijing",
      "population":20693000
   }
]

The cities with more than $population_min people include <?  T(String).join(", ",($cities.filter("city", "city.population > $population_min")).![name]) ?>.

$cities.filter("y", "y.name == @city")

[
   {
      "name":"Tokyo",
      "population":9273000
   }
]

The population of @city is: <? ($cities.filter("y", "y.name == @city").![population]).get(0) ?>.

JSONArray.get(Integer)

Diese Methode gibt den Eingabeindex aus dem JSON-Array zurück.

Für diesen Dialog-Laufzeitkontext, der von einem vorherigen Knoten oder einer externen Anwendung festgelegt wurde:

{
  "context": {
    "name": "John",
    "nested": {
      "array": [ "one", "two" ]
    }
  }
}

Dialogmodulknoten oder Antwortbedingung:

$nested.array.get(0).getAsString().contains('one')

Ergebnis: True, da das verschachtelte Array one als Wert enthält.

Antwort:

"output": {
  "generic" : [
    {
      "values": [
        {
        "text" : "The first item in the array is <?$nested.array.get(0)?>"
        }
      ],
      "response_type": "text",
      "selection_policy": "sequential"
    }
  ]
  }

JSONArray.getRandomItem()

Diese Methode gibt ein beliebiges Element aus dem eingegebenen JSON-Array zurück.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Ausgabe des Dialogmodulknotens:

{
  "output": {
  "generic" : [
    {
      "values": [
        {
    "text": "<? $toppings_array.getRandomItem() ?> is a great choice!"
        }
      ],
      "response_type": "text",
      "selection_policy": "sequential"
    }
  ]
  }
}

Ergebnis: "ham is a great choice!" oder "onion is a great choice!" oder "olives is a great choice!"

Der resultierende Ausgabetext wird zufällig ausgewählt.

JSONArray.indexOf(value)

Diese Methode gibt die Indexnummer des Elements in dem Array zurück, das mit dem Wert übereinstimmt, den Sie als Parameter angeben, oder -1, wenn der Wert im Array nicht gefunden wird. Der Wert kann ein String ( "School" ), Integer ( 8 ) oder Double ( 9.1 ) sein. Der Wert muss exakt übereinstimmen und die Groß-/Kleinschreibung muss beachtet werden.

Arrays sind beispielsweise in den folgenden Kontextvariablen enthalten:

{
  "context": {
    "array1": ["Mary","Lamb","School"],
    "array2": [8,9,10],
    "array3": [8.1,9.1,10.1]
  }
}

Mit dem folgenden Ausdruck kann der Array-Index ermittelt werden, in dem der Wert angegeben ist:

<? $array1.indexOf("Mary") ?> returns `0`
<? $array2.indexOf(9) ?> returns `1`
<? $array3.indexOf(10.1) ?> returns `2`

Diese Methode kann beispielsweise hilfreich sein, um den Index eines Elements in einem Array 'intents' abzurufen. Die Methode indexOf kann auf das Array mit Absichten angewendet werden, das bei jeder Auswertung von Benutzereingaben generiert wird, um die Array-Indexnummer einer bestimmten Absicht zu ermitteln.

intents.indexOf("General_Greetings")

Wenn Sie den Konfidenzwert für eine bestimmte Absicht kennen, können Sie den vorherigen Ausdruck als Wert index an einen Ausdruck mit der Syntax intents[index].confidence übergeben. Beispiel:

intents[intents.indexOf("General_Greetings")].confidence

JSONArray.join(String delimiter)

Diese Methode verknüpft alle Werte in diesem Array zu einer Zeichenfolge. Werte werden in Zeichenketten umgewandelt und durch das Eingabetrennzeichen getrennt.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Ausgabe des Dialogmodulknotens:

{
  "output": {
  "generic" : [
    {
      "values": [
        {
    "text": "This is the array: <? $toppings_array.join(';') ?>"
        }
      ],
      "response_type": "text",
      "selection_policy": "sequential"
    }
  ]
  }
}

Ergebnis:

This is the array: onion;olives;ham;

Wenn in einer Benutzereingabe mehrere Beläge erwähnt werden und Sie eine Entität mit dem Namen @toppings definiert haben, die Belag-Erwähnungen erkennen kann, können Sie in der Antwort den folgenden Ausdruck verwenden, um die erwähnten Beläge aufzulisten:

So, you'd like <? @toppings.values.join(',') ?>.

Wenn Sie eine Variable definieren, die mehrere Werte in einem JSON-Array speichert, können Sie eine Untergruppe von Werten aus dem Array zurückgeben. Verwenden Sie die Methode join(), um sie ordnungsgemäß zu formatieren.

"flights_found": [
  {
    "time": "10:00",
    "flight_code": "OK123"
  },
  {
    "time": "12:30",
    "flight_code": "LH421"
  },
  {
    "time": "16:15",
    "flight_code": "TS4156"
  }
]

<? $flights_found.![flight_code] ?>

The flights that fit your criteria are:
  <? T(String).join(",", $flights_found.![flight_code]) ?>.

JSONArray.joinToArray(template, retainDataType)

Diese Methode extrahiert Informationen aus jedem Element im Array und erstellt ein neues Array, das gemäß der von Ihnen angegebenen Vorlage formatiert wird. Die Vorlage kann eine Zeichenfolge, ein JSON-Objekt oder ein Array sein. Die Methode gibt je nach Schablonentyp ein Array von Zeichenfolgen, ein Array von Objekten oder ein Array von Arrays zurück.

Diese Methode ist nützlich zum Formatieren von Informationen als Zeichenfolge, die Sie als Teil der Ausgabe eines Dialogmodulknotens zurückgeben können, oder zum Umwandeln von Daten in eine andere Struktur, sodass Sie sie mit einer externen API verwenden können.

In der Vorlage können Sie Werte aus dem Quellenarray mit der folgenden Syntax referenzieren, wobei {property} für den Namen der Eigenschaft im Quellenarray steht.

%e.{property}%

Angenommen, Ihr Assistent speichert ein Array, das Flugdetails in einer Kontextvariablen enthält. Die gespeicherten Daten könnten wie folgt aussehen:

"flights": [
      {
        "flight": "AZ1040",
        "origin": "JFK",
        "carrier": "Alitalia",
        "duration": 485,
        "destination": "FCO",
        "arrival_date": "2019-02-03",
        "arrival_time": "07:00",
        "departure_date": "2019-02-02",
        "departure_time": "16:45"
      },
      {
        "flight": "DL1710",
        "origin": "JFK",
        "carrier": "Delta",
        "duration": 379,
        "destination": "LAX",
        "arrival_date": "2019-02-02",
        "arrival_time": "10:19",
        "departure_date": "2019-02-02",
        "departure_time": "07:00"
      },
      {
        "flight": "VS4379",
        "origin": "BOS",
        "carrier": "Virgin Atlantic",
        "duration": 385,
        "destination": "LHR",
        "arrival_date": "2019-02-03",
        "arrival_time": "09:05",
        "departure_date": "2019-02-02",
        "departure_time": "21:40"
      }
    ]

Um ein Array von Zeichenfolgen zu erstellen, die diese Flüge in einem benutzerlesbaren Format beschreiben, können Sie den folgenden Ausdruck verwenden:

${Flight_data}.joinToArray("Flight %e.flight% to %e.destination%", true)

Dieser Ausdruck würde das folgende Array von Zeichenfolgen zurückgeben: ["Flight AZ1040 to FCO","Flight DL1710 to LAX","Flight VS4379 to LHR"].

Der optionale Parameter retainDataType gibt an, ob die Methode den Datentyp aller Eingabewerte im zurückgegebenen Array beibehalten soll. Wenn retainDataType auf false gesetzt oder weggelassen wird, werden Zeichenfolgen im Eingabe-Array möglicherweise in Zahlen im zurückgegebenen Array konvertiert. Wenn die ausgewählten Werte aus dem Eingabearray beispielsweise "1", "2" und "3" sind, könnte das zurückgegebene Array [ 1, 2, 3 ] sein. Geben Sie für diesen Parameter true an, um unerwartete Typkonvertierungen zu verhindern.

<br/>Flight number: %e.flight% <br/> Airline: %e.carrier% <br/> Departure date: %e.departure_date% <br/> Departure time: %e.departure_time% <br/> Arrival time: %e.arrival_time% <br/>

${Flight_data}.joinToArray(${Template})

Flight number: AZ1040
Airline: Alitalia
Departure date: 2019-02-02
Departure time: 16:45
Arrival time: 07:00

Flight number: DL1710
Airline: Delta
Departure date: 2019-02-02
Departure time: 07:00
Arrival time: 10:19

Flight number: VS4379
Airline: Virgin Atlantic
Departure date: 2019-02-02
Departure time: 21:40
Arrival time: 09:05

{
  "departure": "Flight %e.flight% departs on %e.departure_date% at %e.departure_time%.",
  "arrival": "Flight %e.flight% arrives on %e.arrival_date% at %e.arrival_time%."
}

JSONArray.remove(Integer)

Diese Methode entfernt das Element an der Indexposition aus dem JSON-Array und gibt das aktualisierte JSON-Array zurück.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "toppings_array": ["onion", "olives"]
  }
}

Nehmen Sie die folgende Aktualisierung vor:

{
  "context": {
    "toppings_array": "<? $toppings_array.remove(0) ?>"
  }
}

Ergebnis:

{
  "context": {
    "toppings_array": ["olives"]
  }
}

JSONArray.removeValue(object)

Diese Methode entfernt das erste Vorkommen des Wertes aus dem JSON-Array und gibt das aktualisierte JSON-Array zurück.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "toppings_array": ["onion", "olives"]
  }
}

Nehmen Sie die folgende Aktualisierung vor:

{
  "context": {
    "toppings_array": "<? $toppings_array.removeValue('onion') ?>"
  }
}

Ergebnis:

{
  "context": {
    "toppings_array": ["olives"]
  }
}

JSONArray.set(Integer index, Object value)

Diese Methode legt den Eingabeindex des JSON-Arrays für den Eingabewert fest und gibt das geänderte JSON-Array zurück.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Ausgabe des Dialogmodulknotens:

{
  "context": {
    "toppings_array": "<? $toppings_array.set(1,'ketchup')?>"
  }
}

Ergebnis:

{
  "context": {
    "toppings_array": ["onion", "ketchup", "ham"]
  }
}

JSONArray.size()

Diese Methode gibt die Größe des JSON-Arrays als ganze Zahl zurück.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "toppings_array": ["onion", "olives"]
  }
}

Nehmen Sie die folgende Aktualisierung vor:

{
  "context": {
    "toppings_array_size": "<? $toppings_array.size() ?>"
  }
}

Ergebnis:

{
  "context": {
    "toppings_array_size": 2
  }
}

JSONArray split(String regexp)

Diese Methode unterteilt die Eingabezeichenfolge mithilfe des eingegebenen regulären Ausdrucks. Das Ergebnis ist ein JSON-Array mit Zeichenfolgen.

Ausgangspunkt ist die folgende Eingabe:

"bananas;apples;pears"

Verwenden Sie die folgende Syntax:

{
  "context": {
    "array": "<?input.text.split(";")?>
  }
}

Ergebnis ist die folgende Ausgabe:

{
  "context": {
    "array": [ "bananas", "apples", "pears" ]
  }
}

Unterstützung für com.google.gson.JsonArray

Zusätzlich zu den integrierten Methoden können Sie Standardmethoden der Klasse com.google.gson.JsonArray verwenden.

{
  "context":{
    "answer": "<? output.answer?:new JsonArray().append('temp_value') ?>"
  }

.after(String date or time)

Ermittelt, ob der Wert für Datum/Uhrzeit nach dem angegebenen Argument für Datum/Uhrzeit liegt.

.before(String date or time)

Ermittelt, ob der Wert für Datum/Uhrzeit vor dem angegebenen Argument für Datum/Uhrzeit liegt.

Beispiel:

• @sys-time.before('12:00:00')

• @sys-date.before('2016-11-21')

• Wenn Sie verschiedene Elemente vergleichen, z. B. time vs. date, date vs. time und time vs. date and time, gibt die Methode "falsch" zurück und im Antwort-JSON-Protokoll wird eine Ausnahme ausgegeben: output.log_messages.

  Beispiel: @sys-date.before(@sys-time).

• Wenn Sie date and time vs. time vergleichen, ignoriert die Methode das Datum und vergleicht nur die Zeiten.

now(String time zone)

Sie gibt eine Zeichenfolge mit den aktuellen Werten für Datum und Uhrzeit im Format yyyy-MM-dd HH:mm:ss zurück. Geben Sie optional einen timezone-Wert an, um das aktuelle Datum und die aktuelle Uhrzeit für eine bestimmte Zeitzone mit einer zurückgegebenen Zeichenfolge im Format yyyy-MM-dd HH:mm:ss 'GMT'XXX abzurufen.

• Dies ist eine statische Funktion.
• Die anderen Methoden für Datum/Uhrzeit können für Datums-/Uhrzeitwerte aufgerufen werden, die von dieser Funktion zurückgegeben werden, und als deren Argument übergeben werden.
• Die Benutzeroberfläche erstellt automatisch eine $timezone-Kontextvariable für Sie, sodass die richtige Zeit zurückgegeben wird, wenn Sie im Bereich "Ausprobieren" einen Test durchführen. Wenn Sie keine Zeitzone übergeben, wird die automatisch von der Benutzerschnittstelle festgelegte Zeitzone verwendet. Außerhalb der Benutzerschnittstelle wird die Zeitzone GMT verwendet. Informationen zur Syntax, die zur Angabe der Zeitzone verwendet werden muss, finden Sie unter "Von Systemeinheiten unterstützte Zeitzonen ".

Beispiel für die Verwendung von now(), um zuerst zu prüfen, ob es vormittags ist, bevor der Assistent mit einer morgendlichen Begrüßung antwortet.

{
  "conditions": "now().before('12:00:00')",
  "output": {
      "generic": [
        {
        "values": [
          {
          "text": "Good morning!"
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
        }
      ]
  }
}

Beispiel für die Verwendung von now() mit einer Zeitzone zur Rückgabe der aktuellen Uhrzeit (in England):

{
  "output": {
      "generic": [
        {
        "values": [
          {
          "text": "The current date and time is: <? now('Europe/London') ?>"
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
        }
      ]
  }
}

Sie können den fest codierten Zeitzonenwert durch eine Kontextvariable ersetzen, um die Zeit dynamisch basierend auf einer Zeitzone zu ändern, die an den Ausdruck übergeben wird. Beispiel: <? now('$myzone') ?>. Die Kontextvariable $myzone kann in einem Dialog auf 'Australia/Sydney' gesetzt werden und in einem anderen Dialog auf 'Mexico/BajaNorte'.

.reformatDateTime(String format)

Formatiert Datums- und Zeitangaben in das gewünschte Format für die Benutzerausgabe.

Gibt eine formatierte Zeichenfolge gemäß dem angegeben Format zurück:

• MM/dd/yyyy für 12/31/2016
• h a für 10pm

Zur Rückgabe des Wochentags:

• EEEE für Dienstag
• E für Tue
• u für Tagesindex (1 = Montag, ..., 7 = Sonntag)

Die folgende Kontextvariablendefinition erstellt beispielsweise eine Variable '$time', die den Wert 17:30:00 als 5:30 PM speichert.

{
  "context": {
    "time": "<? @sys-time.reformatDateTime('h:mm a') ?>"
  }
}

Das Format entspricht den Java SimpleDateFormat.

Hinweis: Wenn Sie versuchen, nur die Uhrzeit zu formatieren, wird das Datum als 1970-01-01 behandelt.

.sameMoment(String date/time)

• Ermittelt, ob der Wert für Datum/Uhrzeit mit dem angegebenen Argument für Datum/Uhrzeit identisch ist.

.sameOrAfter(String date/time)

• Ermittelt, ob der Wert für Datum/Uhrzeit nach dem angegebenen Argument für Datum/Uhrzeit liegt oder damit identisch ist.
• Ist analog zu .after().

.sameOrBefore(String date/time)

• Ermittelt, ob der Wert für Datum/Uhrzeit vor dem angegebenen Argument für Datum/Uhrzeit liegt oder damit identisch ist.

today()

Gibt eine Zeichenfolge mit dem aktuellen Datum im Format yyyy-MM-dd zurück.

• Dies ist eine statische Funktion.
• Die anderen Methoden für Datumsangaben können für Datumswerte aufgerufen werden, die von dieser Funktion zurückgegeben werden, und als deren Argument übergeben werden.
• Falls die Kontextvariable $timezone festgelegt ist, gibt diese Funktion Datumsangaben in der Zeitzone des Clients zurück. Andernfalls wird die Zeitzone GMT verwendet.

Beispiel für einen Dialogmodulknoten, bei dem today() im Feld 'output' verwendet wird:

{
  "conditions": "#what_day_is_it",
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Today's date is <? today() ?>."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

Ergebnis: Today's date is 2018-03-09.

Mit Zeitspannen arbeiten

Zum Anzeigen einer Antwort, wenn das heutige Datum innerhalb eines bestimmten Zeitrahmens liegt, können Sie eine Kombination aus zeitbasierten Methoden verwenden. Wenn Sie beispielsweise jedes Jahr in der Weihnachtszeit ein Sonderangebot anbieten, können Sie prüfen, ob das heutige Datum im Zeitraum zwischen dem 25. November und dem 24. Dezember des Jahres liegt. Definieren Sie zunächst die betreffenden Datumsangaben als Kontextvariablen.

In den folgenden Ausdrücken für Start- und Enddatum wird das Datum durch Verkettung des abgeleiteten aktuellen Jahreswerts mit fest codierten Monats- und Tageswerten konstruiert.

"context": {
   "end_date": "<? now().reformatDateTime('Y') + '-12-24' ?>",
   "start_date": "<? now().reformatDateTime('Y') + '-11-25' ?>"
 }

In der Antwortbedingung können Sie angeben, dass die Antwort nur angezeigt werden soll, wenn das aktuelle Datum im Zeitraum zwischen dem Start- und dem Enddatum liegt, den Sie durch Kontextvariablen definiert haben.

now().after($start_date) && now().before($end_date)

Unterstützung für java.util.Date

Zusätzlich zu den integrierten Methoden können Sie Standardmethoden der Klasse java.util.Date verwenden.

Um das Datum des Tages abzurufen, der genau eine Woche auf den heutigen Tag folgt, können Sie die folgende Syntax verwenden:

{
  "context": {
    "week_from_today": "<? new Date(new Date().getTime() +
      (7 * (24*60*60*1000L))) ?>"
  }
}

Dieser Ausdruck ermittelt zunächst das aktuelle Datum in Millisekunden seit dem 1. Januar 1970, 00:00:00 Uhr koordinierter Weltzeit. Außerdem wird berechnet, wie viele Millisekunden 7 Tagen entsprechen. (Die Formel (24*60*60*1000L) berechnet die Millisekunden für einen Tag.) Anschließend werden 7 Tage zu dem aktuellen Datum addiert. Das Ergebnis ist das vollständige Datum des Tages, der genau eine Woche auf den heutigen Tag folgt. Beispiel: Fri Jan 26 16:30:37 UTC 2018. Die Zeit wird in der Zeitzone UTC (Coordinated Universal Time) angegeben. Der Wert 7 kann jederzeit in eine Variable (z. B. $number_of_days) geändert werden, die Sie übergeben können. Stellen Sie sicher, dass der Wert festgelegt wird, bevor dieser Ausdruck ausgewertet wird.

Wenn Sie das Datum mit einem anderen Datum vergleichen möchten, das vom Dienst generiert wird, müssen Sie das Datum neu formatieren. Systementitäten (z. B. @sys-date) und andere integrierte Methoden (z. B. now()) wandeln Datumsangaben in das Format yyyy-MM-dd um.

{
  "context": {
    "week_from_today": "<? new Date(new Date().getTime() +
      (7 * (24*60*60*1000L))).format('yyyy-MM-dd') ?>"
  }
}

Nach der Umformatierung des Datums lautet das Ergebnis 2018-01-26. Jetzt können Sie einen Ausdruck wie @sys-date.after($week_from_today) in einer Antwortbedingung verwenden, um ein in der Benutzereingabe angegebenes Datum mit dem in der Kontextvariablen gespeicherten Datum zu vergleichen.

Der folgende Ausdruck berechnet die Uhrzeit, die 3 Stunden nach der aktuellen Uhrzeit folgt.

{
  "context": {
    "future_time": "<? new Date(new Date().getTime() + (3 * (60*60*1000L)) -
      (5 * (60*60*1000L))).format('h:mm a') ?>"
  }
}

Der Wert (60*60*1000L) entspricht einer Stunde, ausgedrückt in Millisekunden. Dieser Ausdruck addiert 3 Stunden zu der aktuellen Uhrzeit. Anschließend wird die Zeit von der koordinierten Weltzeitzone zur EST-Zeitzone neu berechnet, indem 5 Stunden davon abgezogen werden. Außerdem werden die Datumswerte so umformatiert, dass sie Stunden und Minuten sowie AM oder PM enthalten.

toDouble()

Konvertiert das Objekt oder Feld in den Zahlentyp 'Double'. Sie können diese Methode für jedes beliebige Objekt oder Feld aufrufen. Falls die Konvertierung fehlschlägt, wird null zurückgegeben.

toInt()

Konvertiert das Objekt oder Feld in den Zahlentyp 'Integer'. Sie können diese Methode für jedes beliebige Objekt oder Feld aufrufen. Falls die Konvertierung fehlschlägt, wird null zurückgegeben.

toLong()

Konvertiert das Objekt oder Feld in den Zahlentyp 'Long'. Sie können diese Methode für jedes beliebige Objekt oder Feld aufrufen. Falls die Konvertierung fehlschlägt, wird null zurückgegeben.

Wenn Sie einen Zahlentyp 'Long' in einem SpEL-Ausdruck angeben, müssen Sie den Buchstaben L an die Zahl anfügen, um diesen Zahlentyp zu identifizieren. Beispiel: 5000000000L. Diese Syntax ist für alle Zahlen erforderlich, die nicht in das Format einer 32-Bit-Ganzzahl passen. Zum Beispiel werden Zahlen, die größer als 2^31 (2.147.483.648) oder kleiner als -2 (-2 ) sind, als Long-Number-Typen betrachtet. Zahlen des Typs 'Long' liegen zwischen dem Minimalwert -2^63 und dem Maximalwert 2^63-1 (oder 9.223.372.036.854.775.807).

Wenn Sie feststellen möchten, ob eine Zahl zu lang ist, um erkannt zu werden, überprüfen Sie, ob die Zahl mehr als 18 Ganzzahlen enthält, indem Sie einen Ausdruck wie diesen verwenden:

<? @sys-number.toString().length() > 18 ?>

Wenn Sie mit Zahlen arbeiten müssen, die länger als 18 Ganzzahlen sind, sollten Sie eine Musterentität (mit einem regulären Ausdruck wie \d{20} ) in Betracht ziehen, um mit ihnen zu arbeiten, anstatt @sys-number zu verwenden.

Standardrechenoperationen

Mit SpEL-Ausdrücken können Sie mathematische Standardgleichungen definieren, bei denen die Operatoren mit den folgenden Symbolen dargestellt werden:

Beispielsweise können Sie in einer Dialogknotenantwort eine Kontextvariable hinzufügen, die eine in der Benutzereingabe angegebene Nummer ( @sys-number ) erfasst und als $your_number speichert. Anschließend könnten Sie den folgenden Text als Antwort hinzufügen:

I'm doing math. Given the value you specified ($your_number), when I add 5, I get: <? $your_number + 5 ?>.
When I subtract 5, I get: <? $your_number - 5 ?>.
When I multiply it by 5, I get: <? $your_number * 5 ?>.
When I divide it by 5, I get: <? $your_number/5 ?>.

Gibt der Benutzer hier den Wert 10 an, sieht die resultierende Textantwort wie folgt aus:

I'm doing math. Given the value you specified (10), when I add 5, I get: 15.
When I subtract 5, I get: 5.
When I multiply it by 5, I get: 50.
When I divide it by 5, I get: 2.

Zahlenunterstützung in Java

java.lang.Math()

Führt grundlegende Zahlenoperationen aus.

Sie können die Klassenmethoden verwenden:

max()

{
  "context": {
    "bigger_number": "<? T(Math).max($number1,$number2) ?>"
  },
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "The bigger number is $bigger_number."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

min()

{
  "context": {
    "smaller_number": "<? T(Math).min($number1,$number2) ?>"
  },
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "The smaller number is $smaller_number."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

pow()

{
  "context": {
    "power_of_two": "<? T(Math).pow($base.toDouble(),2.toDouble()) ?>"
  },
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Your number $base to the second power is $power_of_two."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

Weitere Informationen finden Sie in der java.lang.Math-Referenzdokumentation.

java.util.Random()

Gibt eine Zufallszahl zurück. Sie können eine der folgenden Syntaxoptionen verwenden:

• Um einen booleschen Zufallswert (true oder false) auszugeben, verwenden Sie <?new Random().nextBoolean()?>.
• Um eine zufällige Zahl zwischen 0 (eingeschlossen) und 1 (ausgeschlossen) zurückzugeben, verwenden Sie <?new Random().nextDouble()?>.
• Um eine Zufallszahl zwischen 0 (eingeschlossen) und einer von Ihnen angegebenen Zahl auszugeben, verwenden Sie <?new Random().nextInt(n)?>, wobei n der Anfang des gewünschten Zahlenbereichs +1 ist. Wenn Sie beispielsweise eine Zufallszahl zwischen 0 und 10 ausgeben möchten, geben Sie <?new Random().nextInt(11)?> an.
• Verwenden Sie <?new Random().nextInt()?>, um eine Zufallszahl aus dem Wertebereich für ganze Zahlen (-2147483648 bis 2147483648) auszugeben.

Sie könnten beispielsweise einen Dialogmodulknoten erstellen, der durch die Absicht '#random_number' ausgelöst wird. Die erste Antwortbedingung könnte wie folgt aussehen:

Condition = @sys-number
{
  "context": {
    "answer": "<? new Random().nextInt(@sys-number.numeric_value + 1) ?>"
  },
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Here's a random number between 0 and @sys-number.literal: $answer."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

Weitere Informationen zu anderen Methoden finden Sie in der Referenzdokumentation java.util.Random

Sie können auch Standardmethoden der folgenden Klassen verwenden:

• java.lang.Byte
• java.lang.Integer
• java.lang.Long
• java.lang.Double
• java.lang.Short
• java.lang.Float

JSONObject.clear()

Diese Methode löscht alle Werte in dem JSON-Objekt und gibt null zurück.

Angenommen, Sie möchten die aktuellen Werte in der Kontextvariablen '$user' löschen.

{
  "context": {
    "user": {
      "first_name":"John",
      "last_name":"Snow"
    }
  }
}

Verwenden Sie den folgenden Ausdruck in der Ausgabe, um ein Feld zu definieren, das die Werte in dem Objekt löscht.

{
  "output": {
    "object_eraser": "<? $user.clear() ?>"
  }
}

Wenn Sie auf die Kontextvariable $user verweisen, wird nur {} zurückgegeben.

Sie können die Methode clear() auf die JSON-Objekte context oder output im Hauptteil des API-Aufrufs /message anwenden.

{
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Response for this node."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ],
    "context_eraser": "<? context.clear() ?>"
  }
}

{
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Have a great day!"
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ],
    "output_eraser": "<? output.clear() ?>"
  }
}

JSONObject.has(String)

Diese Methode gibt 'true' zurück, falls das komplexe JSON-Objekt eine Eigenschaft mit dem eingegebenen Namen besitzt.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "user": {
      "first_name": "John",
      "last_name": "Snow"
    }
  }
}

Ausgabe des Dialogmodulknotens:

{
  "conditions": "$user.has('first_name')"
}

Ergebnis: Diese Bedingung wird mit 'true' ausgewertet, weil das Objekt die Eigenschaft first_name enthält.

JSONObject.remove(String)

Diese Methode entfernt eine Eigenschaft mit dem angegebenen Namen aus dem eingegebenen JSONObject. Das von dieser Methode zurückgegebene JSONElement ist das JSONElement, das entfernt wird.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "user": {
      "first_name": "John",
      "last_name": "Snow"
    }
  }
}

Ausgabe des Dialogmodulknotens:

{
  "context": {
    "attribute_removed": "<? $user.remove('first_name') ?>"
  }
}

Ergebnis:

{
  "context": {
    "user": {
      "last_name": "Snow"
    },
    "attribute_removed": {
      "first_name": "John"
    }
  }
}

Unterstützung für com.google.gson.JsonObject

Neben den integrierten Methoden werden auch einige der Standardverfahren der Klasse com.google.gson.JsonObject unterstützt.

String.append(Object)

Diese Methode hängt ein Eingabeobjekt als Zeichenfolge an die Zeichenfolge an und gibt eine geänderte Zeichenfolge zurück.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "my_text": "This is a text."
  }
}

Verwenden Sie die folgende Syntax:

{
  "context": {
    "my_text": "<? $my_text.append(' More text.') ?>"
  }
}

Ergebnis ist die folgende Ausgabe:

{
  "context": {
    "my_text": "This is a text. More text."
  }
}

String.contains(String)

Diese Methode gibt 'true' zurück, wenn die Zeichenfolge die eingegebene Teilzeichenfolge enthält.

Eingabe: Yes, I'd like to go.

Verwenden Sie die folgende Syntax:

{
  "conditions": "input.text.contains('Yes')"
}

Ergebnis: Die Bedingung wird mit true ausgewertet.

String.endsWith(String)

Diese Methode gibt 'true' zurück, wenn die Zeichenfolge mit der eingegebenen Teilzeichenfolge endet.

Ausgangspunkt ist die folgende Eingabe:

"What is your name?".

Verwenden Sie die folgende Syntax:

{
  "conditions": "input.text.endsWith('?')"
}

Ergebnis: Die Bedingung wird mit true ausgewertet.

String.equals(String)

Diese Methode gibt true aus, wenn die angegebene Zeichenfolge genau der Eingabezeichenfolge entspricht.

Eingabe: "Ja"

Verwenden Sie die folgende Syntax:

{
  "conditions": "input.text.equals('Yes')"
}

Ergebnis: Die Bedingung wird mit true ausgewertet.

Wenn die Eingabe Yes. ist, ist das Ergebnis false, da der Benutzer einen Punkt eingeschlossen hat und der Ausdruck nur den exakten Text Yes ohne Interpunktion erwartet.

String.equalsIgnoreCase(String)

Diese Methode gibt true zurück, wenn die angegebene Zeichenfolge mit der Eingabezeichenfolge übereinstimmt, unabhängig davon, ob die Groß-/Kleinschreibung der Buchstaben übereinstimmt.

Eingabe: "ja"

Verwenden Sie die folgende Syntax:

{
  "conditions": "input.text.equalsIgnoreCase('Yes')"
}

Ergebnis: Die Bedingung wird mit true ausgewertet.

Wenn die Eingabe Yes. lautet, ist das Ergebnis false, da der Benutzer einen Punkt eingegeben hat und der Ausdruck nur den Text Yes in Groß- oder Kleinbuchstaben ohne Satzzeichen erwartet.

String.extract(String regexp, Integer groupIndex)

Diese Methode gibt eine Zeichenfolge aus der Eingabe zurück, die dem von Ihnen angegebenen Gruppenmuster des regulären Ausdrucks entspricht. Sie gibt eine leere Zeichenfolge zurück, falls keine Übereinstimmung gefunden wird.

Diese Methode dient zum Extrahieren von Übereinstimmungen für verschiedene Regex-Mustergruppen, aber nicht von Übereinstimmungen für ein einzelnes Regex-Muster. Informationen zur Suche verschiedener Übereinstimmungen finden Sie unter der Methode getMatch.

Im folgenden Beispiel speichert die Kontextvariable eine Zeichenfolge, die der Regex-Mustergruppe entspricht, die Sie angeben. In dem Ausdruck werden zwei Regex-Mustergruppen definiert, die jeweils in Klammern eingeschlossen sind. Eine inhärente dritte Gruppe besteht aus den beiden Gruppen. Dies ist die erste groupIndex ) Regex-Gruppe; sie entspricht einer Zeichenfolge, die die vollständige Zahlengruppe und Textgruppe enthält. Die zweite Regex-Gruppe (groupIndex 1) stimmt mit dem ersten Vorkommen einer Zahlengruppe überein. Die dritte Gruppe (groupIndex 2) stimmt mit dem ersten Vorkommen einer Textgruppe nach einer Zahlengruppe überein.

{
  "context": {
    "number_extract": "<? input.text.extract('([\\d]+)(\\b [A-Za-z]+)',n) ?>"
  }
}

Wenn Sie den regulären Ausdruck in JSON angeben, müssen Sie zwei umgekehrte Schrägstriche (\) angeben. Wenn Sie diesen Ausdruck in einer Knotenantwort angeben, benötigen Sie nur einen Backslash. Beispiel:

<? input.text.extract('([\d]+)(\b [A-Za-z]+)',n) ?>

Eingabe:

"Hello 123 this is 456".

Ergebnis:

• Wenn n=0, ist der Wert 123 this.
• Wenn n=1, ist der Wert 123.
• Wenn n=2, ist der Wert this.

String.find(String regexp)

Diese Methode gibt 'true' zurück, falls ein Segment der Zeichenfolge mit dem eingegebenen regulären Ausdruck übereinstimmt. Sie können diese Methode gegen ein JSONArray- oder JSONObject-Element aufrufen und sie konvertiert das Array oder Objekt in eine Zeichenkette, bevor sie den Vergleich durchführt.

Ausgangspunkt ist die folgende Eingabe:

"Hello 123456".

Verwenden Sie die folgende Syntax:

{
  "conditions": "input.text.find('^[^\d]*[\d]{6}[^\d]*$')"
}

Ergebnis: Die Bedingung wird mit 'true' ausgewertet, weil der numerische Teil des Eingabetextes mit dem regulären Ausdruck ^[^\d]*[\d]{6}[^\d]*$ übereinstimmt.

String.getMatch(String regexp, Integer matchIndex)

Diese Methode gibt eine Zeichenfolge aus der Eingabe zurück, die dem Vorkommen des von Ihnen angegebenen regulären Ausdrucksmusters entspricht. Diese Methode gibt eine leere Zeichenfolge zurück, wenn keine Übereinstimmung gefunden wird.

Wenn Übereinstimmungen gefunden werden, werden sie einem Element hinzugefügt, das als Übereinstimmungsarray aufgefasst werden kann. Wenn Sie die dritte Übereinstimmung zurückgeben wollen, geben Sie 2 als Wert für matchIndex an, weil die Zählung der Array-Elemente bei 0 beginnt. Wenn Sie zum Beispiel eine Textzeichenfolge mit drei Wörtern eingeben, die dem angegebenen Muster entsprechen, können Sie nur die erste, zweite oder dritte Übereinstimmung durch Angabe des zugehörigen Indexwerts zurückgeben.

Im folgenden Ausdruck wird nach einer Gruppe von Zahlen in der Eingabe gesucht. Der Ausdruck speichert die zweite Zeichenfolge, die dem Muster entspricht, in der Kontextvariablen $second_number, da der Indexwert 1 angegeben wird.

{
  "context": {
    "second_number": "<? input.text.getMatch('([\\d]+)',1) ?>"
  }
}

Wenn Sie den Ausdruck in JSON-Syntax angeben, müssen Sie zwei umgekehrte Schrägstriche (\) angeben. Wenn Sie den Ausdruck in einer Knotenantwort angeben, benötigen Sie nur einen Backslash.

Beispiel:

<? input.text.getMatch('([\d]+)',1) ?>

• Benutzereingabe:

  "hello 123 i said 456 and 8910".
  

• Ergebnis: 456

In diesem Beispiel sucht der Ausdruck nach dem dritten Textblock in der Eingabe.

<? input.text.getMatch('(\b [A-Za-z]+)',2) ?>

Für dieselbe Benutzereingabe gibt dieser Ausdruck das Ergebnis and zurück.

String.isEmpty()

Diese Methode gibt 'true' zurück, wenn die Zeichenfolge eine leere Zeichenfolge, jedoch nicht null ist.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "my_text_variable": ""
  }
}

Verwenden Sie die folgende Syntax:

{
  "conditions": "$my_text_variable.isEmpty()"
}

Ergebnis: Die Bedingung wird mit true ausgewertet.

String.length()

Diese Methode gibt die Zeichenlänge der Zeichenfolge zurück.

Ausgangspunkt ist die folgende Eingabe:

"Hello"

Verwenden Sie die folgende Syntax:

{
  "context": {
    "input_length": "<? input.text.length() ?>"
  }
}

Ergebnis ist die folgende Ausgabe:

{
  "context": {
    "input_length": 5
  }
}

String.matches(String regexp)

Diese Methode gibt 'true' zurück, falls die Zeichenfolge mit dem eingegebenen regulären Ausdruck übereinstimmt.

Ausgangspunkt ist die folgende Eingabe:

"Hello".

Verwenden Sie die folgende Syntax:

{
  "conditions": "input.text.matches('^Hello$')"
}

Ergebnis: Die Bedingung wird mit 'true' ausgewertet, weil der Eingabetext mit dem regulären Ausdruck \^Hello\$ übereinstimmt.

String.startsWith(String)

Diese Methode gibt 'true' zurück, wenn die Zeichenfolge mit der eingegebenen Teilzeichenfolge beginnt.

Ausgangspunkt ist die folgende Eingabe:

"What is your name?".

Verwenden Sie die folgende Syntax:

{
  "conditions": "input.text.startsWith('What')"
}

Ergebnis: Die Bedingung wird mit true ausgewertet.

String.substring(Integer beginIndex, Integer endIndex)

Diese Methode erhält eine Teilzeichenfolge mit dem Zeichen bei beginIndex und dem letzten zu indizierenden Zeichensatz vor endIndex. Das Zeichen bei 'endIndex' wird nicht einbezogen.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "my_text": "This is a text."
  }
}

Verwenden Sie die folgende Syntax:

{
  "context": {
    "my_text": "<? $my_text.substring(5, $my_text.length()) ?>"
  }
}

Ergebnis ist die folgende Ausgabe:

{
  "context": {
    "my_text": "is a text."
  }
}

String.toJson()

Diese Methode analysiert eine Zeichenfolge, die JSON-Daten enthält, und gibt wie im folgenden Beispiel ein JSON-Objekt oder -Array zurück:

${json_var}.toJson()

Wenn die Kontextvariable ${json_var} die folgende Zeichenfolge enthält:

"{ \"firstname\": \"John\", \"lastname\": \"Doe\" }"

Die Methode toJson() gibt das folgende Objekt zurück:

{
  "firstname": "John",
  "lastname": "Doe"
}

String.toLowerCase()

Diese Methode gibt die ursprüngliche Zeichenkette zurück, die in Kleinbuchstaben umgewandelt wurde.

Ausgangspunkt ist die folgende Eingabe:

"This is A DOG!"

Verwenden Sie die folgende Syntax:

{
  "context": {
    "input_lower_case": "<? input.text.toLowerCase() ?>"
  }
}

Ergebnis ist die folgende Ausgabe:

{
  "context": {
    "input_lower_case": "this is a dog!"
  }
}

String.toUpperCase()

Diese Methode gibt die ursprüngliche Zeichenkette zurück, die in Großbuchstaben umgewandelt wurde.

Ausgangspunkt ist die folgende Eingabe:

"hi there".

Verwenden Sie die folgende Syntax:

{
  "context": {
    "input_upper_case": "<? input.text.toUpperCase() ?>"
  }
}

Ergebnis ist die folgende Ausgabe:

{
  "context": {
    "input_upper_case": "HI THERE"
  }
}

String.trim()

Diese Methode schneidet alle Leerzeichen am Beginn und am Ende der Zeichenfolge ab und gibt die geänderte Zeichenfolge zurück.

Ausgangspunkt ist der folgende Laufzeitkontext des Dialogmoduls:

{
  "context": {
    "my_text": "   something is here    "
  }
}

Verwenden Sie die folgende Syntax:

{
  "context": {
    "my_text": "<? $my_text.trim() ?>"
  }
}

Ergebnis ist die folgende Ausgabe:

{
  "context": {
    "my_text": "something is here"
  }
}

Unterstützung für java.lang.String

Zusätzlich zu den integrierten Methoden können Sie Standardmethoden der Klasse java.lang.String verwenden.

{
  "formatted String": "<? T(java.lang.String).format('%d + %d equals %d', 1, 1, 2) ?>"
}

{
  <? T(String).format('%.2f',<number to format>) ?>
}