JSONArray.addAll(JSONArray)

Questo metodo aggiunge un array ad un altro.

Per questo contesto di runtime di dialogo:

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

Effettua questo aggiornamento:

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

Risultato: il metodo restituisce null. Tuttavia, il primo array viene aggiornato per includervi i valori del secondo array.

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

JSONArray.append(object)

Questo metodo aggiunge un nuovo valore al JSONArray e restituisce il JSONArray modificato.

Per questo contesto di runtime di dialogo:

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

Effettua questo aggiornamento:

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

Risultato:

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

JSONArray.clear()

Questo metodo cancella tutti i valori dall'array e restituisce null.

Utilizza la seguente espressione nell'output per definire un campo che cancella i valori di un array che hai salvato in una variabile di contesto ($toppings_array).

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

Quindi, se si fa riferimento alla variabile di contesto $toppings_array, restituisce solo ' [] '.

JSONArray.contains(Object value)

Questo metodo restituisce true se il JSONArray di input contiene il valore di input.

Per questa finestra di dialogo il contesto di runtime è impostato da un nodo precedente o da un'applicazione esterna:

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

Nodo di dialogo o condizione di risposta:

$toppings_array.contains('ham')

Risultato: true perché l'array contiene l'elemento ham.

JSONArray.containsIgnoreCase(Object valore)

Questo metodo restituisce true se il JSONArray di input contiene il valore di input, indipendentemente dal fatto che il valore sia specificato in lettere maiuscole o minuscole.

Per questa finestra di dialogo il contesto di runtime è impostato da un nodo precedente o da un'applicazione esterna:

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

Nodo di dialogo o condizione di risposta:

$toppings_array.containsIgnoreCase('HAM')

Risultato: true perché l'array contiene l'elemento ham e il caso viene ignorato.

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

Questo metodo restituisce true se il JSONArray intents contiene specificatamente l'intento specificato e se l'intento ha un punteggio di affidabilità pari o superiore al punteggio minimo specificato. Facoltativamente, puoi specificare un numero per indicare che l'intento deve rientrare nel numero di elementi superiori nell'array. Il parametro top_n viene ignorato se si specifica un numero negativo.

Restituisce false se l'intento specificato non si trova nell'array, non ha un punteggio di affidabilità pari o superiore al punteggio minimo di affidabilità oppure se l'indice di array dell'intento si trova più in basso rispetto alla posizione di indice specificata.

Il servizio genera automaticamente un array intents che genera gli intenti che il servizio rileva nell'input ogniqualvolta viene inoltrato l'input utente. L'array elenca tutti gli intenti che sono stati rilevati dal servizio partendo dal livello di affidabilità più elevato.

Puoi utilizzare questo metodo in una condizione del nodo non solo per controllare la presenza di un intento, ma per impostare una soglia del punteggio di affidabilità che deve esser soddisfatta prima che il nodo possa essere elaborato e la sua risposta restituita.

Ad esempio, utilizza la seguente espressione in una condizione del nodo quando desideri attivare il nodo di dialogo solo nel caso in cui vengano soddisfatte le seguenti condizioni:

• È presente l'intento #General_Ending.
• Il punteggio di fiducia dell'intento di #General_Ending è superiore all'80%.
• L'intento #General_Ending è uno dei primi due intenti nell'array degli intenti.

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

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

Filtra un array confrontando ciascun valore dell'elemento dell'array con un valore che hai specificato. Questo metodo è simile a una proiezione della raccolta. Una proiezione della raccolta restituisce un array filtrato basato su un nome in una coppia nome-valore dell'elemento dell'array. Il metodo filter restituisce un array filtrato basato su un valore in una coppia nome-valore dell'elemento dell'array.

L'espressione di filtro è composta dai seguenti valori:

• temp: il nome di una variabile utilizzata temporaneamente mentre viene valutato ciascun elemento dell'array. Ad esempio, city.

• property: la proprietà dell'elemento che desideri confrontare con comparison_value. Specifica la proprietà come una proprietà della variabile temporanea che hai specificato nel primo parametro. Utilizza la sintassi: temp.property. Ad esempio, se latitude è un nome elemento valido per una coppia nome-valore nell'array, specifica la proprietà come city.latitude.

