JSONArray.addAll(JSONArray)

Este método añade una matriz a otra.

Para este contexto de tiempo de ejecución del diálogo:

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

Realice esta actualización:

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

Resultado: el propio método devuelve null. Sin embargo, la primera matriz se actualiza para incluir los valores de la segunda matriz.

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

JSONArray.append(object)

Este método añade un nuevo valor a JSONArray y devuelve la matriz JSONArray modificada.

Para este contexto de tiempo de ejecución del diálogo:

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

Realice esta actualización:

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

Resultado:

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

JSONArray.clear()

Este método borra todos los valores de la matriz y devuelve un valor nulo.

Utilice la expresión siguiente en la salida para definir un campo que borre una matriz que ha guardado en una variable de contexto ($toppings_array) de sus valores.

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

Entonces, si hace referencia a la variable de contexto $toppings_array, ésta devuelve ' [] ' solamente.

JSONArray.contains(Object value)

Este método devuelve true si la matriz JSONArray de entrada contiene el valor de entrada.

Para este contexto de ejecución de diálogo que se establece por un nodo anterior o aplicación externa:

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

Nodo de diálogo o condición de respuesta:

$toppings_array.contains('ham')

Resultado: true porque la matriz contiene el elemento ham.

JSONArray.containsIgnoreCase(Object value)

Este método devuelve true si la matriz JSONArray de entrada contiene el valor de entrada, independientemente de si el valor está especificado en letras mayúsculas o minúsculas.

Para este contexto de ejecución de diálogo que se establece por un nodo anterior o aplicación externa:

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

Nodo de diálogo o condición de respuesta:

$toppings_array.containsIgnoreCase('HAM')

Resultado: true porque la matriz contiene el elemento ham y el uso de mayúsculas y minúsculas no se tiene en cuenta.

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

Este método devuelve true si la matriz JSON intents contiene específicamente la intención especificada, y dicha intención tiene una puntuación de confianza que es igual o mayor que la puntuación mínima especificada. Si lo desea, puede especificar un número para indicar que la intención se debe incluir dentro de ese número de elementos principales en la matriz. El parámetro top_n se ignora si se especifica un número negativo.

Devuelve false si la intención especificada no está en la matriz, si no tiene una puntuación de confianza igual o mayor que la puntuación mínima de confianza o si el índice de la matriz de la intención es inferior que la ubicación de índice especificada.

El servicio genera automáticamente una matriz intents que enumera las intenciones que detecta el servicio en la entrada siempre que se envía una entrada de usuario. La matriz muestra todas las intenciones que detecta el servicio, con la de mayor confianza en primer lugar.

Puede utilizar este método en una condición de nodo para comprobar no solo la presencia de una intención, sino también para establecer un umbral de puntuación de confianza que se debe cumplir para que el nodo se pueda procesar y se devuelva su respuesta.

Por ejemplo, utilice la expresión siguiente en una condición de nodo cuando desee desencadenar el nodo de diálogo solo cuando se cumplan las condiciones siguientes:

• Aparezca la intención #General_Ending.
• La puntuación de confianza de la intención #General_Ending es superior al 80 %.
• La intención #General_Ending sea una de las 2 intenciones principales en la matriz de intenciones.

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

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

Filtra una matriz, comparando cada valor de elemento de la matriz con un valor que especifique. Este método es similar a una proyección de colección. Una proyección de colección devuelve una matriz filtrada basada en un nombre de un par nombre-valor de un elemento de la matriz. El método de filtrado devuelve una matriz filtrada basada en un valor de un par nombre-valor de un elemento de la matriz.

La expresión de filtro consta de los valores siguientes:

• temp: Nombre de una variable que se utiliza temporalmente a medida que se evalúa cada elemento de la matriz. Por ejemplo, city.

• property: Propiedad del elemento que desea comparar con comparison_value. Especifique la propiedad como una propiedad de la variable temporal que ha especificado en el primer parámetro. Utilice la sintaxis: temp.property. Por ejemplo, si latitude es un nombre de elemento válido para un par nombre-valor de la matriz, especifique la propiedad como city.latitude.

