数据映射函数参考文档

支持的映射函数

ADD 函数

函数名称 说明 用量 输入参数 返回值
ADD 将指定的数字与现有数字相加。 ADD(value) 要相加的数字。 两个数字的总和。

示例：将两个整数相加

示例数据：$var1$ = 15

用法：$var1$.ADD(5)

将 5 与 var1 相加。

输出：20

AND 函数

函数名称 说明 用量 输入参数 返回值
AND 对指定的布尔值执行逻辑 AND 运算。 AND(value) 布尔值。 布尔值。

示例：查找布尔值表达式的 AND 值

示例数据：$var1$ = TRUE

用法：$var1$.AND(TRUE)

查找布尔值表达式的 AND 值。

输出：TRUE

APPEND_ALL 函数

函数名称 说明 用量 输入参数 返回值
APPEND_ALL 将所有指定值附加到数组。 APPEND_ALL(value1, value2, ...) 要附加的值。

要附加的值的数据类型应与数组的数据类型相匹配。例如，对于 String 数组，您只能附加字符串值。

 带有附加值的数组。

示例 1：向整数数组附加值

示例数据：$var1$ = {3,6,8,1}

用法：$var1$.APPEND_ALL(7,9,15)

将值 7、9 和 15 附加到 var1。

输出：{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) 要附加的值。

要附加的值的数据类型应与数组的数据类型相匹配。例如，对于 Boolean 数组，您只能附加 True 或 False。

 带有附加值的数组。

示例 1：向整数数组附加值

示例数据：$var1$ = {3,6,8,1}

用法：$var1$.APPEND(7)

将值 7 附加到 var1。

输出：{3,6,8,1,7}

示例 2：向布尔值数组附加值。

示例数据：$var1$ = {True,False,True}

用法：$var1$.APPEND(True)

将值 True 附加到 var1。

输出：{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()

计算 var1 中值的平均值。

输出：4.5

示例 2：计算双精度型数组中所有值的平均值

示例数据：$var1$ = {2.0,6.1,3.9}

用法：$var1$.AVG()

计算 var1 中值的平均值。

输出：4.0

CEIL 函数

函数名称 说明 用量 输入参数 返回值
CEIL 计算大于或等于给定输入的最小整数。 CEIL() 不适用 它是一个整数。

示例：查找数字的上限。

示例数据：$var1$ = {3.4}

用法：$var1$.CEIL()

查找 var1 的上限。

输出：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")

检查 var1 中 xyz 的出现次数。

输出：FALSE

DECODE_BASE64_STRING 函数

函数名称 说明 用量 输入参数 返回值
DECODE_BASE64_STRING 将 base64 字符串解码为 UTF-8 字符集。 DECODE_BASE64_STRING() 不适用 解码的 UTF-8 字符串。

示例：对 base64 字符串进行解码

示例数据：$var1$ = "SGVsbG8gSW50ZWdyYXRpb24h"

用法：$var1$.DECODE_BASE64_STRING()

从 base64 格式对 var1 进行解码。

输出：Hello Integration!

DIVIDE 函数

函数名称 说明 用量 输入参数 返回值
DIVIDE 将现有数字除以指定数字。 DIVIDE(value) 除以数字（除数）。 除法运算的商。

示例：用一个整数除以另一个整数

示例数据：$var1$ = 16

用法：$var1$.DIVIDE(3)

用 var1 除以 3。

输出：5

EQUALS 函数

函数名称 说明 用量 输入参数 返回值
EQUALS 将指定值与现有值进行比较。 EQUALS(value) 要比较的值。 一个布尔值。如果指定的值与现有值匹配，则返回 TRUE，否则返回 FALSE。

示例 1：比较两个字符串

示例数据：$var1$ = "Apigee Integrations"

用法：$var1$.EQUALS("Apigee Integrations")

检查 var1 是否等于“Apigee Integrations”。

输出：TRUE

示例 2：比较两个整数

示例数据：$var1$ = 34

用法：$var1$.EQUALS(23)

检查 var1 是否等于 23。

输出：FALSE

EQUALS_IGNORE_CASE 函数

函数名称 说明 用量 输入参数 返回值
EQUALS_IGNORE_CASE 将指定值与现有值进行比较。 EQUALS_IGNORE_CASE(value) 要比较的值。 一个布尔值。如果指定的值与现有值匹配（忽略大小写），则返回 TRUE，否则返回 FALSE。

示例：比较两个字符串

示例数据：$var1$ = "Apigee Integrations"

用法：$var1$.EQUALS_IGNORE_CASE("apigee integrations")

检查 var1 是否等于 apigee integrations。

输出：TRUE

EPOCH_TO_HUMAN_READABLE_TIME 函数

函数名称 说明 用量 输入参数 返回值
EPOCH_TO_HUMAN_READABLE_TIME 将 Unix 纪元时间（以毫秒为单位）转换为人类可读的时间格式。 EPOCH_TO_HUMAN_READABLE_TIME (value, value) 此函数接受以下参数：
  • 第一个参数（字符串）：时间戳格式模式，例如 hh:mm:ss。
  • 第二个参数（字符串）：目标时区。

    有效值包括 UTC、具有偏移量的世界协调时间 (UTC)、GMT 和其他时区名称。

    只能以缩写形式指定 UTC 和 GMT 值。对于任何其他时区，必须指定完整的时区名称。例如，如果要指定“澳大利亚/墨尔本”时区，则必须指定 Australia/Melbourne 作为值，而不是指定 AEDT。如需查看时区名称的完整列表，请参阅 tz 数据库时区列表。

 转换为人类可读格式的时间戳。

示例：将 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)

