支持的映射函数
ADD
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
ADD |
将指定的数字与现有数字相加。 | ADD(value) |
要相加的数字。 | 两个数字的总和。 |
示例:将两个整数相加
示例数据:$var1$ = 15
用法:$var1$.ADD(5)
输出:20
AND
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
AND |
对指定的布尔值执行逻辑 AND 运算。 | AND(value) |
布尔值。 | 布尔值。 |
示例:查找布尔值表达式的 AND 值
示例数据:$var1$ = TRUE
用法:$var1$.AND(TRUE)
输出:TRUE
APPEND_ALL
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
APPEND_ALL |
将所有指定值附加到数组。 | APPEND_ALL(value1, value2, ...) |
要附加的值。 要附加的值的数据类型应与数组的数据类型相匹配。例如,对于 |
带有附加值的数组。 |
示例 1:向整数数组附加值
示例数据:$var1$ = {3,6,8,1}
用法:$var1$.APPEND_ALL(7,9,15)
输出:{3,6,8,1,7,9,15}
示例 2:向布尔值数组附加值
示例数据:$var1$ = {True,False,True}
用法:$var1$.APPEND_ALL(False,True)
False
和 True
附加到 var1。输出:{True,False,True,False,True}
示例 3:向字符串数组附加值
示例数据:$var1$ = {"Hello","Apigee"}
用法:$var1$.APPEND_ALL("Integrations","Test")
Integrations
和 Test
附加到 var1。输出:{"Hello","Apigee","Integrations","Test"}
APPEND_ELEMENT
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
APPEND_ELEMENT |
将元素附加到 JSON 数组。 | APPEND_ELEMENT(value) |
要附加的值。 | 附加了元素的 JSON 数组。 |
示例:将元素附加到 JSON 数组
示例数据:$var1$ = ["first", "second", "third", "fourth"]
用法:$var1$.APPEND_ELEMENT("fifth")
fifth
附加到 var1
。
输出:["first", "second", "third", "fourth", "fifth"]
。
APPEND
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
APPEND |
将指定值附加到数组。 | APPEND(value) |
要附加的值。 要附加的值的数据类型应与数组的数据类型相匹配。例如,对于 |
带有附加值的数组。 |
示例 1:向整数数组附加值
示例数据:$var1$ = {3,6,8,1}
用法:$var1$.APPEND(7)
输出:{3,6,8,1,7}
示例 2:向布尔值数组附加值。
示例数据:$var1$ = {True,False,True}
用法:$var1$.APPEND(True)
输出:{True,False,True,True}
示例 3:向字符串数组附加值
示例数据:$var1$ = {"Hello","Apigee"}
用法:$var1$.APPEND("Integrations")
Integrations
附加到 var1。输出:{"Hello","Apigee","Integrations"}
AVG
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
AVG |
计算数组中所有值的数值平均值。 | AVG() |
不适用 | 数组中所有值的平均值。返回值的类型为 Double 。 |
示例 1:计算整数数组中所有值的平均值
示例数据:$var1$ = {2,4,9,3}
用法:$var1$.AVG()
输出:4.5
示例 2:计算双精度型数组中所有值的平均值
示例数据:$var1$ = {2.0,6.1,3.9}
用法:$var1$.AVG()
输出:4.0
CEIL
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
CEIL |
计算大于或等于给定输入的最小整数。 | CEIL() |
不适用 | 它是一个整数。 |
示例:查找数字的上限。
示例数据:$var1$ = {3.4}
用法:$var1$.CEIL()
输出:4
CONCAT
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
CONCAT |
将指定字符连接至现有字符串。 | CONCAT(value) |
要连接的字符串。 | 连接的字符串。 |
示例:将一串字符连接到现有字符串
示例数据:$var1$ = "HelloApigee"
用法:$var1$.CONCAT("Integrations")
Integrations
连接到 var1。输出:HelloApigeeIntegrations
CONTAINS
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
CONTAINS |
检查指定字符串或字符串数组中是否存在指定值。 | CONTAINS(value) |
要搜索的值。 | 一个布尔值。如果找到匹配项,则返回 TRUE,否则返回 FALSE。 |
示例:检查字符串中一系列字符的实例
示例数据:$var1$ = "Hello Apigee Integrations"
用法:$var1$.CONTAINS("xyz")
xyz
的出现次数。输出:FALSE
DECODE_BASE64_STRING
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
DECODE_BASE64_STRING |
将 base64 字符串解码为 UTF-8 字符集。 | DECODE_BASE64_STRING() |
不适用 | 解码的 UTF-8 字符串。 |
示例:对 base64 字符串进行解码
示例数据:$var1$ = "SGVsbG8gSW50ZWdyYXRpb24h"
用法:$var1$.DECODE_BASE64_STRING()
输出:Hello Integration!
DIVIDE
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
DIVIDE |
将现有数字除以指定数字。 | DIVIDE(value) |
除以数字(除数)。 | 除法运算的商。 |
示例:用一个整数除以另一个整数
示例数据:$var1$ = 16
用法:$var1$.DIVIDE(3)
输出:5
EQUALS
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
EQUALS |
将指定值与现有值进行比较。 | EQUALS(value) |
要比较的值。 | 一个布尔值。如果指定的值与现有值匹配,则返回 TRUE,否则返回 FALSE。 |
示例 1:比较两个字符串
示例数据:$var1$ = "Apigee Integrations"
用法:$var1$.EQUALS("Apigee Integrations")
输出:TRUE
示例 2:比较两个整数
示例数据:$var1$ = 34
用法:$var1$.EQUALS(23)
输出:FALSE
EQUALS_IGNORE_CASE
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
EQUALS_IGNORE_CASE |
将指定值与现有值进行比较。 | EQUALS_IGNORE_CASE(value) |
要比较的值。 | 一个布尔值。如果指定的值与现有值匹配(忽略大小写),则返回 TRUE,否则返回 FALSE。 |
示例:比较两个字符串
示例数据:$var1$ = "Apigee Integrations"
用法:$var1$.EQUALS_IGNORE_CASE("apigee integrations")
apigee integrations
。
输出:TRUE
EPOCH_TO_HUMAN_READABLE_TIME
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
EPOCH_TO_HUMAN_READABLE_TIME |
将 Unix 纪元时间(以毫秒为单位)转换为人类可读的时间格式。 | EPOCH_TO_HUMAN_READABLE_TIME (value, value) |
此函数接受以下参数:
|
转换为人类可读格式的时间戳。 |
示例:将 Unix 纪元时间(以毫秒为单位)转换为人类可读的格式。
样本数据:$var1$ = 1667494335011
用法 1:$var1$.EPOCH_TO_HUMAN_READABLE_TIME("EEE, d MMM yyyy HH:mm:ss z","UTC")
将 var1 转换为人类可读的时间戳,格式为 EEE, d MMM yyyy HH:mm:ss z,时区为 UTC。
输出:Thu, 3 Nov 2022 16:52:15 UTC
用法 2:$var1$.EPOCH_TO_HUMAN_READABLE_TIME("EEE, yy-MM-dd HH:mm:ss,SSS","GMT")
将 var1 转换为人类可读的时间戳,格式为 EEE, yy-MM-dd HH:mm:ss,SSS,时区为 GMT。
输出:Thu, 22-11-03 16:52:15,011
用法 3:$var1$.EPOCH_TO_HUMAN_READABLE_TIME("EEE, yy-MM-dd HH:mm:ss,SSS ZZZZ","America/Los_Angeles")
将 var1 转换为人类可读的时间戳,格式为 EEE, yy-MM-dd HH:mm:ss,SSS ZZZZ,时区为 America/Los_Angeles 时区。
输出:Thu, 22-11-03 09:52:15,011 GMT-07:00
EXPONENT
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
EXPONENT |
计算现有数字的指定次幂的值。 | EXPONENT(value) |
幂值。 | 数字的指定次幂的值。 |
示例:求出整数的 3 次幂的值
示例数据:$var1$ = 5
用法:$var1$.EXPONENT(3)
输出:125
FILTER
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
FILTER |
过滤满足给定过滤条件的数组元素。 请注意,过滤条件的计算结果必须为 TRUE 或 FALSE。 过滤条件包括应用于当前数组迭代元素的一个或多个转换函数。 |
FILTER(~objn -> Variable or Value)
其中 ~objn 表示要为其应用转换函数的当前数组元素。默认情况下,n 的值从 1 开始。
对于具有架构的 JSON 数组,您可以在当前数组元素后面使用点 (.) 表示法直接访问该数组元素的嵌套属性。例如 | 计算结果为 TRUE 或 FALSE 的过滤条件。 | 与过滤条件匹配的元素数组。 |
示例 1:过滤字符串数组。
示例数据:
$var1$ = {
"sara@example.com",
"bola@example.com",
"222larabrown@gmail.com",
"dana@examplepetstore.com",
"cloudysanfrancisco@gmail.com"}
用法:$var1$.FILTER(~obj1-> ~obj1.CONTAINS("@gmail.com"))
在 var1 中过滤包含 @gmail.com 的字符串元素。
输出:
{"222larabrown@gmail.com","cloudysanfrancisco@gmail.com"}
示例 2:过滤 JSON 数组。
示例数据:
$var1$ = { "citynames": [ { "city": "Abbeville", "state": "Louisiana" }, { "city": "Aberdeen", "state": "Maryland" }, { "city": "Benicia", "state": "California" }, { "city": "Chehalis", "state": "Washington" }, { "city": "Aberdeen", "state": "Washington" }, { "city": "Aberdeen", "state": "Mississippi" }, { "city": "Cheektowaga", "state": "New York" } ] }
用法:
var1.citynames .FILTER(~obj1-> ~obj1 .GET_PROPERTY("city") .EQUALS("Aberdeen") )
在 var1 中过滤含有 Aberdeen 城市的元素。
输出:
[{ "city": "Aberdeen", "state": "Maryland" }, { "city": "Aberdeen", "state": "Washington" }, { "city": "Aberdeen", "state": "Mississippi" }]
示例 3:过滤嵌套的 JSON 数组。
示例数据:
$var1$ = { "products": [ { "PA": "Integrations", "users": [ { "name": "Ariel", "role": [ "editor", "approver" ] }, { "name": "Dana", "role": [ "admin", "deployer" ] }, { "name": "Lee", "role": [ "viewer" ] } ] }, { "PA": "Apigee", "users": [ { "name": "Mahan", "role": [ "editor", "admin", "deployer" ] }, { "name": "Quinn", "role": [ "invoker" ] } ] }, { "PA": "Connectors", "users": [ { "name": "Kiran", "role": [ "invoker", "admin", "deployer" ] }, { "name": "Sasha", "role": [ "admin" ] } ] } ] }
用法:
var1.products .FOR_EACH(~obj1 -> ~obj1 .SET_PROPERTY( ~obj1 .GET_PROPERTY("users") .FILTER(~obj2 -> ~obj2 .GET_PROPERTY("role") .TO_STRING() .CONTAINS("admin") ) , "users" ) )
过滤 var1 的 users 中包含 admin 的元素。
输出:
[{ "PA": "Integrations", "users": [{ "name": "Dana", "role": ["admin", "deployer"] }] }, { "PA": "Apigee", "users": [{ "name": "Mahan", "role": ["editor", "admin", "deployer"] }] }, { "PA": "Connectors", "users": [{ "name": "Kiran", "role": ["invoker", "admin", "deployer"] }, { "name": "Sasha", "role": ["admin"] }] }]
FLATTEN
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
FLATTEN |
以递归方式展平 JSON 数组,以创建新的一维数组。 | FLATTEN() |
不适用 | 展平的 JSON 数组。 |
示例:展平嵌套的 JSON 数组
示例数据:$var1$ = [[1, 2], [3, 4]]
用法:$var1$.FLATTEN()
输出:[1, 2, 3 ,4]
FLOOR
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
FLOOR |
计算小于或等于提供的输入的最大整数。 | FLOOR() |
不适用 | 它是一个整数。 |
示例:
示例数据:$var1$ = {27.6}
用法:$var1$.FLOOR()
输出:27
FOR_EACH
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
FOR_EACH |
对数组中的每个元素应用一个或多个转换函数。 | FOR_EACH(~objn -> Variable or Value)
其中 ~objn 表示您要为其应用转换函数的当前数组迭代元素。默认情况下,n 的值从 1 开始。 对于具有架构的 JSON 数组,您可以在当前数组元素后面使用点 (.) 表示法直接访问该数组元素的嵌套属性。查看示例。 |
转换函数。 | 元素的数组。 |
示例 1:将值连接到字符串数组的所有元素。
示例数据:$var1$ = {"Alex","Bola","Charlie","Dana","Hao"}
用法:$var1$.FOR_EACH(~obj1-> ~obj1.CONCAT("@gmail.com"))
将值 @gmail.com 连接到 var1。
输出:
{
"Alex@gmail.com",
"Bola@gmail.com",
"Charlie@gmail.com",
"Dana@gmail.com",
"Hao@gmail.com"
}
示例 2:给定一个没有架构的 JSON 数组,向所有 JSON 对象添加属性。
示例数据:
$var1$ = { "employeeDetails": [ { "name": "Alex" }, { "name": "Bola" }, { "name": "Charlie" } ] }
用法:$var1$.employeeDetails.FOR_EACH(~obj1-> ~obj1.SET_PROPERTY("Google","company"))
向 var1 添加属性 company:Google。
输出结果:
[ { "name": "Alex", "company": "Google" }, { "name": "Bola", "company": "Google" }, { "name": "Charlie", "company": "Google" } ]
示例 3:给定一个不含架构的 JSON 数组,向所有嵌套的 JSON 对象添加属性。
示例数据:
$var1$ = { "employeeDetails": [ { "name": "Alex", "details": [ { "age": "27", "address": "1800 Amphibious Blvd. Mountain View, CA 94045" } ] }, { "name": "Bob", "details": [ { "age": "25", "address": "8 Rue du Nom Fictif 341 Paris" } ] } ], "deptDetails": [ { "id1": "HR" }, { "id2": "Finance" }, { "id3": "Sales" } ] }
用法:$var1$.employeeDetails.FOR_EACH(~obj1-> ~obj1.GET_PROPERTY("details").FOR_EACH(~obj2-> ~obj2.SET_PROPERTY("dd/mm/yyyy", "dob")))
向 var1 中的details 添加占位符属性 dob: "dd/mm/yyyy"。
输出结果:
[ [ { "age": "27", "address": "1800 Amphibious Blvd. Mountain View, CA 94045", "dob": "dd/mm/yyyy" } ], [ { "age": "25", "address": "8 Rue du Nom Fictif 341 Paris", "dob": "dd/mm/yyyy" } ] ]
示例 4:给定具有架构的 JSON 数组,连接 JSON 对象的嵌套属性。
示例数据:
$var1$ = {"citynames": [ { "city": "Abbeville", "info": { "pincode": 29620, "state": "South Carolina", "location" : { "lat" : "50.1055 N", "lon": "1.8368 E" } } }, { "city": "Aberdeen", "info": { "pincode": AB10, "state": "Scotland", "location" : { "lat" : "57.1499 N", "lon": "2.0938 W" } } }, { "city": "Benicia", "info": { "pincode": 94510, "state": "California", "location" : { "lat" : "38.0494 N", "lon": "122.1586 W" } } } ] }
用法:$var1$.citynames.FOR_EACH(~obj1-> ~obj1.city.CONCAT(",").CONCAT(~obj1.info.location.lat).CONCAT(",").CONCAT(~obj1.info.location.lon))
使用 var1 中的分隔符 (,) 连接 city 的嵌套属性。
输出结果:
[ "Abbeville,50.1055 N,1.8368 E", "Aberdeen,57.1499 N,2.0938 W", "Benicia,38.0494 N,122.1586 W" ]
示例 5:解析模板 JSON 中的 JSON 数组对象引用。
示例数据:
$var2$ = { "cityName": "$~obj1.city$", "latitude": "$~obj1.info.location.lat$", "longitude": "$~obj1.info.location.lon$" }
$var1$ = {"citynames": [ { "city": "Abbeville", "info": { "pincode": 29620, "state": "South Carolina", "location" : { "lat" : "50.1055 N", "lon": "1.8368 E" } } }, { "city": "Aberdeen", "info": { "pincode": AB10, "state": "Scotland", "location" : { "lat" : "57.1499 N", "lon": "2.0938 W" } } }, { "city": "Benicia", "info": { "pincode": 94510, "state": "California", "location" : { "lat" : "38.0494 N", "lon": "122.1586 W" } } } ] }
用法:$var1$.citynames.FOR_EACH(~obj1-> $var2$.RESOLVETEMPLATE())
解析 var2 中的 ~obj1
引用,其中 ~obj1
是 var1 的当前迭代元素。
输出结果:
[ { "cityName": "Abbeville", "latitude": "50.1055 N", "longitude": "1.8368 E", } { "cityName": "Aberdeen", "latitude": "57.1499 N", "longitude": "2.0938 W", } { "cityName": "Benicia", "latitude": "38.0494 N", "longitude": "122.1586 W", } ]
GET_ELEMENT
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GET_ELEMENT |
以 JSON 数组形式返回指定索引处的元素。 在数组中,第一个值在索引 0 处,最后一个值在索引 n-1 处,其中 n 是数组的大小。 | GET_ELEMENT(value) |
元素的索引值。 | 元素的值。 |
示例:获取 JSON 数组中元素的值
示例数据:$var1$ = ["first", "second", "third", "fourth"]
用法:$var1$.GET_ELEMENT(2)
2
处的元素。
输出:third
GET_PROPERTY
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GET_PROPERTY |
返回 JSON 对象中指定属性的值。 | GET_PROPERTY(value) |
属性名称。 | 属性的值。 |
示例:获取 JSON 对象中属性的值
示例数据:$var1$ = {"productId": 23,"productName": "radio"}
用法:$var1$.GET_PROPERTY("productId")
productId
属性的值。输出:23
GET
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GET |
返回数组中指定索引处的值。在数组中,第一个值在索引 0 处,最后一个值在索引 n-1 处,其中 n 是数组的大小。 | GET(value) |
整数类型的索引值。 | 数组中给定索引处的值。返回类型取决于数组的数据类型。例如,对于整数数组,此函数返回整数值。 |
示例 1:获取整数数组中某个索引处的值
示例数据:$var1$ = {11,6,7,2,15,8}
用法:$var1$.GET(3)
输出:2
示例 2:获取字符串数组中某个索引处的值
示例数据:$var1$ =
{"Hello", "Test", "Apigee", "Integrations", "API Trigger", "Cloud"}
用法:$var1$.GET(5)
输出:Cloud
GREATER_THAN_EQUAL_TO
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GREATER_THAN_EQUAL_TO |
检查整数是否大于或等于指定值。 | GREATER_THAN_EQUAL_TO(value) |
要检查的整数值。 | 一个布尔值。如果整数大于或等于指定值,则返回 TRUE,否则返回 FALSE。 |
示例:检查某个整数是否大于或等于指定值
示例数据:$var1$ = 35
用法:$var1$.GREATER_THAN_EQUAL_TO(15)
输出:TRUE
GREATER_THAN
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GREATER_THAN |
检查现有数字是否大于指定数字。 | GREATER_THAN(value) |
要检查的数字。 | 一个布尔值。如果现有数字大于指定值,则返回 TRUE,否则返回 FALSE。 |
示例:检查某个整数是否大于指定值
示例数据:$var1$ = 25
用法:$var1$.GREATER_THAN(27)
输出:FALSE
LENGTH
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
LENGTH |
计算字符串的长度。字符串的长度是字符串中的字符数。 | LENGTH() |
不适用 | 字符串的长度。 |
示例:计算字符串的长度
示例数据:$var1$ = "Hello Apigee Test"
用法:$var1$.LENGTH()
输出:17
LESS_THAN_EQUAL_TO
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
LESS_THAN_EQUAL_TO |
检查某个整数是否小于或等于指定值。 | LESS_THAN_EQUAL_TO(value) |
要检查的整数值。 | 一个布尔值。如果整数小于或等于指定值,则返回 TRUE,否则返回 FALSE。 |
示例:检查某个整数是否小于或等于指定值
示例数据:$var1$ = 35
用法:$var1$.LESS_THAN_EQUAL_TO(15)
输出:FALSE
LESS_THAN
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
LESS_THAN |
检查现有数字是否小于指定数字。 | LESS_THAN(value) |
要检查的数字。 | 一个布尔值。如果现有数字小于指定数字,则返回 TRUE,否则返回 FALSE。 |
示例:检查某个整数是否小于指定值
示例数据:$var1$ = 25
用法:$var1$.LESS_THAN(27)
27
。
输出:TRUE
MAX
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
MAX |
查找数组中的最大值。 | MAX() |
不适用 | 数组中的最大值。 |
示例 1:获取整数数组中的最大值
示例数据:$var1$ = {5,8,2,1}
用法:$var1$.MAX()
输出:8
示例 2:获取双精度型数组中的最大值
示例数据:$var1$ = {2.5,6.1,4.9}
用法:$var1$.MAX()
输出:6.1
MERGE
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
MERGE |
合并两个 JSON 变量(对象或数组)。如果同一个值同时存在于这两个变量中,该函数将移除重复值。 | MERGE(value) |
要合并的 JSON 值。 | JSON 对象或数组。 |
示例:合并两个 JSON 对象
示例数据:$var1$ = {"productId": 23}
用法:$var1$.MERGE({"productName":"radio"})
{"productName":"radio"}
与 var1 合并。输出:{"productId": 23,"productName": "radio"}
示例:合并两个 JSON 数组
示例数据:$var1$ = ["first", "second", "third"]
用法:$var1$.MERGE([4,5])
[4,5]
与 var1 合并。输出:["first", "second", "third",4,5]
MIN
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
MIN |
查找数组中的最小值。 | MIN() |
不适用 | 数组中的最小值。 |
示例 1:查找整数数组中的最小值
示例数据:$var1$ = {5,8,2,1}
用法:$var1$.MIN()
输出:1
示例 2:查找双精度型数组中的最小值
示例数据:$var1$ = {2.5,6.1,4.9}
用法:$var1$.MIN()
输出:2.5
MOD
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
MOD |
两个值相除,并返回除法运算的余数。 | MOD(value) |
除数的值。 | 除法运算的余数。 |
示例:查找除法运算的余数
示例数据:$var1$ = 90
用法:$var1$.MOD(3)
3
。
输出:0
MULTIPLY
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
MULTIPLY |
将现有数字乘以指定数字。 | MULTIPLY(value) |
要相乘的数字。 | 两个数字的乘积。 |
示例:求出两个整数的乘积
示例数据:$var1$ = 10
用法:$var1$.MULTIPLY(3)
输出:30
NAND
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
NAND |
对指定的布尔值执行逻辑 NAND 运算。 | NAND(value) |
布尔值。 | 布尔值。 |
示例:查找布尔值表达式的 NAND 值
示例数据:$var1$ = TRUE
用法:$var1$.NAND(TRUE)
输出:FALSE
NOR
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
NOR |
对指定的布尔值执行逻辑 NOR 运算。 | NOR(value) |
布尔值。 | 布尔值。 |
示例:查找布尔值表达式的 NOR 值
示例数据:$var1$ = FALSE
用法:$var1$.NOR(FALSE)
输出:TRUE
NOT
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
NOT |
返回布尔值的相反值。 | NOT() |
不适用 | 布尔值。 |
示例:查找布尔值的相反值
示例数据:$var1$ = FALSE
用法:$var1$.NOT()
输出:TRUE
OR
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
OR |
对指定的布尔值执行逻辑 OR 运算。 | OR(value) |
布尔值。 | 布尔值。 |
示例:查找布尔值表达式的 OR 值
示例数据:$var1$ = FALSE
用法:$var1$.OR(TRUE)
输出:TRUE
REMOVE
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
REMOVE |
从数组中移除指定的值。 | REMOVE(value) |
要移除的值。 | 移除指定值后更新的数组。 |
示例:从字符串数组中移除字符串
示例数据:$var1$ = {"Hello","Apigee","Integrations"}
用法:$var1$.REMOVE("Integrations")
Integrations
输出:{"Hello","Apigee"}
REMOVE_AT
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
REMOVE_AT |
从数组中移除指定索引位置的元素。 | REMOVE_AT(value) |
数组中的索引值。 | 移除指定元素后更新的数组。 |
示例:从字符串数组中移除元素
示例数据:$var1$ = {"Hello","Apigee","Integrations"}
用法:$var1$.REMOVE_AT(1)
输出:{"Hello","Integrations"}
REMOVE_PROPERTY
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
REMOVE_PROPERTY |
从 JSON 对象中移除属性。 | REMOVE_PROPERTY(value) |
属性名称。 | 移除了指定的属性及其相应值后的更新 JSON 对象。 |
示例:从 JSON 对象中移除属性。
示例数据:
$var1$ = { "name": "Alex", "address": { "street": "1800 Amphibious Blvd", "city": "Mountain View", "state": "CA", "pincode": "94045" } }
用法:$var1$.REMOVE_PROPERTY("address.street")
从 JSON 中移除 address.street 属性。
输出:
{ "name": "Alex", "address": { "city": "Mountain View", "state": "CA", "pincode": "94045" } }
REPLACE_ALL
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
REPLACE_ALL |
替换字符串中出现的所有子字符串。 | REPLACE_ALL(value, value) |
该函数采用下列参数:
|
使用替换值更新的字符串。 |
示例:将出现的所有子字符串替换为新值。
示例数据:$var1$ = "HelloApigee"
用法:$var1$.REPLACE_ALL("Apigee", "Google")
输出:HelloGoogle
RESOLVE_TEMPLATE
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
RESOLVE_TEMPLATE |
解析包含 $variable$ 引用的模板字符串中的引用。 | RESOLVE_TEMPLATE() |
无 | 带有引用变量值的已解析模板。 |
示例:解析包含 $variable$ 引用的模板 JSON 中的 JSON 引用。
示例数据:
$var1$ = { "name": "Alex", "address": "$var2$", "age": "25" }
$var2$ = { "street": "1800 Amphibious Blvd", "city": "Mountain View", "state": "CA", "pincode": "94045" }
用法:$var1$.RESOLVE_TEMPLATE()
解析 var1 中的 var2 变量引用。
输出:
{ "name": "Alex", "address": { "street": "1800 Amphibious Blvd", "city": "Mountain View", "state": "CA", "pincode": "94045" }, "age": "25" }
示例:解析包含 $variable$ 引用的模板字符串中的字符串引用。
示例数据:
$var1$ = Hello $var2$
$var2$ = World
用法:$var1$.RESOLVE_TEMPLATE()
解析 var1 中的 var2 变量引用。
输出:Hello World
ROUND
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
ROUND |
将数字舍入到最接近的整数。 | ROUND() |
不适用 | 它是一个整数。 |
示例:将数字舍入到最接近的整数
示例数据:$var1$ = 15.6
用法:$var1$.ROUND()
输出:16
SET
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 | |
---|---|---|---|---|---|
SET |
在指定索引位置更新字符串数组的值。 | SET(value,value) |
该函数采用下列参数:
|
更新的字符串数组。 |
示例:在索引位置更新字符串数组的值
示例数据:$var1$ = {"Hello","World","Integrations"}
用法:$var1$.SET(2,"Apigee")
输出:{"Hello","World","Apigee"}
SET_PROPERTY
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
SET_PROPERTY |
添加或更新 JSON 对象中的属性。 | SET_PROPERTY(value) |
属性名称和值。 | 包含新增属性或更新属性的 JSON 对象。 |
示例:向 JSON 对象添加属性
示例数据:$var1$ = {"productId":23}
用法:$var1$.SET_PROPERTY("radio","productName")
输出:{"productId":23,"productName":"radio"}
。
示例:向 JSON 对象添加嵌套属性
示例数据:$var1$ = {"productId":23}
用法:$var1$.SET_PROPERTY({"productName","radio"},"productDetails")
输出:{"productId":23,"productDetails":{"productName":"radio"}}
。
示例:更新 JSON 对象中的属性
示例数据:$var1$ = {"productId":23}
用法:$var1$.SET_PROPERTY("34","productId")
productId
属性。
输出:{"productId":34}
。
SIZE
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
SIZE |
计算数组中的元素数量。 | SIZE() |
不适用 | 数组中的元素总数。 |
示例 1:求出字符串数组的大小
示例数据:$var1$ = {"Hello", "Apigee", "Integrations"}
用法:$var1$.SIZE()
输出:3
示例 2:求出整数数组的大小
示例数据:$var1$ = {5,8,2,1,7}
用法:$var1$.SIZE()
输出:5
SPLIT
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
SPLIT |
根据指定的分隔符拆分字符串。 | SPLIT(value) |
用于拆分字符串的一个字符或一系列字符。 | 字符串数组。 |
示例 1:根据空格字符拆分字符串
示例数据:$var1$ = "Hello Apigee Integrations"
用法:$var1$.SPLIT(" ")
输出:{"Hello","Apigee","Integrations"}
示例 2:根据英文逗号拆分字符串
示例数据:$var1$ = "Test,Integrations"
用法:$var1$.SPLIT(",")
输出:{"Test","Integrations"}
SUBSTRING
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
SUBSTRING |
返回从起始索引(含)到结束索引(不含)的当前字符串的子字符串。 | SUBSTRING(value, value) |
该函数采用下列参数:
|
起始索引和结束索引之间的字符串。 |
示例:返回当前字符串的子字符串,从起始索引编号的字符开始,在结束索引编号的字符之前结束。
示例数据:$var1$ = "HelloApigee"
用法:$var1$.SUBSTRING(1, 5)
输出:ello
SUBTRACT
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
SUBTRACT |
从现有数字中减去指定的数字。 | SUBTRACT(value) |
要减去的数字。 | 两个数字之差。 |
示例:减去一个整数值
示例数据:$var1$ = 10
用法:$var1$.SUBTRACT(15)
输出:-5
SUM
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
SUM |
将数组中的所有值相加。 | SUM() |
不适用 | 数组中所有数字的总和。返回类型取决于数组的类型。例如,对于 Double 类型的数组,返回值类型是双精度值。 |
示例:将整数数组的所有值相加
示例数据:$var1$ = {5,8,2,1}
用法:$var1$.SUM()
输出:16
TO_BASE_64
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_BASE_64 |
使用 UTF-8 字符集将字符串编码为 base64 格式。 | TO_BASE_64() |
不适用 | 使用 base64 编码的字符串。 |
示例:将字符串编码为 base64 格式
示例数据:$var1$ = "Hello World!"
用法:$var1$.TO_BASE_64()
输出:SGVsbG8gV29ybGQh
TO_BOOLEAN_ARRAY
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_BOOLEAN_ARRAY |
将 JSON 数组转换为布尔值数组。 | TO_BOOLEAN_ARRAY() |
不适用 | 布尔值数组。 |
示例:将 JSON 数组转换为布尔值数组
示例数据:$var1$ = ["true", "false", "false"]
用法:$var1$.TO_BOOLEAN_ARRAY()
输出:{true, false, false}
TO_BOOLEAN
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_BOOLEAN |
将字符串转换为布尔值数据类型。 | TO_BOOLEAN() |
不适用 | 一个布尔值。如果字符串的值为 true 或 false,则此函数会返回相应的布尔值。 |
示例 1:获取字符串的布尔值
示例数据:$var1$ = "true"
用法:$var1$.TO_BOOLEAN()
输出:TRUE
示例 2:获取字符串的布尔值
示例数据:$var1$ = "FALSE"
用法:$var1$.TO_BOOLEAN()
输出:FALSE
TO_DOUBLE_ARRAY
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_DOUBLE_ARRAY |
将 JSON 数组转换为双精度浮点数数组。 | TO_DOUBLE_ARRAY() |
不适用 | 双精度浮点数数组。 |
示例:将 JSON 数组转换为双精度浮点数数组
示例数据:$var1$ = [1.3, 4.8, 7.9]
用法:$var1$.TO_DOUBLE_ARRAY()
输出:{1.3, 4.8, 7.9}
TO_DOUBLE
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_DOUBLE |
将字符串或整数转换为双精度浮点数。 | TO_DOUBLE() |
不适用 | 双精度型。 |
示例 1:将字符串转换为双精度浮点数
示例数据:$var1$ = "2.5"
用法:$var1$.TO_DOUBLE()
输出:2.5
示例 2:将整数转换为双精度浮点数
示例数据:$var1$ = 22
用法:$var1$.TO_DOUBLE()
输出:22.0
TO_INT_ARRAY
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_INT_ARRAY |
将 JSON 数组转换为整数数组。 | TO_INT_ARRAY() |
不适用 | 整数数组。 |
示例:将 JSON 数组转换为整数数组
示例数据:$var1$ = [3, 8, 9]
用法:$var1$.TO_INT_ARRAY()
输出:{3, 8, 9}
TO_INT
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_INT |
将字符串转换为整数。 | TO_INT() |
不适用 | 它是一个整数。 |
示例:将字符串转换为整数
示例数据:$var1$ = "35"
用法:$var1$.TO_INT()
输出:35
TO_JSON
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_JSON |
将当前值转换为 JSON 对象。 | TO_JSON() |
不适用 | JSON 对象。 |
示例:将字符串转换为 JSON
示例数据:$var1$ = "{product: "cake", id: 21, price: 5}"
用法:$var1$.TO_JSON()
输出:{product: "cake", id: 21, price: 5}
TO_LOWERCASE
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_LOWERCASE |
将字符串中的所有字符都转换为小写。 | TO_LOWERCASE() |
不适用 | 所有字符都是小写的字符串。 |
示例:将字符串转换为小写
示例数据:$var1$ = "Integrations TEST"
用法:$var1$.TO_LOWERCASE()
输出:integrations test
TO_SET
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_SET |
移除数组中的重复值。 | TO_SET() |
不适用 | 具有非重复值的数组。 |
示例 1:获取字符串数组的非重复值
示例数据:$var1$ = {"Hello","World","Apigee","World"}
用法:$var1$.TO_SET()
输出:{"Hello","World","Apigee"}
示例 2:获取整数数组的唯一值
示例数据:$var1$ = (2,6,9,12,6,8,10,6,12)
用法:$var1$.TO_SET()
输出:2,6,9,12,8,10
TO_STRING_ARRAY
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_STRING_ARRAY |
将 JSON 数组转换为字符串数组。 | TO_STRING_ARRAY() |
不适用 | 字符串数组。 |
示例:将 JSON 数组转换为字符串数组
示例数据:$var1$ = [[1, 2], [3, 4]]
用法:$var1$.TO_STRING_ARRAY()
输出:["[1, 2]", "[3, 4]"]
TO_STRING
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_STRING |
将数字或 JSON 转换为字符串。 | TO_STRING() |
不适用 | 它是一个字符串。 |
示例:将整数转换为字符串
示例数据:$var1$ = 235
用法:$var1$.TO_STRING()
输出:235
示例:将 JSON 转换为字符串
示例数据:
$var1$ = { "dbIntegers": [1.0, 2.0, 3.0, 4.0], "dbString": "test" }
用法:$var1$.TO_STRING()
输出结果:
{ "dbIntegers": [ 1, 2, 3, 4 ], "dbString": "test" }
TO_UPPERCASE
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
TO_UPPERCASE |
将字符串中的所有字符都转换为大写。 | TO_UPPERCASE() |
不适用 | 包含所有字母均为大写的字符串。 |
示例:将字符串转换为大写
示例数据:$var1$ = "Integrations Test"
用法:$var1$.TO_UPPERCASE()
输出:INTEGRATIONS TEST
XNOR
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
XNOR |
对指定的布尔值执行逻辑 XNOR 运算。 | XNOR(value) |
布尔值。 | 布尔值。 |
示例:查找布尔值表达式的 XNOR 值
示例数据:$var1$ = FALSE
用法:$var1$.XNOR(TRUE)
输出:FALSE
XOR
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
XOR |
对指定的布尔值执行逻辑 XOR 运算。 | XOR(value) |
布尔值。 | 布尔值。 |
示例:查找布尔值表达式的 XOR 值
示例数据:$var1$ = TRUE
用法:$var1$.XOR(FALSE)
输出:TRUE
支持的基本函数
GENERATE_UUID
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GENERATE_UUID |
生成随机 UUID。 | GENERATE_UUID() |
不适用 | 一个字符串 |
示例:生成 UUID。
用法:GENERATE_UUID()
输出:57547434-b572-4aaa-8da6-e6768850baa3
GET_EXECUTION_ID
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GET_EXECUTION_ID |
返回当前集成的执行 ID。 | GET_EXECUTION_ID() |
不适用 | 一个字符串 |
示例:获取当前集成执行的 ID。
用法:GET_EXECUTION_ID()
输出:83fb009a-0152-433d-a3b6-e38118335308
GET_INTEGRATION_NAME
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GET_INTEGRATION_NAME |
返回当前集成的名称。 | GET_INTEGRATION_NAME() |
不适用 | 一个字符串 |
示例:获取当前集成的名称。
用法:GET_INTEGRATION_NAME()
输出:demo_integration
GET_INTEGRATION_REGION
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GET_INTEGRATION_REGION |
返回当前集成的区域。 | GET_INTEGRATION_REGION() |
不适用 | 一个字符串 |
示例:获取当前集成的区域。
用法:GET_INTEGRATION_REGION()
输出:us-east1
GET_PROJECT_ID
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
GET_PROJECT_ID |
返回当前集成的 Google Cloud 项目 ID。 | GET_PROJECT_ID() |
不适用 | 一个字符串 |
示例:获取当前集成的 Google Cloud 项目 ID。
用法:GET_PROJECT_ID()
输出:demo-gcp-ip
INT_LIST
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
INT_LIST |
返回指定值之间的整数列表。返回的列表包含起始值,但不含结束值。 | INT_LIST(value, value) |
此函数接受以下参数:
|
一个整数数组 |
示例:生成一个介于 12 到 20 之间的整数数组。
用法:INT_LIST(“12”, “20”)
返回 12 到 20 之间的整数列表。
输出:12, 13, 14, 15, 16, 17, 18, 19
NOW_IN_MILLIS
函数
函数名称 | 说明 | 用量 | 输入参数 | 返回值 |
---|---|---|---|---|
NOW_IN_MILLIS |
返回集成的当前 Unix 纪元时间(以毫秒为单位)。 | NOW_IN_MILLIS() |
不适用 | Unix 纪元时间(以毫秒为单位) |
示例:获取当前的 Unix 纪元时间(以毫秒为单位),并将其转换为人类可读的格式。
用法:NOW_IN_MILLIS().EPOCH_TO_HUMAN_READABLE_TIME("d MMM yyyy HH:mm:ss:SSS z","GMT")
返回 Unix 纪元时间 1657783580839
,并将其转换为人类可读的格式。
输出:14 Jul 2022 07:26:20:839 GMT