• operator: Operador que se utilizará para comparar el valor de la propiedad con comparison_value.

  Los operadores admitidos son:

  Operadores de filtro admitidos

  Operador	Descripción
  ==	Es igual que
  >	Es mayor que
  <	Es menos que
  >=	Mayor o igual que
  <=	Menor o igual que
  !=	No es igual que

• comparison_value: Valor con el que desea comparar cada valor de propiedad de elemento de la matriz. Para especificar un valor que pueda cambiar en función de la entrada del usuario, utilice una variable de contexto o una entidad como el valor. Si especifica un valor que puede variar, añada lógica para garantizar que el valor comparison_value es válido en el momento de la evaluación o se producirá un error.

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

Este método devuelve el índice de entrada de la matriz JSONArray.

Para este contexto de ejecución de diálogo que se establece por un nodo anterior o aplicación externa:

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

Nodo de diálogo o condición de respuesta:

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

Resultado: True porque la matriz anidada contiene one como valor.

Respuesta:

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

JSONArray.getRandomItem()

Este método devuelve un elemento aleatorio procedente de la JSONArray de entrada.

Para este contexto de tiempo de ejecución del diálogo:

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

Salida del nodo del diálogo:

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

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

El texto de salida resultante se elige aleatoriamente.

JSONArray.indexOf(value)

Este método devuelve el número de índice del elemento de la matriz que coincide con el valor que especifica como un parámetro o -1 si el valor no se encuentra en la matriz. El valor puede ser una cadena ( "School" ), un número entero ( 8 ) o un número doble ( 9.1 ). El valor debe coincidir exactamente y distingue entre mayúsculas y minúsculas.

Por ejemplo, las siguientes variables de contexto contienen matrices:

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

Se pueden utilizar las siguientes expresiones para determinar el índice de la matriz en el que se especifica el valor:

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

Este método puede resultar útil, por ejemplo, para obtener el índice de un elemento de una matriz de intenciones. Puede aplicar el método indexOf a la matriz de intenciones que se genera cada vez que se evalúa la entrada del usuario para determinar el número de índice de matriz de una intención específica.

intents.indexOf("General_Greetings")

Si desea conocer la puntuación de confianza de una intención específica, puede pasar la expresión anterior en como el valor index a una expresión con la sintaxis intents[index].confidence. Por ejemplo:

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

JSONArray.join(String delimiter)

Este método une todos los valores de esta matriz a una serie. Los valores se convierten en cadenas y se delimitan mediante el delimitador de entrada.

Para este contexto de tiempo de ejecución del diálogo:

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

Salida del nodo del diálogo:

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

Resultado:

This is the array: onion;olives;ham;

Si un usuario menciona varios toppings y usted ha definido una entidad llamada @toppings que puede reconocer las menciones de toppings, puede utilizar la siguiente expresión en la respuesta para enumerar los toppings mencionados:

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

Si define una variable que almacena varios valores en una matriz JSON, puede devolver un subconjunto de valores de la matriz. Utilice el método join() para formatearlos correctamente.

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

Este método extrae información de cada elemento de la matriz y crea una nueva matriz formateada según la plantilla que especifique. La plantilla puede ser una serie, un objeto JSON o una matriz. El método devuelve una matriz de series, una matriz de objetos o una matriz de matrices, en función del tipo de plantilla.

Este método es útil para formatear información como una serie que puede devolver como parte de la salida de un nodo de diálogo, o para transformar datos en una estructura diferente para que pueda utilizarla con una API externa.

En la plantilla, puede hacer referencia a valores de la matriz de origen utilizando la sintaxis siguiente, donde {property} representa el nombre de la propiedad en la matriz de origen.

%e.{property}%

Por ejemplo, supongamos que el asistente almacena una matriz que contiene detalles de vuelo en una variable de contexto. Los datos almacenados pueden tener este aspecto:

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