var1 的 3 次幂的值。

输出：125

FILTER 函数

函数名称 说明 用量 输入参数 返回值
FILTER 过滤满足给定过滤条件的数组元素。

请注意，过滤条件的计算结果必须为 TRUE 或 FALSE。

过滤条件包括应用于当前数组迭代元素的一个或多个转换函数。

 FILTER(~objn -> Variable or Value)

其中 ~objn 表示要为其应用转换函数的当前数组元素。默认情况下，n 的值从 1 开始。

对于具有架构的 JSON 数组，您可以在当前数组元素后面使用点 (.) 表示法直接访问该数组元素的嵌套属性。例如 ~objn.PROPERTY。

计算结果为 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()

展平 var1。

输出：[1, 2, 3 ,4]

FLOOR 函数

函数名称 说明 用量 输入参数 返回值
FLOOR 计算小于或等于提供的输入的最大整数。 FLOOR() 不适用 它是一个整数。

示例：

示例数据：$var1$ = {27.6}

用法：$var1$.FLOOR()

查找 var1 的整数部分。

输出：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)

返回 var1 中索引 3 处的值。

输出：2

示例 2：获取字符串数组中某个索引处的值

示例数据：$var1$ = {"Hello", "Test", "Apigee", "Integrations", "API Trigger", "Cloud"}

用法：$var1$.GET(5)

返回索引 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)

检查 var1 是否大于或等于 15。

输出：TRUE

GREATER_THAN 函数

函数名称 说明 用量 输入参数 返回值
GREATER_THAN 检查现有数字是否大于指定数字。 GREATER_THAN(value) 要检查的数字。 一个布尔值。如果现有数字大于指定值，则返回 TRUE，否则返回 FALSE。

示例：检查某个整数是否大于指定值

示例数据：$var1$ = 25

用法：$var1$.GREATER_THAN(27)

检查 var1 是否大于 27。

输出：FALSE

LENGTH 函数

函数名称 说明 用量 输入参数 返回值
LENGTH 计算字符串的长度。字符串的长度是字符串中的字符数。 LENGTH() 不适用 字符串的长度。

示例：计算字符串的长度

示例数据：$var1$ = "Hello Apigee Test"

用法：$var1$.LENGTH()

计算字符串 var1 的长度。

输出：17

LESS_THAN_EQUAL_TO 函数