• operator: l'operatore da utilizzare per confrontare il valore della proprietà con comparison_value.

  Gli operatori supportati sono:

  Operatori di filtraggio supportati

  Operatore	Descrizione
  ==	È uguale a
  >	È maggiore di
  <	È minore di
  >=	È maggiore di o uguale a
  <=	È minore di o uguale a
  !=	Non è uguale a

• comparison_value: il valore con cui desideri confrontare ciascun valore della proprietà dell'elemento dell'array. Per specificare un valore che può cambiare a seconda dell'input utente, utilizza una variabile di contesto o un'entità come valore. Se si specifica un valore che può variare, aggiungere una logica per garantire che il valore comparison_value sia valido al momento della valutazione, altrimenti si verifica un errore.

[
   {
      "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)

Questo metodo restituisce l'indice di input dal JSONArray.

Per questa finestra di dialogo il contesto di runtime è impostato da un nodo precedente o da un'applicazione esterna:

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

Nodo di dialogo o condizione di risposta:

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

Risultato: True perché l'array annidato contiene one come valore.

Risposta:

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

JSONArray.getRandomItem()

Questo metodo restituisce un elemento casuale dal JSONArray di input.

Per questo contesto di runtime di dialogo:

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

Output del nodo di dialogo:

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

Risultato: "ham is a great choice!" o "onion is a great choice!" o "olives is a great choice!"

Il testo di uscita risultante viene scelto in modo casuale.

JSONArray.indexOf(value)

Questo metodo restituisce il numero di indice dell'elemento che corrisponde al valore che specifichi come parametro o a -1 se il valore non viene trovato nell'array. Il valore può essere String ("School"), Integer (8) o Double (9.1). Il valore deve essere una corrispondenza esatta ed è sensibile al maiuscolo / minuscolo.

Ad esempio, le seguenti variabili di contesto contengono array:

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

Le seguenti espressioni possono essere utilizzate per determinare l'indice dell'array in cui viene specificato il valore:

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

Questo metodo può essere utile per ottenere l'indice di un elemento in un array di intenti, ad esempio. Puoi applicare il metodo indexOf all'array di intenti generato ogni volta che l'input utente viene valutato per determinare il numero di indice dell'array di uno specifico intento.

intents.indexOf("General_Greetings")

Se desideri conoscere il punteggio di affidabilità per uno specifico intento, puoi passare l'espressione sopra riportata come valore index in un'espressione con la sintassi intents[index].confidence. Ad esempio:

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

JSONArray.join(String delimiter)

Questo metodo unisce tutti i valori di questo array a una stringa. I valori vengono convertiti in stringhe e delimitati dal delimitatore di input.

Per questo contesto di runtime di dialogo:

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

Output del nodo di dialogo:

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

Risultato:

This is the array: onion;olives;ham;

Se un input dell'utente menziona più condimenti e si è definita un'entità denominata @toppings in grado di riconoscere le menzioni dei condimenti, si potrebbe usare la seguente espressione nella risposta per elencare i condimenti menzionati:

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

Se definisci una variabile che memorizza più valori in un array JSON, puoi restituire un sottoinsieme di valori dall'array. Utilizzare il metodo join() per formattarli correttamente.

"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)

Questo metodo estrae le informazioni da ogni elemento nell'array e crea un nuovo array formattato in base al modello specificato. Il template può essere una stringa, un oggetto JSON o un array. Il metodo restituisce un array di stringhe, un array di oggetti o un array di array, a seconda del tipo di template.

Questo metodo è utile per formattare le informazioni come una stringa che puoi restituire come parte dell'emissione di un nodo di dialogo o per trasformare i dati in una struttura diversa in modo da poterli utilizzare con un'API esterna.

Nel modello, è possibile fare riferimento ai valori dall'array di origine utilizzando la sintassi seguente, dove {property} rappresenta il nome della proprietà nell'array di origine.

%e.{property}%

Ad esempio, supponiamo che il tuo assistente memorizzi un array che contiene i dettagli del volo in una variabile di contesto. I dati memorizzati potrebbero essere simili a quelli riportati di seguito:

"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"
      }
    ]