Para crear una matriz de series que describan estos vuelos en un formato legible por el usuario, puede utilizar la expresión siguiente:

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

Esta expresión devolvería la siguiente matriz de series: ["Flight AZ1040 to FCO","Flight DL1710 to LAX","Flight VS4379 to LHR"].

El parámetro opcional retainDataType especifica si el método debe conservar el tipo de datos de todos los valores de entrada en la matriz devuelta. Si retainDataType se establece en false u se omite, en algunas situaciones, las series de la matriz de entrada se pueden convertir en números en la matriz devuelta. Por ejemplo, si los valores seleccionados de la matriz de entrada son "1", "2" y "3", la matriz devuelta podría ser [ 1, 2, 3 ]. Para evitar conversiones de tipo inesperadas, especifique true para este parámetro.

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

Este método elimina el elemento en la posición de índice de JSONArray y devuelve la matriz JSONArray actualizada.

Para este contexto de tiempo de ejecución del diálogo:

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

Realice esta actualización:

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

Resultado:

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

JSONArray.removeValue(object)

Este método elimina la primera aparición del valor de JSONArray y devuelve la matriz JSONArray actualizada.

Para este contexto de tiempo de ejecución del diálogo:

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

Realice esta actualización:

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

Resultado:

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

JSONArray.set(Integer index, Object value)

Este método establece el índice de entrada de JSONArray en el valor de entrada y devuelve la matriz JSONArray modificada.

Para este contexto de tiempo de ejecución del diálogo:

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

Salida del nodo del diálogo:

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

Resultado:

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

JSONArray.size()

Este método devuelve el tamaño de la matriz JSONArray como un entero.

Para este contexto de tiempo de ejecución del diálogo:

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

Realice esta actualización:

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

Resultado:

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

JSONArray split(String regexp)

Este método divide la serie de entrada utilizando la expresión regular de entrada. El resultado es una matriz JSONArray de series.

Por esta entrada:

"bananas;apples;pears"

Esta sintaxis:

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

Da como resultado esta salida:

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

Soporte de com.google.gson.JsonArray

Además de los métodos incorporados, utilice los métodos estándar de la clase com.google.gson.JsonArray.

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

.after(String date or time)

Determina si el valor de fecha y hora es posterior al argumento date/time.

.before(String date or time)

Determina si el valor de fecha y hora es anterior al argumento date/time.

Por ejemplo:

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

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

• Si se comparan elementos diferentes, como time vs. date, date vs. time, y time vs. date and time, el método devuelve false y se imprime una excepción en el registro JSON de respuesta output.log_messages.

  Por ejemplo, @sys-date.before(@sys-time).

• Si compara date and time vs. time, el método ignora la fecha y compara sólo las horas.

now (huso horario de serie)

Devuelve una serie con la fecha y hora actuales en el formato yyyy-MM-dd HH:mm:ss. Opcionalmente, especifique un valor timezone para obtener la fecha y hora actuales para un huso horario específico, con una serie devuelta en el formato yyyy-MM-dd HH:mm:ss 'GMT'XXX.

• Función estática.
• Los otros métodos de fecha y hora se pueden invocar en valores de fecha y hora que devuelve esta función y se pueden pasar como argumento.
• La interfaz de usuario crea automáticamente una variable contextual $timezone para que se devuelva la hora correcta cuando realice la prueba desde el panel "Probar". Si no pasa de un huso horario, se utilizará el huso horario establecido automáticamente por la interfaz de usuario. Fuera de la interfaz de usuario, se utiliza GMT como huso horario. Para conocer la sintaxis a utilizar para especificar la zona horaria, consulte Zonas horarias soportadas por las entidades del sistema.

Ejemplo de uso de now() para comprobar primero si es por la mañana antes de que el asistente responda con un saludo específico de la mañana.

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

Ejemplo de uso de now() con una zona horaria para devolver la hora actual (en Inglaterra):

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