函数名称 说明 用量 输入参数 返回值
LESS_THAN_EQUAL_TO 检查某个整数是否小于或等于指定值。 LESS_THAN_EQUAL_TO(value) 要检查的整数值。 一个布尔值。如果整数小于或等于指定值，则返回 TRUE，否则返回 FALSE。

示例：检查某个整数是否小于或等于指定值

示例数据：$var1$ = 35

用法：$var1$.LESS_THAN_EQUAL_TO(15)

检查 var1 是否小于或等于 15。

输出：FALSE

LESS_THAN 函数

函数名称 说明 用量 输入参数 返回值
LESS_THAN 检查现有数字是否小于指定数字。 LESS_THAN(value) 要检查的数字。 一个布尔值。如果现有数字小于指定数字，则返回 TRUE，否则返回 FALSE。

示例：检查某个整数是否小于指定值

示例数据：$var1$ = 25

用法：$var1$.LESS_THAN(27)

检查 var1 是否小于 27。

输出：TRUE

MAX 函数

函数名称 说明 用量 输入参数 返回值
MAX 查找数组中的最大值。 MAX() 不适用 数组中的最大值。

示例 1：获取整数数组中的最大值

示例数据：$var1$ = {5,8,2,1}

用法：$var1$.MAX()

返回 var1 中的最大值。

输出：8

示例 2：获取双精度型数组中的最大值

示例数据：$var1$ = {2.5,6.1,4.9}

用法：$var1$.MAX()

返回 var1 中的最大值。

输出：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()

返回 var1 中的最小值。

输出：1

示例 2：查找双精度型数组中的最小值

示例数据：$var1$ = {2.5,6.1,4.9}

用法：$var1$.MIN()

返回 var1 中的最小值。

输出：2.5

MOD 函数

函数名称 说明 用量 输入参数 返回值
MOD 两个值相除，并返回除法运算的余数。 MOD(value) 除数的值。 除法运算的余数。

示例：查找除法运算的余数

示例数据：$var1$ = 90

用法：$var1$.MOD(3)

var1 除以 3。

输出：0

MULTIPLY 函数

函数名称 说明 用量 输入参数 返回值
MULTIPLY 将现有数字乘以指定数字。 MULTIPLY(value) 要相乘的数字。 两个数字的乘积。

示例：求出两个整数的乘积

示例数据：$var1$ = 10

用法：$var1$.MULTIPLY(3)

将 var1 乘以 3。

输出：30

NAND 函数

函数名称 说明 用量 输入参数 返回值
NAND 对指定的布尔值执行逻辑 NAND 运算。 NAND(value) 布尔值。 布尔值。

示例：查找布尔值表达式的 NAND 值

示例数据：$var1$ = TRUE

用法：$var1$.NAND(TRUE)

查找布尔值表达式的 NAND 值。

输出：FALSE

NOR 函数

函数名称 说明 用量 输入参数 返回值
NOR 对指定的布尔值执行逻辑 NOR 运算。 NOR(value) 布尔值。 布尔值。

示例：查找布尔值表达式的 NOR 值

示例数据：$var1$ = FALSE

用法：$var1$.NOR(FALSE)

查找布尔值表达式的 NOR 值。

输出：TRUE

NOT 函数

函数名称 说明 用量 输入参数 返回值
NOT 返回布尔值的相反值。 NOT() 不适用 布尔值。

示例：查找布尔值的相反值

示例数据：$var1$ = FALSE

用法：$var1$.NOT()

查找 var1 的 NOT 值。

输出：TRUE

OR 函数

函数名称 说明 用量 输入参数 返回值
OR 对指定的布尔值执行逻辑 OR 运算。 OR(value) 布尔值。 布尔值。

示例：查找布尔值表达式的 OR 值

示例数据：$var1$ = FALSE

用法：$var1$.OR(TRUE)

查找布尔值表达式的 OR 值。

输出：TRUE

REMOVE 函数

函数名称 说明 用量 输入参数 返回值
REMOVE 从数组中移除指定的值。 REMOVE(value) 要移除的值。 移除指定值后更新的数组。