Per creare un array di stringhe che descrivono questi voli in un formato leggibile dall'utente, è possibile utilizzare la seguente espressione:

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

Questa espressione restituisce il seguente array di stringhe: ["Flight AZ1040 to FCO","Flight DL1710 to LAX","Flight VS4379 to LHR"].

Il parametro facoltativo retainDataType specifica se il metodo deve conservare il tipo di dati di tutti i valori di input nell'array restituito. Se retainDataType è impostato su false o omesso, in alcune situazioni, le stringhe nell'array di input potrebbero essere convertite in numeri nell'array restituito. Ad esempio, se i valori selezionati dall'array di input sono "1", "2" e "3", l'array restituito potrebbe essere [ 1, 2, 3 ]. Per evitare conversioni di tipo non previste, specificare true per questo parametro.

<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)

Questo metodo rimuove l'elemento nella posizione dell'indice dal JSONArray e restituisce il JSONArray aggiornato.

Per questo contesto di runtime di dialogo:

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

Effettua questo aggiornamento:

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

Risultato:

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

JSONArray.removeValue(object)

Questo metodo rimuove la prima ricorrenza del valore dal JSONArray e restituisce il JSONArray aggiornato.

Per questo contesto di runtime di dialogo:

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

Effettua questo aggiornamento:

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

Risultato:

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

JSONArray.set(Integer index, Object value)

Questo metodo imposta l'indice di input del JSONArray sul valore di input e restituisce il JSONArray modificato.

Per questo contesto di runtime di dialogo:

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

Output del nodo di dialogo:

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

Risultato:

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

JSONArray.size()

Questo metodo restituisce la dimensione del JSONArray come numero intero.

Per questo contesto di runtime di dialogo:

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

Effettua questo aggiornamento:

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

Risultato:

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

JSONArray split(String regexp)

Questo metodo suddivide la stringa di input utilizzando l'espressione regolare di input. Il risultato è un JSONArray di stringhe.

Per questo input:

"bananas;apples;pears"

Questa sintassi:

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

Risultati in questo output:

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

Supporto com.google.gson.JsonArray

Oltre ai metodi integrati, puoi utilizzare i metodi standard della classe com.google.gson.JsonArray.

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

.after(String date or time)

Determina se il valore data/ora è dopo l'argomento data/ora.

.before(String date or time)

Determina se il valore data/ora è prima dell'argomento data/ora.

Ad esempio:

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

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

• Se si confrontano elementi diversi, come time vs. date, date vs. time, e time vs. date and time, il metodo restituisce false e viene stampata un'eccezione nel log JSON della risposta output.log_messages.

  Ad esempio, @sys-date.before(@sys-time).

• Se si confronta date and time vs. time il metodo ignora la data e confronta solo gli orari.

now(String time zone)

Restituisce una stringa con la data e ora corrente in formato yyyy-MM-dd HH:mm:ss. Facoltativamente, specificare un valore timezone per ottenere la data e l'ora correnti per uno specifico fuso orario, con una stringa restituita nel formato yyyy-MM-dd HH:mm:ss 'GMT'XXX.

• Funzione statica.
• Gli altri metodi di data/ora possono essere richiamati sui valori data-ora restituiti da questa funzione e possono essere passati come argomento.
• L'interfaccia utente crea automaticamente una variabile di contesto $timezone, in modo da restituire l'ora corretta quando si esegue il test dal riquadro "Prova". Se non passi un fuso orario, viene utilizzato il fuso orario impostato automaticamente dalla IU. Al di fuori dalla IU, viene utilizzato GMT come fuso orario. Per conoscere la sintassi da utilizzare per specificare il fuso orario, vedere Fusi orari supportati dalle entità di sistema.

Esempio di utilizzo di now() per controllare prima se è mattina prima che l'assistente risponda con un messaggio di saluto specifico del mattino.

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

Esempio di utilizzo di now() con un fuso orario per restituire l'ora corrente (in Inghilterra):

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