Puede sustituir el valor de zona horaria codificado por una variable de contexto para cambiar dinámicamente la hora en función de una zona horaria que se pase a la expresión. Por ejemplo: <? now('$myzone') ?>. La variable de contexto $myzone se puede establecer en 'Australia/Sydney' en una conversación y en 'Mexico/BajaNorte' en otra.

.reformatDateTime(String format)

Formatea las cadenas de fecha y hora al formato que desee para la salida del usuario.

Devuelve una serie formateada según el formato especificado:

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

Para devolver el día de la semana:

• EEEE para martes
• E para Tue
• u para índice de días (1 = lunes, ..., 7 = domingo)

Por ejemplo, esta definición variable de contexto crea una variable $time que guarda el valor 17:30:00 como 5:30 PM.

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

El formato sigue las reglas de Java SimpleDateFormat.

Nota: Cuando se intenta formatear sólo la hora, la fecha se trata como 1970-01-01.

.sameMoment(String date/time)

• Determina si el valor de fecha y hora es igual al argumento date/time.

.sameOrAfter(String date/time)

• Determina si el valor de fecha y hora es posterior o igual al argumento date/time.
• Similar a .after().

.sameOrBefore(String date/time)

• Determina si el valor de fecha y hora es anterior o igual al argumento date/time.

today()

Devuelve una serie con la fecha actual en el formato yyyy-MM-dd.

• Función estática.
• Los otros métodos de fecha se pueden invocar en valores de fecha que devuelve esta función y se pueden pasar como argumento.
• Si se ha definido la variable de contexto $timezone, esta función devuelve fechas en el huso horario del cliente. De lo contrario, se utiliza el huso horario GMT.

Ejemplo de un nodo de diálogo en el que se utiliza today() en el campo de salida:

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

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

Cómo trabajar con intervalos de tiempo

Para mostrar una respuesta que dependa de si la fecha de hoy se encuentra dentro de un determinado intervalo de tiempo, puede utilizar una combinación de métodos relacionados con el tiempo. Por ejemplo, si ejecuta una oferta especial durante la temporada navideña cada año, puede comprobar si la fecha de hoy se encuentra entre el 25 de noviembre y el 24 de diciembre de este año. En primer lugar, defina las fechas de interés como variables de contexto.

En las siguientes expresiones de variables de contexto de fecha inicial y final, la fecha se construye concatenando el valor del año actual derivado con los valores de mes y día codificados.

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

En la condición de respuesta, puede indicar que desea mostrar la respuesta únicamente si la fecha actual se encuentra entre las fechas de inicio y de finalización que ha definido como variables de contexto.

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

Soporte de java.util.Date

Además de los métodos incorporados, utilice los métodos estándar de la clase java.util.Date.

Para obtener la fecha de aquí a una semana, puede utilizar la siguiente sintaxis.

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

Esta expresión obtiene primero la fecha actual en milisegundos desde el 1 de enero de 1970, 00:00:00 Tiempo Universal Coordinado. También calcula el número de milisegundos en 7 días. ((24*60*60*1000L) representa un día en milisegundos). A continuación añade 7 días a la fecha actual. El resultado es la fecha completa del día que cae de aquí una semana a partir de la fecha actual de hoy. Por ejemplo, Fri Jan 26 16:30:37 UTC 2018. La hora está en el huso horario universal coordinado. Siempre es posible cambiar 7 por una variable ($number_of_days, por ejemplo) que puede pasar a la expresión. Asegúrese de que su valor se establece antes de que se evalúe esta expresión.

Si desea poder comparar la fecha con otra fecha generada por el servicio, deberá reformatear la fecha. Las entidades del sistema (@sys-date) y otros métodos incorporados (now()) convierten la fecha al formato yyyy-MM-dd.

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

Después de reformatear la fecha, el resultado es 2018-01-26. Ahora, puede utilizar una expresión como @sys-date.after($week_from_today) en una condición de respuesta para comparar una fecha especificada en la entrada del usuario con la fecha guardada en la variable de contexto.

