JSONArray.addAll(JSONArray)

此方法将一个数组附加到另一个数组。

对于以下对话运行时上下文：

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

进行以下更新：

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

结果: 方法本身返回 null。 但是，将更新第一个数组以包含第二个数组中的值。

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

JSONArray.append(object)

此方法用于将新值附加到 JSONArray，并返回修改后的 JSONArray。

对于以下对话运行时上下文：

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

进行以下更新：

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

结果：

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

JSONArray.clear()

此方法用于清除数组中的所有值并返回 null。

在输出中使用以下表达式来定义一个字段，用于清除保存到其值的上下文变量的数组 ($toppings_array)。

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

然后，如果您引用$toppings_array上下文变量，它只返回“[]”。

JSONArray.contains(Object value)

如果输入 JSONArray 包含输入值，那么此方法会返回 true。

对于由前一个节点或外部应用程序设置的此对话框运行时上下文：

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

对话节点或响应条件：

$toppings_array.contains('ham')

结果：true，因为数组中包含元素 ham。

JSONArray.containsIgnoreCase(Object value)

如果输入 JSONArray 包含输入值 (无论该值是以大写还是小写字母指定)，那么此方法将返回 true。

对于由前一个节点或外部应用程序设置的此对话框运行时上下文：

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

对话节点或响应条件：

$toppings_array.containsIgnoreCase('HAM')

结果: true，因为数组包含元素 ham 并且忽略大小写。

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

如果 true JSONArray 明确包含指定的意向，并且该意向的置信度分数等于或高于指定的最小分数，那么此方法会返回 intents。 您可以选择指定一个数字，以指示该意向必须包含在数组中排名前几位（该数字）元素内。 如果指定负数，那么将忽略 top_n 参数。

如果指定的意向不在数组中，并且其置信度分数低于最小置信度分数，或者该意向的数组索引低于指定的索引位置，那么会返回 false。

服务会自动生成 intents 数组，其中列出每当提交用户输入时，服务都会在输入中检测到的意向。 该数组会按置信度从高到低列出服务检测到的所有意向。

可以在节点条件中使用此方法，这样不仅可以检查是否存在意向，还可以设置置信度分数阈值，必须达到此阈值，才会处理节点并返回其响应。

例如，如果要在仅当满足以下条件时才触发对话节点，请在节点条件中使用以下表达式：

• #General_Ending 意向存在。
• #General_Ending 意向的信任度得分超过80%。
• #General_Ending 意向是意向数组中排名前 2 位的意向之一。

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

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

通过将每个数组元素值与指定的值进行比较来过滤数组。 此方法类似于集合投影。 集合投影返回基于数组元素名称/值对中的名称过滤的数组。 filter 方法返回基于数组元素名称/值对中的值过滤的数组。

过滤表达式由以下值组成：

• temp：对每个数组元素求值时临时使用的变量的名称。 例如，city。

• property：要与 comparison_value 进行比较的元素属性。 将 property 指定为在第一个参数中命名的临时变量的属性。 请使用语法：temp.property。 例如，如果 latitude 是数组中名称/值对的有效元素名称，请将 property 指定为 city.latitude。

• operator：要用于将属性值与 comparison_value 进行比较的运算符。

  支持的运算符如下：

  支持的过滤器运算符

  运算符	描述
  ==	等于
  >	大于
  <	小于
  >=	大于或等于
  <=	小于或等于
  !=	不等于

• comparison_value：要与每个数组元素属性值进行比较的值。 要指定可以根据用户输入变化的值，请将上下文变量或实体用作值。 如果您指定了一个可变的值，请添加逻辑以确保 comparison_value 值在评估时有效，否则将发生错误。

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

此方法用于返回 JSONArray 中的输入索引。

对于由前一个节点或外部应用程序设置的此对话框运行时上下文：

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

对话节点或响应条件：

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

结果： True 因为嵌套数组包含 作为值。one

响应：

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

JSONArray.getRandomItem()

此方法用于返回输入 JSONArray 中的随机项。

对于以下对话运行时上下文：

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

对话节点输出：

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

结果: "ham is a great choice!"，"onion is a great choice!" 或 "olives is a great choice!"

生成的输出文本是随机选择的。

JSONArray.indexOf(value)

此方法返回数组中与指定为参数的值相匹配的元素的下标号，如果在数组中找不到该值，那么会返回 -1。 该值可以是字符串 ("School")，整数 (8) 或双精度 (9.1)。该值必须完全匹配并且区分大小写。

例如，以下上下文变量包含数组：

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