È possibile sostituire il valore del fuso orario codificato con una variabile di contesto per modificare dinamicamente l'ora in base al fuso orario passato all'espressione. Ad esempio: <? now('$myzone') ?>. La variabile di contesto $myzone potrebbe essere impostata su 'Australia/Sydney' in una conversazione e su 'Mexico/BajaNorte' in un'altra.

.reformatDateTime(String format)

Formatta le stringhe di data e ora nel formato desiderato per l'output dell'utente.

Restituisce una stringa formattata in base al formato specificato:

• MM/dd/yyyy per 12/31/2016
• h a per 10pm

Per restituire il giorno della settimana:

• EEEE per martedì
• E per tonalità
• u per l'indice del giorno (1 = lunedì, ..., 7 = domenica)

Ad esempio, questa definizione di variabile di contesto crea una variabile $time che salva il valore 17:30:00 come 5:30 PM.

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

Il formato segue le regole del SimpleDateFormat Java.

Nota: quando si cerca di formattare solo l'ora, la data viene trattata come 1970-01-01.

.sameMoment(String date/time)

• Determina se il valore data/ora è uguale all'argomento data/ora.

.sameOrAfter(String date/time)

• Determina se il valore data/ora è dopo o uguale all'argomento data/ora.
• Simile a .after().

.sameOrBefore(String date/time)

• Determina se il valore data/ora è prima o uguale all'argomento data/ora.

today()

Restituisce una stringa con la data corrente nel formato yyyy-MM-dd.

• Funzione statica.
• Gli altri metodi di data possono essere richiamati sui valori di data restituiti da questa funzione e possono essere passati come argomento.
• Se la variabile di contesto $timezone è impostata, questa funzione restituisce le date nel fuso orario del client. In caso contrario, viene utilizzato il fuso orario GMT.

Esempio di un nodo di dialogo con today() utilizzato nel campo di output:

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

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

Utilizzo degli intervalli di tempo

Per mostrare una risposta basata sul fatto che la data di oggi rientra in un determinato intervallo di tempo, puoi utilizzare una combinazione di metodi correlati al tempo. Ad esempio, se ogni anno fai un'offerta speciale durante il periodo delle festività, puoi controllare se la data di oggi rientra nell'intervallo tra il 25 novembre e il 24 dicembre di quest'anno. Innanzitutto, definisci le date di interesse come variabili di contesto.

Nelle seguenti espressioni di variabili contestuali di data iniziale e finale, la data viene costruita concatenando il valore dell'anno corrente derivato con i valori di mese e giorno codificati.

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

Nella condizione di risposta, puoi indicare che desideri mostrare la risposta solo se la data corrente rientra tra la data iniziale e quella finale che hai definito come variabili di contesto.

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

Supporto java.util.Date

Oltre ai metodi integrati, puoi utilizzare i metodi standard della classe java.util.Date.

Per ottenere la data del giorno tra una settimana, puoi utilizzare la seguente sintassi.

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

Questa espressione ottiene innanzitutto la data corrente in millisecondi dal 1° gennaio 1970, 00:00:00 Tempo universale coordinato. Calcola anche il numero di millisecondi in 7 giorni. ((24*60*60*1000L) rappresenta un giorno in millisecondi.) Quindi aggiunge 7 giorni alla data corrente. Il risultato è la data completa del giorno tra una settimana. Ad esempio, Fri Jan 26 16:30:37 UTC 2018. L'ora è nel fuso orario UTC (Coordinated Universal Time). Puoi sempre modificare il valore 7 con una variabile ($number_of_days, ad esempio) che puoi passare. Assicurarsi che il suo valore venga impostato prima che questa espressione venga valutata.

Se si desidera confrontare la data con un'altra data generata dal servizio, è necessario riformattare la data. Le entità di sistema (@sys-date) e gli altri metodi integrati (now()) convertono le date nel formato yyyy-MM-dd.

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

Dopo aver riformattato la data, il risultato è 2018-01-26. Ora è possibile utilizzare un'espressione come @sys-date.after($week_from_today) in una condizione di risposta per confrontare una data specificata nell'input dell'utente con la data salvata nella variabile di contesto.