La siguiente expresión calcula la hora de aquí a 3 horas.

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

El valor (60*60*1000L) representa una hora en milisegundos. Esta expresión añade 3 horas a la hora actual. A continuación, recalcula la hora del huso horario universal coordinado al huso horario EST restándole 5 horas. También reformatea los valores de fecha para incluir las horas y los minutos con AM o PM.

toDouble()

Convierte el objeto o campo al tipo de número Double (doble). Puede llamar a este método sobre cualquier objeto o campo. Si la conversión falla, se devuelve null.

toInt()

Convierte el objeto o campo al tipo de número Integer (entero). Puede llamar a este método sobre cualquier objeto o campo. Si la conversión falla, se devuelve null.

toLong()

Convierte el objeto o campo al tipo de número Long (largo). Puede llamar a este método sobre cualquier objeto o campo. Si la conversión falla, se devuelve null.

Si especifica un tipo de número Long en una expresión SpEL, debe añadir una L al número para identificarlo como tal. Por ejemplo, 5000000000L. Esta sintaxis es necesaria para cualquier número que no encaje en el tipo Integer de 32 bits. Por ejemplo, los números mayores que 2^31 (2.147.483.648) o menores que -2 (-2.147.483.648) se consideran tipos de números Largos. Los tipos de números Long tienen un valor mínimo de -2^63 y un valor máximo de 2^63-1 (o 9,223,372,036,854,775,807).

Si necesitas determinar si un número es demasiado largo para ser reconocido, comprueba si hay más de 18 enteros en el número utilizando una expresión como ésta:

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

Si necesita trabajar con números de más de 18 enteros, considere una entidad de patrón (con una expresión regular como \d{20} ) para trabajar con ellos en lugar de utilizar @sys-number.

Matemáticas estándares

Utilice expresiones SpEL para definir ecuaciones matemáticas estándares, donde los operadores se representan con estos símbolos:

Por ejemplo, en una respuesta de nodo de diálogo, puede añadir una variable de contexto que capture un número especificado en la entrada del usuario ( @sys-number ) y lo guarde como $your_number. Luego puede añadir el texto siguiente como respuesta de texto:

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

Si el usuario especifica 10, la respuesta de texto resultante es la siguiente:

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.

Soporte numérico de Java

java.lang.Math()

Realiza las operaciones numéricas básicas.

Puede utilizar los métodos de clase:

máx ()

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

mín ()

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

Para obtener más información, consulte la documentación de referencia dejava.lang.Math.

java.util.Random()

Devuelve un número aleatorio. Utilice una de las siguientes opciones de sintaxis:

• Para devolver un valor booleano aleatorio (true o false), utilice <?new Random().nextBoolean()?>.
• Para devolver un número doble aleatorio entre 0 (incluido) y 1 (excluido), utilice <?new Random().nextDouble()?>.
• Para devolver un entero aleatorio comprendido entre 0 (incluido) y el número que especifique, utilice <?new Random().nextInt(n)?> donde n equivale al mayor del rango de números que quiere que se devuelva + 1. Por ejemplo, si quiere que se devuelva un número aleatorio comprendido entre 0 y 10, especifique <?new Random().nextInt(11)?>.
• Para devolver un entero aleatorio del rango completo de valores enteros (entre -2147483648 y 2147483648), utilice <?new Random().nextInt()?>.

Por ejemplo, supongamos que desea crear un nodo de diálogo que se activa mediante la intención #random_number. La primera condición de respuesta se parecería a la siguiente:

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

Consulte la documentación de referencia de java.util.Random para obtener información sobre otros métodos.

También puede utilizar métodos estándar de las siguientes clases:

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

JSONObject.clear()

Este método borra todos los valores del objeto JSON y devuelve un valor nulo.

Por ejemplo, si desea borrar los valores actuales de la variable de contexto $user.

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

Utilice la expresión siguiente en la salida para definir un campo que borre el objeto de sus valores.

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