以下表达式可用于确定在其中指定值的数组下标：

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

例如，要获取意向数组中某个元素的下标，此方法很有用。 您可以将 indexOf 方法应用于在每次对用户输入求值时生成的意向数组，以确定特定意向的数组下标号。

intents.indexOf("General_Greetings")

如果您想知道特定意图的置信度得分，可以将前面的表达式作为 index值传递给表达式，语法如下 intents[index].confidence。 例如：

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

JSONArray.join(String delimiter)

此方法用于将此数组中的所有值连接成一个字符串。 数值转换为字符串，并以输入分隔符分隔。

对于以下对话运行时上下文：

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

对话节点输出：

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

结果：

This is the array: onion;olives;ham;

如果用户输入中提到了多个配料，而您定义了一个名为 @toppings 的实体，它可以识别提到的配料，那么您可以在响应中使用以下表达式列出提到的配料：

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

如果定义将多个值存储在 JSON 数组中的变量，那么可以从该数组返回值的子集。 使用 join() 方法来正确设置它们的格式。

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

此方法从数组中的每个项抽取信息，并构建根据您指定的模板进行格式化的新数组。 模板可以是字符串，JSON 对象或数组。 此方法根据模板的类型返回字符串数组，对象数组或数组数组。

此方法对于将信息格式化为可作为对话节点输出的一部分返回的字符串，或者对于将数据转换为其他结构以便可将其与外部 API 配合使用非常有用。

在模板中，可以使用以下语法来引用源数组中的值，其中 {property} 表示源数组中属性的名称。

%e.{property}%

例如，假设助手将包含飞行详细信息的数组存储在上下文变量中。 存储的数据可能如下所示:

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

要构建以用户可读形式描述这些飞行的字符串数组，可以使用以下表达式:

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

此表达式将返回以下字符串数组: ["Flight AZ1040 to FCO","Flight DL1710 to LAX","Flight VS4379 to LHR"]。

可选的 retainDataType 参数指定方法是否应保留返回数组中所有输入值的数据类型。 如果 retainDataType 设置为 false 或省略，那么在某些情况下，输入数组中的字符串可能会转换为返回数组中的数字。 例如，如果输入数组中的所选值为 "1"，"2" 和 "3"，那么返回的数组可能为 [ 1, 2, 3 ]。 要避免意外的类型转换，请为此参数指定 true。

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

此方法用于从 JSONArray 除去索引位置中的元素，并返回更新后的 JSONArray。

对于以下对话运行时上下文：

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

进行以下更新：

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

结果：

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

JSONArray.removeValue(object)

此方法用于从 JSONArray 中除去第一次出现的值，并返回更新后的 JSONArray。

对于以下对话运行时上下文：

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

进行以下更新：

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

结果：

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

JSONArray.set(Integer index, Object value)

此方法用于将 JSONArray 的输入索引设置为输入值，并返回修改后的 JSONArray。

对于以下对话运行时上下文：

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

对话节点输出：

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

结果：

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

JSONArray.size()

此方法用于以整数形式返回 JSONArray 的大小。

对于以下对话运行时上下文：

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

进行以下更新：

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

结果：

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

JSONArray split(String regexp)

此方法用于通过输入正则表达式来拆分输入字符串。 结果为字符串的 JSONArray。

对于以下输入：

"bananas;apples;pears"

以下语法：

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

将生成以下输出：

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

com.google.gson.JsonArray 支持

除了内置方法外，还可以使用 com.google.gson.JsonArray 类的标准方法。

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

.after(String date or time)

确定日期/时间值是否晚于 date/time 自变量。

.before(String date or time)

确定日期/时间值是否早于 date/time 自变量。

例如：

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

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

• 如果您比较不同的项目，例如 time vs. date、date vs. time 和 time vs. date and time，该方法将返回false，并在响应JSON日志 output.log_messages 中打印异常。

  例如，@sys-date.before(@sys-time)。

• 如果您比较 date and time vs. time，该方法会忽略日期，只比较时间。

now(String timezone)

返回 yyyy-MM-dd HH:mm:ss 格式的当前日期和时间的字符串。 (可选) 指定 timezone 值以获取特定时区的当前日期和时间，返回格式为 yyyy-MM-dd HH:mm:ss 'GMT'XXX 的字符串。