La seguente espressione calcola un orario di 3 ore a partire da ora.

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

Il valore (60*60*1000L) rappresenta un'ora in millisecondi. Questa espressione aggiunge 3 ore all'ora corrente. Ricalcola quindi l'ora dal fuso orario universale coordinato al fuso orario EST sottraendo 5 ore. Riformatta anche i valori della data in modo da includere ore e minuti AM o PM.

toDouble()

Converte l'oggetto o il campo nel tipo di numero Doppio. Puoi chiamare questo metodo su qualsiasi oggetto o campo. Se la conversione non riesce, viene restituito null.

toInt()

Converte l'oggetto o il campo nel tipo di numero Intero. Puoi chiamare questo metodo su qualsiasi oggetto o campo. Se la conversione non riesce, viene restituito null.

toLong()

Converte l'oggetto o il campo nel tipo di numero Lungo. Puoi chiamare questo metodo su qualsiasi oggetto o campo. Se la conversione non riesce, viene restituito null.

Se specifichi un tipo di numero Lungo in un'espressione SpEL, devi accodare una lettera L al numero per identificarlo come tale. Ad esempio, 5000000000L. Questa sintassi è obbligatoria per i numeri che non si adattano al tipo Intero a 32 bit. Ad esempio, i numeri maggiori di 2^31 (2.147.483.648) o minori di -2 (-2.147.483.648) sono considerati numeri lunghi. I tipi di numero Lungo hanno un valore minimo di -2^63 e un valore massimo di 2^63-1 (o 9.223.372.036.854.775.807).

Se si vuole determinare se un numero è troppo lungo per essere riconosciuto, si può verificare se ci sono più di 18 numeri interi nel numero utilizzando un'espressione come questa:

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

Se si ha bisogno di lavorare con numeri più lunghi di 18 interi, si consideri un'entità modello (con un'espressione regolare come \d{20} ) per lavorarci invece di usare @sys-number.

Matematica standard

Utilizza le espressioni SpEL per definire le equazioni matematiche standard dove gli operatori sono rappresentati utilizzando questi simboli:

Ad esempio, nella risposta di un nodo di dialogo, si può aggiungere una variabile di contesto che cattura un numero specificato nell'input dell'utente ( @sys-number ) e lo salva come $your_number. Puoi poi aggiungere il seguente testo come una risposta di testo:

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 ?>.

Se l'utente specifica 10, la risposta di testo risultante si presenta così:

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.

Supporto numero Java

java.lang.Math()

Esegue operazioni numeriche di base.

È possibile utilizzare i metodi Class:

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"
      }
    ]
  }
}

Per ulteriori informazioni, consulta la documentazione di riferimentojava.lang.Math.

java.util.Random()

Restituisce un numero casuale. Puoi utilizzare una delle seguenti opzioni di sintassi:

• Per restituire un valore booleano casuale (vero o falso), utilizzare <?new Random().nextBoolean()?>.
• Per restituire un numero doppio casuale compreso tra 0 (incluso) e 1 (escluso), utilizzare <?new Random().nextDouble()?>.
• Per restituire un numero intero casuale compreso tra 0 (incluso) e un numero specificato dall'utente, utilizzare <?new Random().nextInt(n)?> dove n è il massimo dell'intervallo di numeri desiderato + 1. Ad esempio, se si vuole restituire un numero casuale compreso tra 0 e 10, specificare <?new Random().nextInt(11)?>.
• Per restituire un intero casuale dall'intero intervallo di valori di Integer (da -2147483648 a 2147483648), utilizzare <?new Random().nextInt()?>.

Ad esempio, puoi creare un nodo di dialogo che viene attivato dall'intento #random_number. La prima condizione di risposta potrebbe essere simile alla seguente:

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"
      }
    ]
  }
}

Per informazioni sugli altri metodi, consultare la documentazione di riferimento di java.util.Random.

Puoi anche utilizzare i metodi standard delle seguenti classi:

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

JSONObject.clear()

Questo metodo cancella tutti i valori dall'oggetto JSON e restituisce null.

Ad esempio, desideri cancellare i valori correnti dalla variabile di contesto $user.

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