Si hace referencia a la variable de contexto $user, devuelve {} solamente.

Puede utilizar el método clear() en los objetos JSON context u output en el cuerpo de la llamada de 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)

Este método devuelve true si el objeto JSONObject complejo tiene una propiedad del nombre de entrada.

Para este contexto de tiempo de ejecución del diálogo:

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

Salida del nodo del diálogo:

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

Resultado: La condición es true (verdadera) porque el objeto de usuario contiene la propiedad first_name.

JSONObject.remove(String)

Este método elimina una propiedad del nombre de la entrada JSONObject. El elemento JSONElement que devuelve este método es el JSONElement que se va a eliminar.

Para este contexto de tiempo de ejecución del diálogo:

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

Salida del nodo del diálogo:

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

Resultado:

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

Soporte de com.google.gson.JsonObject

Además de los métodos incorporados, se admiten también algunos métodos estándar de la clase com.google.gson.JsonObject.

String.append(Object)

Este método añade un objeto de entrada a la serie como serie (string) y devuelve una serie modificada.

Para este contexto de tiempo de ejecución del diálogo:

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

Esta sintaxis:

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

Da como resultado esta salida:

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

String.contains(String)

Este método devuelve true si la serie contiene la subserie de entrada.

Entrada: Yes, I'd like to go.

Esta sintaxis:

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

Da como resultado: La condición es true.

String.endsWith(String)

Este método devuelve true si la serie termina por la subserie de entrada.

Por esta entrada:

"What is your name?".

Esta sintaxis:

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

Da como resultado: La condición es true.

String.equals(String)

Este método devuelve true si la serie especificada es exactamente igual a la serie de entrada.

Entrada: "Yes"

Esta sintaxis:

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

Da como resultado: La condición es true.

Si la entrada es Yes., el resultado es false, porque el usuario ha incluido un punto y la expresión espera solo el texto exacto, Yes, sin ninguna puntuación.

String.equalsIgnoreCase(String)

Este método devuelve true si la cadena especificada es igual a la cadena de entrada, independientemente de que coincidan las mayúsculas y minúsculas.

Entrada: "yes"

Esta sintaxis:

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

Da como resultado: La condición es true.

Si la entrada es Yes., entonces el resultado es false porque el usuario incluyó un punto y la expresión sólo espera el texto Yes, en mayúsculas o minúsculas sin ningún signo de puntuación.

String.extract(String regexp, Integer groupIndex)

Este método devuelve una serie de la entrada que coincide con el patrón de grupo de expresiones regulares que especifique. Devuelve una serie vacía si no se encuentra ninguna coincidencia.

Este método se ha diseñado para extraer coincidencias para distintos grupos de patrones de expresión regular (regex), no diferentes coincidencias para un patrón de expresión regular único. Para buscar coincidencias diferentes, consulte el método getMatch.

En este ejemplo, la variable de contexto guarda una serie que coincide con el grupo del patrón de expresión regular que se especifica. En la expresión, se definen dos grupos de patrones de expresión regular, cada uno encerrado entre paréntesis. Un tercer grupo inherente se compone de los dos grupos. Este es el primer grupo regex groupIndex 0); coincide con una cadena que contiene el grupo de números completo y el grupo de texto. El segundo grupo de regex (groupIndex 1) coincide con la primera aparición de un grupo de números. El tercer grupo (groupIndex 2) coincide con la primera aparición de un grupo de texto después de un grupo de números.

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

Al especificar la expresión regular en JSON, se tienen que incluir dos barras inclinadas invertidas (\). Si se especifica esta expresión en una respuesta de nodo, solo se necesita una barra inclinada invertida. Por ejemplo:

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

Entrada:

"Hello 123 this is 456".

Resultado:

• Si n=0, el valor es 123 this.
• Si n=1, el valor es 123.
• Si n=2, el valor es this.

String.find(String regexp)