• 静态函数。
• 可以对此函数返回的日期/时间值调用其他日期/时间方法，并且可以将其作为这些方法的自变量传递。
• 用户界面会自动为您创建一个 $timezone 上下文变量，以便您在“试试看”面板中进行测试时返回正确的时间。 如果未传递时区，那么将使用 UI 自动设置的时区。 在 UI 外部，GMT 用作时区。 要了解用于指定时区的语法，请参阅 系统实体支持的时区。

使用 now() 的示例首先检查在助手以特定于上午的问候语进行响应之前是否为上午。

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

使用now()函数与时区返回当前时间（英国）的示例：

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

您可以将硬编码的时区值替换为上下文变量，以便根据传递给表达式的时区动态更改时间。 例如：<? now('$myzone') ?>。 $myzone 上下文变量可以在一个交谈中设置为 'Australia/Sydney'，并在另一个交谈中设置为 'Mexico/BajaNorte'。

.reformatDateTime(String format)

将日期和时间字符串格式设置为用户输出的所需格式。

根据指定格式返回已设置格式的字符串：

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

要返回星期几：

• EEEE 表示星期二
• E 表示 Tue
• u 用于日期索引（1 = 星期一，……，7 = 星期日）

例如，此上下文变量定义会创建 $time 变量，用于将值 17:30:00 保存为 5:30 PM。

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

格式遵循 Java SimpleDateFormat 规则。

注意：当您尝试仅格式化时间时，日期会被视为 1970-01-01。

.sameMoment(String date/time)

• 确定日期/时间值是否等于 date/time 自变量。

.sameOrAfter(String date/time)

• 确定日期/时间值是否晚于或等于 date/time 自变量。
• 类似于 .after()。

.sameOrBefore(String date/time)

• 确定日期/时间值是否早于或等于 date/time 自变量。

today()

返回 yyyy-MM-dd 格式的当前日期的字符串。

• 静态函数。
• 可以对此函数返回的日期值调用其他日期方法，并且可以将其作为这些方法的自变量传递。
• 如果设置了上下文变量 $timezone，那么此函数会返回客户机时区中的日期。 否则，将使用 GMT 时区。

输出字段中使用了 today() 的对话节点示例：

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

结果： Today's date is 2018-03-09.

使用时间范围

要根据今天的日期是否位于特定时间范围内来显示响应，可以使用与时间相关的方法的组合。 例如，如果您在每年的节日期间运行特殊报价，那么可以检查今天的日期是否位于今年的 11 月 25 日与 12 月 24 日之间。 首先，将相关日期定义为上下文变量。

在以下开始和结束日期上下文变量表达式中，日期是通过将当前年份的派生值与硬编码的月份和日期值连接起来构建的。

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

在响应条件中，可以指示仅在当前日期位于定义为上下文变量的开始日期和结束日期之间时，才显示响应。

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

java.util.Date 支持

除了内置方法外，还可以使用 java.util.Date 类的标准方法。

要获取从今天起一周之后的日期，可以使用以下语法。

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

该表达式首先获取自1970年1月1日00:00:00协调世界时以来的当前日期（以毫秒为单位）。 此表达式还会计算 7 天的毫秒数。 （(24*60*60*1000L) 表示一天的毫秒数。） 然后，将当前日期加上 7 天。 结果就是从今天起一周之后的完整日期。 例如，Fri Jan 26 16:30:37 UTC 2018。 时间采用全球标准时区。 您始终可以将 7 更改为可以传入的变量（例如，$number_of_days）。 在计算表达式之前，请确保其值已设置。

如果您想将日期与服务生成的其他日期进行比较，则必须重新设置日期格式。 系统实体 (@sys-date) 和其他内置方法 (now()) 会将日期转换为 yyyy-MM-dd 格式。

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

重新格式化日期后，结果为 2018-01-26。 现在，您可以在响应条件中使用 @sys-date.after($week_from_today) 这样的表达式，将用户输入的日期与上下文变量中保存的日期进行比较。

以下表达式计算从此刻起 3 小时之后的时间。

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

(60*60*1000L) 值表示一小时的毫秒数。 此表达式将当前时间加上 3 小时。 然后，它从协调世界时区减去5小时，重新计算出东部标准时间时区的时间。 此表达式还会重新设置日期值的格式，以包含小时和分钟以及“上午”或“下午”。

toDouble()

将对象或字段转换为 Double 数字类型。 可以对任何对象或字段调用此方法。 如果转换失败，会返回 null。

toInt()

将对象或字段转换为 Integer 数字类型。 可以对任何对象或字段调用此方法。 如果转换失败，会返回 null。

toLong()

将对象或字段转换为 Long 数字类型。 可以对任何对象或字段调用此方法。 如果转换失败，会返回 null。