示例：从字符串数组中移除字符串

示例数据：$var1$ = {"Hello","Apigee","Integrations"}

用法：$var1$.REMOVE("Integrations")

从 var1 中移除 Integrations

输出：{"Hello","Apigee"}

REMOVE_AT 函数

函数名称 说明 用量 输入参数 返回值
REMOVE_AT 从数组中移除指定索引位置的元素。 REMOVE_AT(value) 数组中的索引值。 移除指定元素后更新的数组。

示例：从字符串数组中移除元素

示例数据：$var1$ = {"Hello","Apigee","Integrations"}

用法：$var1$.REMOVE_AT(1)

移除 var1 中索引 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")

返回当前字符串“HelloApigee”，其中与“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()

将 var1 舍入到最接近的整数。

输出：16

SET 函数

函数名称 说明 用量 输入参数 返回值
SET 在指定索引位置更新字符串数组的值。 SET(value,value) 该函数采用下列参数：
  • 第一个参数（整数）：应在其位置更新值的字符串数组的索引。
  • 第二个参数：替换字符串。
 更新的字符串数组。

示例：在索引位置更新字符串数组的值

示例数据：$var1$ = {"Hello","World","Integrations"}

用法：$var1$.SET(2,"Apigee")

在索引 2 位置更新 var1。

输出：{"Hello","World","Apigee"}

SET_PROPERTY 函数

函数名称 说明 用量 输入参数 返回值
SET_PROPERTY 添加或更新 JSON 对象中的属性。 SET_PROPERTY(value) 属性名称和值。 包含新增属性或更新属性的 JSON 对象。

示例：向 JSON 对象添加属性

示例数据：$var1$ = {"productId":23}

用法：$var1$.SET_PROPERTY("radio","productName")

向 var1 添加属性。

输出：{"productId":23,"productName":"radio"}。

示例：向 JSON 对象添加嵌套属性

示例数据：$var1$ = {"productId":23}

用法：$var1$.SET_PROPERTY({"productName","radio"},"productDetails")

向 var1 添加嵌套属性。

输出：{"productId":23,"productDetails":{"productName":"radio"}}。

示例：更新 JSON 对象中的属性

示例数据：$var1$ = {"productId":23}

用法：$var1$.SET_PROPERTY("34","productId")

更新 var1 中的 productId 属性。

输出：{"productId":34}。

SIZE 函数

函数名称 说明 用量 输入参数 返回值
SIZE 计算数组中的元素数量。 SIZE() 不适用 数组中的元素总数。

示例 1：求出字符串数组的大小

示例数据：$var1$ = {"Hello", "Apigee", "Integrations"}

用法：$var1$.SIZE()

计算 var1 中的元素数量。

输出：3

示例 2：求出整数数组的大小

示例数据：$var1$ = {5,8,2,1,7}

用法：$var1$.SIZE()

计算 var1 中的元素数量。

输出：5

SPLIT 函数

函数名称 说明 用量 输入参数 返回值
SPLIT 根据指定的分隔符拆分字符串。 SPLIT(value) 用于拆分字符串的一个字符或一系列字符。 字符串数组。

示例 1：根据空格字符拆分字符串

示例数据：$var1$ = "Hello Apigee Integrations"

用法：$var1$.SPLIT(" ")

根据空格字符拆分 var1。

输出：{"Hello","Apigee","Integrations"}

示例 2：根据英文逗号拆分字符串

示例数据：$var1$ = "Test,Integrations"

用法：$var1$.SPLIT(",")

根据英文逗号字符拆分 var1。

输出：{"Test","Integrations"}

SUBSTRING 函数

函数名称 说明 用量 输入参数 返回值
SUBSTRING 返回从起始索引（含）到结束索引（不含）的当前字符串的子字符串。 SUBSTRING(value, value) 该函数采用下列参数：
  • 第一个参数：起始索引值。
  • 第二个参数：结束索引值。
 起始索引和结束索引之间的字符串。

示例：返回当前字符串的子字符串，从起始索引编号的字符开始，在结束索引编号的字符之前结束。