Este método devuelve true si algún segmento de la serie coincide con la expresión regular de entrada. Puedes llamar a este método contra un elemento JSONArray o JSONObject, y convierte el array u objeto en una cadena antes de hacer la comparación.

Por esta entrada:

"Hello 123456".

Esta sintaxis:

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

Da como resultado: La condición es true porque la parte numérica de la entrada coincide con la expresión regular ^[^\d]*[\d]{6}[^\d]*$.

String.getMatch(String regexp, Integer matchIndex)

Este método devuelve una serie de la entrada que coincide con la instancia del patrón de grupo de expresiones regulares que especifique. Este método devuelve una serie vacía si no se encuentra ninguna coincidencia.

A medida que se encuentran coincidencias, se añaden a lo que se puede pensar como una matriz de coincidencias. Si desea devolver la tercera coincidencia, porque el recuento de elementos de matriz empieza en 0, especifique 2 como el valor matchIndex. Por ejemplo, si especifica una serie de texto con tres palabras que coincidan con el patrón especificado, puede devolver la primera, segunda o tercera coincidencia solo especificando el valor de su índice.

En la expresión siguiente, está buscando un grupo de números en la entrada. Esta expresión guarda la segunda serie de coincidencia de patrón en la variable de contexto $second_number porque se ha especificado el valor de índice 1.

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

Si se especifica la expresión en sintaxis JSON, se tienen que incluir dos barras inclinadas invertidas (\). Si se especifica la expresión en una respuesta de nodo, solo se necesita una barra inclinada invertida.

Por ejemplo:

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

• Entrada del usuario:

  "hello 123 i said 456 and 8910".
  

• Resultado: 456

En este ejemplo, la expresión busca el tercer bloque de texto en la entrada.

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

Para la misma entrada de usuario, esta expresión devuelve and.

String.isEmpty()

Este método devuelve true si la serie termina es una serie vacía pero no nula.

Para este contexto de tiempo de ejecución del diálogo:

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

Esta sintaxis:

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

Da como resultado: La condición es true.

String.length()

Este método devuelve la longitud en caracteres de la serie.

Por esta entrada:

"Hello"

Esta sintaxis:

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

Da como resultado esta salida:

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

String.matches(String regexp)

Este método devuelve true si la serie coincide con la expresión regular de entrada.

Por esta entrada:

"Hello".

Esta sintaxis:

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

Da como resultado: La condición es true porque el texto coincide con la expresión regular \^Hello\$.

String.startsWith(String)

Este método devuelve true si la serie empieza por la subserie de entrada.

Por esta entrada:

"What is your name?".

Esta sintaxis:

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

Da como resultado: La condición es true.

String.substring(Integer beginIndex, Integer endIndex)

Este método obtiene una subcadena con el carácter en beginIndex y el último conjunto de caracteres a indexar antes de endIndex. El carácter endIndex no se incluye.

Para este contexto de tiempo de ejecución del diálogo:

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

Esta sintaxis:

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

Da como resultado esta salida:

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

String.toJson()

Este método analiza una serie que contiene datos JSON y devuelve un objeto o matriz JSON, como en este ejemplo:

${json_var}.toJson()

Si la variable de contexto ${json_var} contiene la serie siguiente:

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

El método toJson() devuelve el objeto siguiente:

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

String.toLowerCase()

Este método devuelve la cadena original convertida a minúsculas.

Por esta entrada:

"This is A DOG!"

Esta sintaxis:

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

Da como resultado esta salida:

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

String.toUpperCase()

Este método devuelve la cadena original convertida a mayúsculas.

Por esta entrada:

"hi there".

Esta sintaxis:

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

Da como resultado esta salida:

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

String.trim()

Este método elimina los espacios al principio y al final de la serie y devuelve la serie modificada.

Para este contexto de tiempo de ejecución del diálogo:

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

Esta sintaxis:

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

Da como resultado esta salida:

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

Soporte de java.lang.String

Además de los métodos incorporados, utilice los métodos estándar de la clase java.lang.String.

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

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