Utilizza la seguente espressione nell'output per definire un campo che cancella i valori dell'oggetto.

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

Se si fa riferimento alla variabile di contesto $user, viene restituito solo {}.

Puoi utilizzare il metodo clear() sugli oggetti JSON context o output nel corpo della chiamata API /message.

{
  "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)

Questo metodo restituisce true se il JSONObject complesso ha una proprietà del nome di input.

Per questo contesto di runtime di dialogo:

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

Output del nodo di dialogo:

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

Risultato: la condizione è true perché l'oggetto utente contiene la proprietà first_name.

JSONObject.remove(String)

Questo metodo rimuove una proprietà del nome dall'input JSONObject. Il JSONElement che viene restituito da questo metodo è il JSONElement che verrà rimosso.

Per questo contesto di runtime di dialogo:

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

Output del nodo di dialogo:

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

Risultato:

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

Supporto com.google.gson.JsonObject

Oltre ai metodi integrati, sono supportati anche alcuni dei metodi standard della classe com.google.gson.JsonObject.

String.append(Object)

Questo metodo aggiunge un oggetto di input alla stringa sotto forma di stringa e restituisce una stringa modificata.

Per questo contesto di runtime di dialogo:

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

Questa sintassi:

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

Risultati in questo output:

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

String.contains(String)

Questo metodo restituisce true se la stringa contiene la sottostringa di input.

Input: Yes, I'd like to go.

Questa sintassi:

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

Risultato: la condizione è true.

String.endsWith(String)

Questo metodo restituisce true se la stringa termina con la sottostringa di input.

Per questo input:

"What is your name?".

Questa sintassi:

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

Risultato: la condizione è true.

String.equals(Stringa)

Questo metodo restituisce true se la stringa specificata è esattamente uguale alla stringa di input.

Input: "Sì"

Questa sintassi:

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

Risultato: la condizione è true.

Se l'input è Yes., il risultato è false perché l'utente ha incluso un punto e l'espressione prevede solo il testo esatto, Yes senza punteggiatura.

String.equalsIgnoreCase(String)

Questo metodo restituisce true se la stringa specificata è uguale alla stringa di input, indipendentemente dal fatto che il maiuscolo / minuscolo delle lettere corrisponda.

Input: "sì"

Questa sintassi:

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

Risultato: la condizione è true.

Se l'input è Yes., il risultato è false perché l'utente ha incluso un punto e l'espressione prevede solo il testo Yes, in lettere maiuscole o minuscole senza punteggiatura.

String.extract(String regexp, Integer groupIndex)

Questo metodo restituisce una stringa dall'input che corrisponde al modello di gruppo dell'espressione regolare che specifichi. Restituisce una stringa vuota se non vengono trovate corrispondenze.

Questo metodo è progettato per estrarre le corrispondenze per i diversi gruppi di modelli regex, non le diverse corrispondenze per un singolo modello regex. Per trovare corrispondenze diverse, vedi il metodo getMatch.

In questo esempio, la variabile di contesto sta salvando una stringa che corrisponde al gruppo di modelli regex che specifichi. Nell'espressione, sono definiti due gruppi di modelli regex, ciascuno racchiuso tra parentesi. Un terzo gruppo inerente è composto dai due gruppi. Questo è il primo gruppo regex groupIndex 0); corrisponde a una stringa che contiene l'intero gruppo di numeri e il gruppo di testo. Il secondo gruppo regex (groupIndex 1) corrisponde alla prima ricorrenza di un gruppo di numeri. Il terzo gruppo (groupIndex 2) corrisponde alla prima ricorrenza di un gruppo di testo dopo un gruppo di numeri.

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

Quando si specifica l'espressione regolare in JSON, è necessario fornire due barre rovesciate (\). Se si specifica questa espressione in una risposta del nodo, è necessaria solo una barra rovesciata. Ad esempio:

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

Input:

"Hello 123 this is 456".

Risultato:

• Quando n=0, il valore è 123 this.
• Quando n=1, il valore è 123.
• Quando n=2, il valore è this.

String.find(String regexp)

Questo metodo restituisce true se qualsiasi segmento della stringa corrisponde all'espressione regolare di input. Questo metodo può essere richiamato per un elemento JSONArray o JSONObject e converte l'array o l'oggetto in una stringa prima di effettuare il confronto.

Per questo input:

"Hello 123456".

Questa sintassi:

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

Risultato: la condizione è true perché la parte numerica del testo di input corrisponde all'espressione regolare ^[^\d]*[\d]{6}[^\d]*$.

String.getMatch(String regexp, Integer matchIndex)

Questo metodo restituisce una stringa dall'input che corrisponde alla ricorrenza del modello di gruppo dell'espressione regolare che specifichi. Questo metodo restituisce una stringa vuota se non vengono trovate corrispondenze.

Man mano che vengono trovate corrispondenze, vengono aggiunte a quello che puoi considerare come un array di corrispondenze. Se vuoi restituire la terza corrispondenza, poiché il conteggio degli elementi dell'array inizia da 0, specifica 2 come valore di matchIndex. Ad esempio, se immetti una stringa di testo con tre parole che corrispondono al modello specificato, puoi restituire solo la prima, la seconda o la terza corrispondenza specificando il suo valore di indice.

Nella seguente espressione, stai ricercando un gruppo di numeri nell'input. Questa espressione salva la seconda stringa di corrispondenza del modello nella variabile di contesto $second_number poiché viene specificato il valore di indice 1.

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

Se si specifica l'espressione nella sintassi JSON, è necessario fornire due barre rovesciate (\). Se si specifica l'espressione in una risposta del nodo, è necessaria solo una barra rovesciata.

Ad esempio:

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

• Input utente:

  "hello 123 i said 456 and 8910".
  

• Risultato: 456

In questo esempio, l'espressione cerca il terzo blocco di testo nell'input.

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

Per lo stesso input utente, questa espressione restituisce and.

String.isEmpty()

Questo metodo restituisce true se la stringa è una stringa vuota, ma non null.

Per questo contesto di runtime di dialogo:

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

Questa sintassi:

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

Risultato: la condizione è true.

String.length()

Questo metodo restituisce la lunghezza dei caratteri della stringa.

Per questo input:

"Hello"

Questa sintassi:

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

Risultati in questo output:

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

String.matches(String regexp)

Questo metodo restituisce true se la stringa corrisponde all'espressione regolare di input.

Per questo input:

"Hello".

Questa sintassi:

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

Risultato: la condizione è true perché il testo di input corrisponde all'espressione regolare \^Hello\$.

String.startsWith(String)

Questo metodo restituisce true se la stringa inizia con la sottostringa di input.

Per questo input:

"What is your name?".

Questa sintassi:

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

Risultato: la condizione è true.

String.substring(Integer beginIndex, Integer endIndex)

Questo metodo ottiene una sottostringa con il carattere in beginIndex e l'ultimo carattere da indicizzare prima di endIndex. Il carattere endIndex non è incluso.

Per questo contesto di runtime di dialogo:

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

Questa sintassi:

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

Risultati in questo output:

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

String.toJson()

Questo metodo analizza una stringa che contiene dati JSON e restituisce un oggetto o un array JSON, come in questo esempio:

${json_var}.toJson()

Se la variabile di contesto ${json_var} contiene la seguente stringa:

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

Il metodo toJson() restituisce il seguente oggetto:

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

String.toLowerCase()

Questo metodo restituisce la stringa originale convertita in lettere minuscole.

Per questo input:

"This is A DOG!"

Questa sintassi:

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

Risultati in questo output:

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

String.toUpperCase()

Questo metodo restituisce la stringa originale convertita in lettere maiuscole.

Per questo input:

"hi there".

Questa sintassi:

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

Risultati in questo output:

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

String.trim()

Questo metodo elimina gli spazi all'inizio e alla fine della stringa e restituisce la stringa modificata.

Per questo contesto di runtime di dialogo:

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

Questa sintassi:

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

Risultati in questo output:

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

Supporto java.lang.String

Oltre ai metodi integrati, puoi utilizzare i metodi standard della classe java.lang.String.

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

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