如果在 SpEL 表达式中指定了长整型数字类型，那么必须在该数字后附加 L 进行标识。 例如，5000000000L。 对于任何不适合 32 位整数类型的数字，此语法都是必需的。 例如，大于2^31（2,147,483,648）或小于 -2 (-2 的数字被视为长数字类型。 长整型数字类型的最小值为 -2^63，最大值为 2^63-1（或 9,223,372,036,854,775,807）。

如果您需要判断一个数字是否太长而无法识别，请使用以下表达式检查数字中是否包含超过18个整数：

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

如果您需要处理超过18个整数的数字，请考虑使用模式实体（使用正则表达式，例如 \d{20} ）来处理它们，而不是使用 @sys-number。

标准数学

使用 SpEL 表达式可定义标准数学公式，其中运算符使用以下符号来表示：

例如，在对话节点响应中，您可以添加一个上下文变量，用于捕获用户输入（ @sys-number ）中指定的数字，并将其保存为 $your_number。 然后，可以将以下文本添加为文本响应：

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

如果用户指定 10，那么生成的文本响应类似于以下内容：

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.

Java 数字支持

java.lang.Math()

执行基本数字运算。

您可以使用类方法:

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

有关更多信息，请参阅 java.lang.Math 参考文档。

java.util.Random()

返回一个随机数。 可以使用以下其中一个语法选项：

• 要返回一个随机的布尔值（true或false），请使用 <?new Random().nextBoolean()?>。
• 要返回一个介于0（含）和1（不含）之间的随机双数，请使用 <?new Random().nextDouble()?>。
• 要返回一个介于0（含）和您指定的数字之间的随机整数，请使用 <?new Random().nextInt(n)?>，其中n是您想要的数字范围的顶部+1。 例如，如果您想返回一个介于0到10之间的随机数，请指定 <?new Random().nextInt(11)?>。
• 要返回整数值范围（-2147483648到2147483648）中的随机整数，请使用 <?new Random().nextInt()?>。

例如，可以创建由 #random_number 意向触发的对话节点。 第一个响应条件可能类似于：

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

有关其他方法的信息，请参阅 java.util.Random 参考文档。

还可以使用以下类的标准方法：

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

JSONObject.clear()

此方法用于清除 JSON 对象中的所有值并返回 null。

例如，您希望清除 $user 上下文变量中的当前值。

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

在输出中使用以下表达式来定义一个字段，用于清除其值的对象。

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

如果引用$user上下文变量，则仅返回 {}。

可以在 API clear() 调用主体中的 context 或 output JSON 对象上使用 /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)

如果复杂 JSONObject 具有输入名称的属性，那么此方法会返回 true。

对于以下对话运行时上下文：

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

对话节点输出：

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

结果：条件为 true，因为用户对象包含属性 first_name。

JSONObject.remove(String)

此方法用于从输入 JSONObject 中除去名称的属性。 此方法返回的 JSONElement 是要除去的 JSONElement。

对于以下对话运行时上下文：

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

对话节点输出：

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

结果：

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

com.google.gson.JsonObject 支持

除了内置方法外，还支持 com.google.gson.JsonObject 类的一些标准方法。

String.append(Object)

此方法用于将输入对象作为字符串附加到字符串，并返回修改后的字符串。

对于以下对话运行时上下文：

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

以下语法：

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

将生成以下输出：

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

String.contains(String)

如果字符串包含输入子字符串，那么此方法会返回 true。

输入： Yes, I'd like to go.

以下语法：

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

结果：条件为 true。

String.endsWith(String)

如果字符串以输入子字符串结尾，那么此方法会返回 true。

对于以下输入：

"What is your name?".

以下语法：

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

结果：条件为 true。

String.equals(字符串)

如果指定的字符串与输入字符串完全相同，那么此方法将返回 true。

输入:“是”

以下语法：

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

结果：条件为 true。

如果输入为 Yes.，那么结果为 false，因为用户包含句点，并且表达式只需要精确文本 Yes 而没有任何标点符号。

String.equalsIgnoreCase(String)

如果指定的字符串等于输入字符串 (无论字母的大小写是否匹配)，那么此方法将返回 true。

输入: "yes"

以下语法：

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

结果：条件为 true。

如果输入为 Yes.，那么结果为 false，因为用户包含句点，并且表达式仅期望文本 Yes(大写或小写字母)，而没有任何标点符号。

String.extract(String regexp, Integer groupIndex)