示例数据：$var1$ = "HelloApigee"

用法：$var1$.SUBSTRING(1, 5)

返回 var1 的子字符串。

输出：ello

SUBTRACT 函数

函数名称 说明 用量 输入参数 返回值
SUBTRACT 从现有数字中减去指定的数字。 SUBTRACT(value) 要减去的数字。 两个数字之差。

示例：减去一个整数值

示例数据：$var1$ = 10

用法：$var1$.SUBTRACT(15)

从 var1 中减去 15。

输出：-5

SUM 函数

函数名称 说明 用量 输入参数 返回值
SUM 将数组中的所有值相加。 SUM() 不适用 数组中所有数字的总和。返回类型取决于数组的类型。例如，对于 Double 类型的数组，返回值类型是双精度值。

示例：将整数数组的所有值相加

示例数据：$var1$ = {5,8,2,1}

用法：$var1$.SUM()

将 var1 中的所有值相加。

输出：16

TO_BASE_64 函数

函数名称 说明 用量 输入参数 返回值
TO_BASE_64 使用 UTF-8 字符集将字符串编码为 base64 格式。 TO_BASE_64() 不适用 使用 base64 编码的字符串。

示例：将字符串编码为 base64 格式

示例数据：$var1$ = "Hello World!"

用法：$var1$.TO_BASE_64()

采用 base64 格式对 var1 进行编码。

输出：SGVsbG8gV29ybGQh

TO_BOOLEAN_ARRAY 函数

函数名称 说明 用量 输入参数 返回值
TO_BOOLEAN_ARRAY 将 JSON 数组转换为布尔值数组。 TO_BOOLEAN_ARRAY() 不适用 布尔值数组。

示例：将 JSON 数组转换为布尔值数组

示例数据：$var1$ = ["true", "false", "false"]

用法：$var1$.TO_BOOLEAN_ARRAY()

将 var1 转换为布尔值数组。

输出：{true, false, false}

TO_BOOLEAN 函数

函数名称 说明 用量 输入参数 返回值
TO_BOOLEAN 将字符串转换为布尔值数据类型。 TO_BOOLEAN() 不适用 一个布尔值。如果字符串的值为 true 或 false，则此函数会返回相应的布尔值。

示例 1：获取字符串的布尔值

示例数据：$var1$ = "true"

用法：$var1$.TO_BOOLEAN()

获取 var1 的布尔值。

输出：TRUE

示例 2：获取字符串的布尔值

示例数据：$var1$ = "FALSE"

用法：$var1$.TO_BOOLEAN()

获取 var1 的布尔值。

输出：FALSE

TO_DOUBLE_ARRAY 函数

函数名称 说明 用量 输入参数 返回值
TO_DOUBLE_ARRAY 将 JSON 数组转换为双精度浮点数数组。 TO_DOUBLE_ARRAY() 不适用 双精度浮点数数组。

示例：将 JSON 数组转换为双精度浮点数数组

示例数据：$var1$ = [1.3, 4.8, 7.9]

用法：$var1$.TO_DOUBLE_ARRAY()

将 var1 转换为双精度浮点数数组。

输出：{1.3, 4.8, 7.9}

TO_DOUBLE 函数

函数名称 说明 用量 输入参数 返回值
TO_DOUBLE 将字符串或整数转换为双精度浮点数。 TO_DOUBLE() 不适用 双精度型。

示例 1：将字符串转换为双精度浮点数

示例数据：$var1$ = "2.5"

用法：$var1$.TO_DOUBLE()

将 var1 转换为双精度浮点数。

输出：2.5

示例 2：将整数转换为双精度浮点数

示例数据：$var1$ = 22

用法：$var1$.TO_DOUBLE()

将 var1 转换为双精度浮点数。

输出：22.0

TO_INT_ARRAY 函数

函数名称 说明 用量 输入参数 返回值
TO_INT_ARRAY 将 JSON 数组转换为整数数组。 TO_INT_ARRAY() 不适用 整数数组。

示例：将 JSON 数组转换为整数数组

示例数据：$var1$ = [3, 8, 9]

用法：$var1$.TO_INT_ARRAY()

将 var1 转换为整数数组。

输出：{3, 8, 9}

TO_INT 函数

函数名称 说明 用量 输入参数 返回值
TO_INT 将字符串转换为整数。 TO_INT() 不适用 它是一个整数。

示例：将字符串转换为整数

示例数据：$var1$ = "35"

用法：$var1$.TO_INT()

将 var1 转换为整数。

输出：35

TO_JSON 函数

函数名称 说明 用量 输入参数 返回值
TO_JSON 将当前值转换为 JSON 对象。 TO_JSON() 不适用 JSON 对象。

示例：将字符串转换为 JSON

示例数据：$var1$ = "{product: "cake", id: 21, price: 5}"

用法：$var1$.TO_JSON()

将 var1 转换为 JSON。

输出：{product: "cake", id: 21, price: 5}

TO_LOWERCASE 函数

函数名称 说明 用量 输入参数 返回值
TO_LOWERCASE 将字符串中的所有字符都转换为小写。 TO_LOWERCASE() 不适用 所有字符都是小写的字符串。

示例：将字符串转换为小写

示例数据：$var1$ = "Integrations TEST"

用法：$var1$.TO_LOWERCASE()

将 var1 转换为小写。

输出：integrations test

TO_SET 函数

函数名称 说明 用量 输入参数 返回值
TO_SET 移除数组中的重复值。 TO_SET() 不适用 具有非重复值的数组。

示例 1：获取字符串数组的非重复值

示例数据：$var1$ = {"Hello","World","Apigee","World"}

用法：$var1$.TO_SET()

获取 var1 中的唯一值。

输出：{"Hello","World","Apigee"}

示例 2：获取整数数组的唯一值

示例数据：$var1$ = (2,6,9,12,6,8,10,6,12)

用法：$var1$.TO_SET()

获取 var1 中的唯一值。

输出：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()

将 var1 转换为字符串数组。

输出：["[1, 2]", "[3, 4]"]

TO_STRING 函数

函数名称 说明 用量 输入参数 返回值
TO_STRING 将数字或 JSON 转换为字符串。 TO_STRING() 不适用 它是一个字符串。

示例：将整数转换为字符串

示例数据：$var1$ = 235

用法：$var1$.TO_STRING()

将 var1 转换为字符串。

输出：235

示例：将 JSON 转换为字符串

示例数据： 

$var1$ =
{
  "dbIntegers": [1.0, 2.0, 3.0, 4.0],
  "dbString": "test"
}

用法：$var1$.TO_STRING()

将 var1 转换为字符串。

输出结果： 

{
  "dbIntegers": [
    1,
    2,
    3,
    4
  ],
  "dbString": "test"
}

TO_UPPERCASE 函数

函数名称 说明 用量 输入参数 返回值
TO_UPPERCASE 将字符串中的所有字符都转换为大写。 TO_UPPERCASE() 不适用 包含所有字母均为大写的字符串。

示例：将字符串转换为大写

示例数据：$var1$ = "Integrations Test"

用法：$var1$.TO_UPPERCASE()

将 var1 转换为大写。

输出：INTEGRATIONS TEST

XNOR 函数

函数名称 说明 用量 输入参数 返回值
XNOR 对指定的布尔值执行逻辑 XNOR 运算。 XNOR(value) 布尔值。 布尔值。

示例：查找布尔值表达式的 XNOR 值

示例数据：$var1$ = FALSE

用法：$var1$.XNOR(TRUE)

查找布尔值表达式的 XNOR 值。

输出：FALSE

XOR 函数

函数名称 说明 用量 输入参数 返回值
XOR 对指定的布尔值执行逻辑 XOR 运算。 XOR(value) 布尔值。 布尔值。

示例：查找布尔值表达式的 XOR 值

示例数据：$var1$ = TRUE

用法：$var1$.XOR(FALSE)

查找布尔值表达式的 XOR 值。

输出：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