此方法会返回输入中与指定的正则表达式组模式相匹配的字符串。 如果找不到匹配项，那么将返回空字符串。

此方法旨在抽取不同正则表达式模式组的匹配项，而不是抽取单个正则表达式模式的不同匹配项。 要查找不同的匹配项，请参阅 getMatch 方法。

在此示例中，上下文变量将保存与指定的正则表达式模式组相匹配的字符串。 在表达式中，定义了两个正则表达式模式组，每个组都用括号括起。 固有的第三组由两组组成。 这是第一个 groupIndex 正则表达式组；它与包含数字组和文本组的字符串匹配。 第二个正则表达式组 (groupIndex 1) 与第一次出现的数字组相匹配。 第三个组 (groupIndex 2) 与数字组后第一次出现的文本组相匹配。

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

在 JSON 中指定正则表达式时，必须提供两个反斜杠 (\)。如果在节点响应中指定此表达式，那么仅需要一个反斜杠。 例如：

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

输入：

"Hello 123 this is 456".

结果：

• n=0 时，值为 123 this。
• n=1 时，值为 123。
• n=2 时，值为 this。

String.find(String regexp)

如果字符串的任何分段与输入正则表达式匹配，那么此方法会返回 true。 你可以对JSONArray或JSONObject元素调用此方法，它会在进行比较之前将数组或对象转换为字符串。

对于以下输入：

"Hello 123456".

以下语法：

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

结果：条件为 true，因为输入文本的数字部分与正则表达式 ^[^\d]*[\d]{6}[^\d]*$ 匹配。

String.getMatch(String regexp, Integer matchIndex)

此方法会返回输入中与指定的正则表达式模式的出现相匹配的字符串。 如果找不到匹配项，那么此方法将返回空字符串。

找到匹配项时，会将其添加到您可以视为匹配项数组的内容。 如果要返回第三个匹配项，因为数组元素计数从 0 开始，因此请为 matchIndex 值指定 2。 例如，如果输入的文本字符串包含与指定模式匹配的三个词，那么只能通过指定其索引值来返回第一个、第二个或第三个匹配项。

在以下表达式中，您将在输入中查找一组数字。 此表达式将第二个模式匹配字符串保存到 $second_number 上下文变量中，因为指定了索引值 1。

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

如果以 JSON 语法指定表达式，那么必须提供两个反斜杠 (\)。如果在节点响应中指定表达式，那么仅需要一个反斜杠。

例如：

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

• 用户输入：

  "hello 123 i said 456 and 8910".
  

• 结果： 456

在这个例子中，表达式在输入中寻找第三个文本块。

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

对于相同的用户输入，此表达式会返回 and。

String.isEmpty()

如果字符串为空字符串，但不是 null，那么此方法会返回 true。

对于以下对话运行时上下文：

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

以下语法：

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

结果：条件为 true。

String.length()

此方法用于返回字符串的字符长度。

对于以下输入：

"Hello"

以下语法：

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

将生成以下输出：

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

String.matches(String regexp)

如果字符串与输入正则表达式匹配，那么此方法会返回 true。

对于以下输入：

"Hello".

以下语法：

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

结果：条件为 true，因为输入文本与正则表达式 \^Hello\$ 匹配。

String.startsWith(String)

如果字符串以输入子字符串开头，那么此方法会返回 true。

对于以下输入：

"What is your name?".

以下语法：

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

结果：条件为 true。

String.substring(Integer beginIndex, Integer endIndex)

这种方法获取一个子字符串，其中包含字符 beginIndex，最后一个字符设置为索引，位于 endIndex 之前。 不包括 endIndex 字符。

对于以下对话运行时上下文：

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

以下语法：

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

将生成以下输出：

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

String.toJson()

此方法解析包含 JSON 数据的字符串并返回 JSON 对象或数组，如以下示例中所示:

${json_var}.toJson()

如果上下文变量 ${json_var} 包含以下字符串:

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

toJson() 方法返回以下对象:

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

String.toLowerCase()

此方法将原始字符串转换为小写字母。

对于以下输入：

"This is A DOG!"

以下语法：

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

将生成以下输出：

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

String.toUpperCase()

此方法返回转换为大写字母的原始字符串。

对于以下输入：

"hi there".

以下语法：

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

将生成以下输出：

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

String.trim()

此方法用于删除字符串开头和结尾的所有空格，并返回修改后的字符串。

对于以下对话运行时上下文：

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

以下语法：

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

将生成以下输出：

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

java.lang.String 支持

除了内置方法外，还可以使用 java.lang.String 类的标准方法。

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

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